class="×××.core.cache.CacheService" init-method="init" destroy-method="destory">
bean>
在properties文件中配置${cache.servers}${cache.cacheServerWeights}${cache.cluster}
具体工具类的代码
Java代码
/**
* @author Marc
*
*/
public class CacheService {
private Log logger = LogFactory.getLog（getClass（））;
private Cache localCache;
String cacheServerList;
String cacheServerWeights;
boolean cacheCluster = false;
int initialConnections = 10;
int minSpareConnections = 5;
int maxSpareConnections = 50;
long maxIdleTime = 1000 * 60 * 30; // 30 minutes
long maxBusyTime = 1000 * 60 * 5; // 5 minutes
long maintThreadSleep = 1000 * 5; // 5 seconds
int socketTimeOut = 1000 * 3; // 3 seconds to block on reads
int socketConnectTO = 1000 * 3; // 3 seconds to block on initial
// connections. If 0, then will use blocking
// connect （default）
boolean failover = false; // turn off auto-failover in event of server
// down
boolean nagleAlg = false; // turn off Nagle's algorithm on all sockets in
// pool
MemCachedClient mc;
public CacheService（）{
mc = new MemCachedClient（）;
mc.setCompressEnable（false）;
}
/**
* 放入
*
*/
public void put（String key, Object obj） {
Assert.hasText（key）;
Assert.notNull（obj）;
Assert.notNull（localCache）;
if （this.cacheCluster） {
mc.set（key, obj）;
} else {
Element element = new Element（key, （Serializable） obj）;
localCache.put（element）;
}
}
/**
* 删除
*/
public void remove（String key）{
Assert.hasText（key）;
Assert.notNull（localCache）;
if （this.cacheCluster） {
mc.delete（key）;
}else{
localCache.remove（key）;
}
}
/**
* 得到
*/
public Object get（String key） {
Assert.hasText（key）;
Assert.notNull（localCache）;
Object rt = null;
if （this.cacheCluster） {
rt = mc.get（key）;
} else {
Element element = null;
try {
element = localCache.get（key）;
} catch （CacheException cacheException） {
throw new DataRetrievalFailureException（"Cache failure:
"
+ cacheException.getMessage（））;
}
if（element !
= null）
rt = element.getValue（）;
}
return rt;
}
/**
* 判断是否存在
*
*/
public boolean exist（String key）{
Assert.hasText（key）;
Assert.notNull（localCache）;
if （this.cacheCluster） {
return mc.keyExists（key）;
}else{
return this.localCache.isKeyInCache（key）;
}
}
private void init（） {
if （this.cacheCluster） {
String[] serverlist = cacheServerList.split（","）;
Integer[] weights = this.split（cacheServerWeights）;
// initialize the pool for memcache servers
SockIOPool pool = SockIOPool.getInstance（）;
pool.setServers（serverlist）;
pool.setWeights（weights）;
pool.setInitConn（initialConnections）;
pool.setMinConn（minSpareConnections）;
pool.setMaxConn（maxSpareConnections）;
pool.setMaxIdle（maxIdleTime）;
pool.setMaxBusyTime（maxBusyTime）;
pool.setMaintSleep（maintThreadSleep）;
pool.setSocketTO（socketTimeOut）;
pool.setSocketConnectTO（socketConnectTO）;
pool.setNagle（nagleAlg）;
pool.setHashingAlg（SockIOPool.NEW_COMPAT_HASH）;
pool.initialize（）;
logger.info（"初始化memcached pool!
"）;
}
}
private void destory（） {
if （this.cacheCluster） {
SockIOPool.getInstance（）.shutDown（）;
}
}
}
/**
* @author Marc
*
*/
public class CacheService {
private Log logger = LogFactory.getLog（getClass（））;
private Cache localCache;
String cacheServerList;
String cacheServerWeights;
boolean cacheCluster = false;
int initialConnections = 10;
int minSpareConnections = 5;
int maxSpareConnections = 50;
long maxIdleTime = 1000 * 60 * 30; // 30 minutes
long maxBusyTime = 1000 * 60 * 5; // 5 minutes
long maintThreadSleep = 1000 * 5; // 5 seconds
int socketTimeOut = 1000 * 3; // 3 seconds to block on reads
int socketConnectTO = 1000 * 3; // 3 seconds to block on initial
// connections. If 0, then will use blocking
// connect （default）
boolean failover = false; // turn off auto-failover in event of server
// down
boolean nagleAlg = false; // turn off Nagle's algorithm on all sockets in
// pool
MemCachedClient mc;
public CacheService（）{
mc = new MemCachedClient（）;
mc.setCompressEnable（false）;
}
/**
* 放入
*
*/
public void put（String key, Object obj） {
Assert.hasText（key）;
Assert.notNull（obj）;
Assert.notNull（localCache）;
if （this.cacheCluster） {
mc.set（key, obj）;
} else {
Element element = new Element（key, （Serializable） obj）;
localCache.put（element）;
}
}
/**
* 删除
*/
public void remove（String key）{
Assert.hasText（key）;
Assert.notNull（localCache）;
if （this.cacheCluster） {
mc.delete（key）;
}else{
localCache.remove（key）;
}
}
/**
* 得到
*/
public Object get（String key） {
Assert.hasText（key）;
Assert.notNull（localCache）;
Object rt = null;
if （this.cacheCluster） {
rt = mc.get（key）;
} else {
Element element = null;
try {
element = localCache.get（key）;
} catch （CacheException cacheException） {
throw new DataRetrievalFailureException（"Cache failure:
"
+ cacheException.getMessage（））;
}
if（element !
= null）
rt = element.getValue（）;
}
return rt;
}
/**
* 判断是否存在
*
*/
public boolean exist（String key）{
Assert.hasText（key）;
Assert.notNull（localCache）;
if （this.cacheCluster） {
return mc.keyExists（key）;
}else{
return this.localCache.isKeyInCache（key）;
}
}
private void init（） {
if （this.cacheCluster） {
String[] serverlist = cacheServerList.split（","）;
Integer[] weights = this.split（cacheServerWeights）;
// initialize the pool for memcache servers
SockIOPool pool = SockIOPool.getInstance（）;
pool.setServers（serverlist）;
pool.setWeights（weights）;
pool.setInitConn（initialConnections）;
pool.setMinConn（minSpareConnections）;
pool.setMaxConn（maxSpareConnections）;
pool.setMaxIdle（maxIdleTime）;
pool.setMaxBusyTime（maxBusyTime）;
pool.setMaintSleep（maintThreadSleep）;
pool.setSocketTO（socketTimeOut）;
pool.setSocketConnectTO（socketConnectTO）;
pool.setNagle（nagleAlg）;
pool.setHashingAlg（SockIOPool.NEW_COMPAT_HASH）;
pool.initialize（）;
logger.info（"初始化memcachedpool!
"）;
}
}
private void destory（） {
if （this.cacheCluster） {
SockIOPool.getInstance（）.shutDown（）;
}
}
}
然后实现函数的AOP拦截类，用来在函数执行前返回缓存内容
Java代码
public class CachingInterceptor implements MethodInterceptor {
private CacheService cacheService;
private String cacheKey;
public void setCacheKey（String cacheKey） {
this.cacheKey = cacheKey;
升级会员 