spring+memcache实践实例

配置文件：

<bean id="memcachedPool" class="com.danga.MemCached.SockIOPool"
factory-method="getInstance" init-method="initialize" destroy-method="shutDown">
<constructor-arg>
<value>neeaMemcachedPool</value>
</constructor-arg>
<property name="servers">
<list>
<value>127.0.0.1:11211</value>
</list>
</property>
<property name="initConn">
<value>20</value>
</property>
<property name="minConn">
<value>10</value>
</property>
<property name="maxConn">
<value>50</value>
</property>
<property name="maintSleep">
<value>30</value>
</property>
<property name="nagle">
<value>false</value>
</property>
<property name="socketTO">
<value>3000</value>
</property>
</bean>

<bean id="memcachedClient" class="com.danga.MemCached.MemCachedClient">
<constructor-arg>
<value>neeaMemcachedPool</value>
</constructor-arg>
<property name="primitiveAsString">
<value>true</value>
</property>
<property name="defaultEncoding">
<value>utf-8</value>
</property>
<property name="compressEnable">
<value>true</value>
</property>
<property name="compressThreshold">
<value>4096</value>
</property>
</bean>

服务接口：
public interface MemcachedService {

public MemCachedClient getMemCachedClient();

public void setMemCachedClient(MemCachedClient memCachedClient);

public boolean removeCached(String key);

public void addCached(String key, Object value);

public void addCached(String key, Object value, Date exTime);

/**
* 放入缓存
*
* @param key
* @param value
*/
public void setCached(String key, Object value);

/**
* 放入缓存并且指定缓存时间
*
* @param key
* @param value
* @param time
*/
// public void setCached(String key, Object value, int time) {
// memCachedClient.set(key, value, time);
// }

public void setCached(String key, Object value, Date time);

/**
* 取缓存
*
* @param key
* @return
*/
public Object getCached(String key);

/**
* 清空缓存 慎用
*/
public void clearCached();

@SuppressWarnings("rawtypes")
public Set filterCachedKey(String keyStart);
}
接口实现：

@Service("memcachedService")
public class MemcachedServiceImpl implements MemcachedService, Serializable {

private static final long serialVersionUID = 3637897902641513553L;

@Resource
MemCachedClient memCachedClient;

private static final Log log = LogFactory.getLog(MemcachedServiceImpl.class);

@Override
public MemCachedClient getMemCachedClient() {
return memCachedClient;
}

public void setMemCachedClient(MemCachedClient memCachedClient) {

this.memCachedClient = memCachedClient;

// 序列化
if (this.memCachedClient != null) {
this.memCachedClient.setPrimitiveAsString(true);
}

log.debug(memCachedClient);
}

public boolean removeCached(String key) {
log.debug("移出 key:" + key + " 的缓存");
return memCachedClient.delete(key);
}

public void addCached(String key, Object value) {
log.debug("存入key:" + key + "的缓存 ");
memCachedClient.add(key, value, Integer.MAX_VALUE);
}

public void addCached(String key, Object value, Date exTime) {
try {
log.debug("存入key:" + key + "的缓存，过期时间为" + DateUtil.getFormatDate(exTime, "yyyy-MM-dd HH:mm:ss"));
} catch (ParseException e) {
e.printStackTrace();
}
memCachedClient.add(key, value, exTime);
}

/**
* 放入缓存
*
* @param key
* @param value
*/
public void setCached(String key, Object value) {
log.debug("存入key:" + key + "的缓存 ");
memCachedClient.set(key, value, Integer.MAX_VALUE);
}

/**
* 放入缓存并且指定缓存时间
*
* @param key
* @param value
* @param time
*/
public void setCached(String key, Object value, int time) {
memCachedClient.set(key, value, time);
}

// /**
// * 放入缓存并且指定缓存时间
// *
// * @param key
// * @param value
// * @param time 有效期，单位为 毫秒
// */
// public void setCached(String key, Object value, int time) {
// memCachedClient.set(key, value, new Date(time));
// }

public void setCached(String key, Object value, Date time) {
try {
log.debug("存入key:" + key + "的缓存，过期时间为" + DateUtil.getFormatDate(time, "yyyy-MM-dd HH:mm:ss"));
} catch (ParseException e) {
e.printStackTrace();
}
memCachedClient.set(key, value, time);
}

/**
* 取缓存
*
* @param key
* @return
*/
public Object getCached(String key) {
log.debug(">>>>>>>>>>> [ from cached ] 取出key:" + key + "的缓存 ");
return memCachedClient.get(key);
}

/**
* 清空缓存 慎用
*/
public void clearCached() {
memCachedClient.flushAll();
}

/**
*
* 从memcached 中检索以指定key为开头的一组key值
*/
@SuppressWarnings("rawtypes")
public Set filterCachedKey(String keyStart) {
Set<String> keys = new HashSet<String>();
try {
int limit = 0;

Map<String, Integer> dumps = new HashMap<String, Integer>();

Map slabs = memCachedClient.statsItems();
if (slabs != null && slabs.keySet() != null) {
Iterator itemsItr = slabs.keySet().iterator();
while (itemsItr.hasNext()) {
String server = itemsItr.next().toString();
Map itemNames = (Map)slabs.get(server);
Iterator itemNameItr = itemNames.keySet().iterator();
while (itemNameItr.hasNext()) {
String itemName = itemNameItr.next().toString();
// itemAtt[0]=itemname
// itemAtt[1]=number
// itemAtt[2]=field
String[] itemAtt = itemName.split(":");

if (itemAtt[2].startsWith("number"))
dumps.put(itemAtt[1], Integer.parseInt(itemAtt[1]));

}
}
if (!dumps.values().isEmpty()) {
Iterator<Integer> dumpIter = dumps.values().iterator();
while (dumpIter.hasNext()) {
int dump = dumpIter.next();

Map cacheDump = memCachedClient.statsCacheDump(dump, limit);
Iterator entryIter = cacheDump.values().iterator();
while (entryIter.hasNext()) {
Map items = (Map)entryIter.next();
Iterator ks = items.keySet().iterator();
while (ks.hasNext()) {
String k = (String)ks.next();
if (k.startsWith(keyStart) && this.memCachedClient.keyExists(k)) {
keys.add(k);
}
}
}
}
}

}
} catch (Exception ex) {
log.debug(ex.toString());
}
return keys;

}
}