Java环境下Memcached实际运用详解

windows下的Server端很简单，不用安装，双击运行后默认服务端口是11211，没有试着去更改端口，因为反正以后会用unix版本，到时再记录安装步骤。下载客户端的javaAPI包，接口非常简单，参考API手册上就有现成的例子。ITPUB个人空间T {]:eJ
ITPUB个人空间E&bH8\[a'U!w
目标，对旧框架缓存部分进行改造：ITPUB个人空间5W%M8YRw:z:~
1、缓存工具类
:Ob F6IG)K2I02、hibernate的provider
t*G,iKxRK03、用缓存实现session机制
"{ CY t:g1jyn0
u v0W1}}5x0今天先研究研究缓存工具类的改造，在旧框架中部分函数用了ehcache对执行结果进行了缓存处理，现在目标是提供一个缓存工具类，在配置文件中配置使用哪种缓存（memcached或ehcached），使其它程序对具体的缓存不依赖，同时使用AOP方式来对方法执行结果进行缓存。
E!U~CQ%H8N?&T.Y0首先是工具类的实现：ITPUB个人空间bp%@3Ef iZ#Z
在Spring中配置
g~'d%q`*d?_0
Java代码

class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">

classpath:ehcache.xml



class="org.springframework.cache.ehcache.EhCacheFactoryBean">

value="×××.cache.LOCAL_CACHE" />


class="×××.core.cache.CacheService" init-method="init" destroy-method="destory">






class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">

classpath:ehcache.xml



class="org.springframework.cache.ehcache.EhCacheFactoryBean">

value="×××.cache.LOCAL_CACHE" />


class="×××.core.cache.CacheService" init-method="init" destroy-method="destory">




在properties文件中配置${cache.servers} ${cache.cacheServerWeights} ${cache.cluster}
YYPGx'r!cH$SQ0具体工具类的代码ITPUB个人空间 _ A+n/g b~"y(E

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();
}
}
}ITPUB个人空间~+v]^8QWHQ!J
然后实现函数的AOP拦截类，用来在函数执行前返回缓存内容ITPUB个人空间L9a m{em0w

Java代码
public class CachingInterceptor implements MethodInterceptor {

private CacheService cacheService;
private String cacheKey;

public void setCacheKey(String cacheKey) {
this.cacheKey = cacheKey;
}

public void setCacheService(CacheService cacheService) {
this.cacheService = cacheService;
}

public Object invoke(MethodInvocation invocation) throws Throwable {
Object result = cacheService.get(cacheKey);
//如果函数返回结果不在Cache中,执行函数并将结果放入Cache
if (result == null) {
result = invocation.proceed();
cacheService.put(cacheKey,result);
}
return result;
}
}
public class CachingInterceptor implements MethodInterceptor {

private CacheService cacheService;
private String cacheKey;

public void setCacheKey(String cacheKey) {
this.cacheKey = cacheKey;
}

public void setCacheService(CacheService cacheService) {
this.cacheService = cacheService;
}

public Object invoke(MethodInvocation invocation) throws Throwable {
Object result = cacheService.get(cacheKey);
//如果函数返回结果不在Cache中,执行函数并将结果放入Cache
if (result == null) {
result = invocation.proceed();
cacheService.put(cacheKey,result);
}
return result;
}
}Spring的AOP配置如下：
6P$^g5[&@X]'Y0
Java代码

pointcut="execution(* ×××.PoiService.getOne(..))"
advice-ref="PoiServiceCachingAdvice" />


class="×××.core.cache.CachingInterceptor">