Java使用Memcached

最新推荐文章于 2021-02-16 18:01:51 发布

不能飞的肥燕

最新推荐文章于 2021-02-16 18:01:51 发布

阅读量1.5k

点赞数

CC 4.0 BY-SA版权

分类专栏： Architect 中间件文章标签： memcached java string class object aop

本文链接：https://blog.youkuaiyun.com/haydenwang8287/article/details/5716365

Architect 同时被 2 个专栏收录

67 篇文章

订阅专栏

中间件

63 篇文章

订阅专栏

在设计互联网系统架构时，作者详细介绍了如何选择并整合memcached作为远程缓存解决方案，以及如何通过Spring框架实现AOP方式的缓存功能。通过调整现有框架，作者成功实现了缓存工具类、hibernate provider和session机制的改造，为提高系统性能和稳定性提供了有力支持。

这些天在设计SNA的架构，接触了一些远程缓存、集群、session复制等的东西，以前做企业应用的时候感觉作用不大，现在设计面对internet的系统架构时就非常有用了，而且在调试后看到压力测试的情况还是比较爽的。
4uV^M*b.W(d0在缓存的选择上有过很多的思考，虽然说memcached结合java在序列化上性能不怎么样，不过也没有更好的集群环境下的缓存解决方案了，就选择了memcached。本来计划等公司买的服务器到位装个linux再来研究memcached，但这两天在找到了一个windows下的Memcached版本，就动手开始调整现有的框架了。

windows下的Server端很简单，不用安装，双击运行后默认服务端口是11211，没有试着去更改端口，因为反正以后会用unix版本，到时再记录安装步骤。下载客户端的javaAPI包，接口非常简单，参考API手册上就有现成的例子。

目标，对旧框架缓存部分进行改造：

1、缓存工具类
2、hibernate的provider
3、用缓存实现session机制
今天先研究研究缓存工具类的改造，在旧框架中部分函数用了ehcache对执行结果进行了缓存处理，现在目标是提供一个缓存工具类，在配置文件中配置使用哪种缓存（memcached或ehcached），使其它程序对具体的缓存不依赖，同时使用AOP方式来对方法执行结果进行缓存。
首先是工具类的实现：
在Spring中配置
 <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"> <property name="configLocation"> <value>classpath:ehcache.xml</value> </property> </bean> <bean id="localCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean"> <property name="cacheManager" ref="cacheManager" /> <property name="cacheName" value="×××.cache.LOCAL_CACHE" /> </bean> <bean id="cacheService" class="×××.core.cache.CacheService" init-method="init" destroy-method="destory"> <property name="cacheServerList" value="${cache.servers}"/> <property name="cacheServerWeights" value="${cache.cacheServerWeights}"/> <property name="cacheCluster" value="${cache.cluster}"/> <property name="localCache" ref="localCache"/> </bean>  <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"> <property name="configLocation"> <value>classpath:ehcache.xml</value> </property> </bean> <bean id="localCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean"> <property name="cacheManager" ref="cacheManager" /> <property name="cacheName" value="×××.cache.LOCAL_CACHE" /> </bean> <bean id="cacheService" class="×××.core.cache.CacheService" init-method="init" destroy-method="destory"> <property name="cacheServerList" value="${cache.servers}"/> <property name="cacheServerWeights" value="${cache.cacheServerWeights}"/> <property name="cacheCluster" value="${cache.cluster}"/> <property name="localCache" ref="localCache"/> </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();   
        }   
    }   
}

AOP拦截类

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配置如下：

http://space.itpub.net/583467/viewspace-614201