XMemcached与Spring3.2缓存框架集成

从Spring3.1开始,增加了抽像缓存框架,利用Spring3.1提供的注释,可以很方便的使用缓存,Spring官方给出基于Map和 EHCache的实现,正好最近在用Memcached,参考了EHCacheCacheManager的源码,写了一个基于XMemcached的 MemcachedCacheManager。

 

直接上代码(注:只支持Spring3.2以上版本)

 

 

 

1、MemcachedCacheManager.java

 

Java代码 复制代码  收藏代码
  1. public class MemcachedCacheManager extends AbstractTransactionSupportingCacheManager   
  2. {   
  3.     private ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<String, Cache>();   
  4.     private Map<String, Integer> expireMap = new HashMap<String, Integer>();   
  5.   
  6.     private MemcachedClient memcachedClient;   
  7.   
  8.     public MemcachedCacheManager()   
  9.     {   
  10.     }   
  11.   
  12.     @Override  
  13.     protected Collection<? extends Cache> loadCaches()   
  14.     {   
  15.         Collection<Cache> values = cacheMap.values();   
  16.         return values;   
  17.     }   
  18.   
  19.     @Override  
  20.     public Cache getCache(String name)   
  21.     {   
  22.         Cache cache = cacheMap.get(name);   
  23.         if (cache == null)   
  24.         {   
  25.             Integer expire = expireMap.get(name);   
  26.             if (expire == null)   
  27.             {   
  28.                 expire = 0;   
  29.                 expireMap.put(name, expire);   
  30.             }   
  31.                
  32.             cache = new MemcachedCache(name, expire.intValue(), memcachedClient);   
  33.             cacheMap.put(name, cache);   
  34.         }   
  35.         return cache;   
  36.     }   
  37.   
  38.     public void setMemcachedClient(MemcachedClient memcachedClient)   
  39.     {   
  40.         this.memcachedClient = memcachedClient;   
  41.     }   
  42.   
  43.     public void setConfigMap(Map<String, Integer> configMap)   
  44.     {   
  45.         this.expireMap = configMap;   
  46.     }   
  47.   
  48. }  

 

 2、MemcachedCache.java

 

 

 

Java代码 复制代码  收藏代码
  1. public class MemcachedCache implements Cache   
  2. {   
  3.     private final String name;   
  4.     private final MemcachedClient memcachedClient;   
  5.     private final MemCache memCache;   
  6.        
  7.     public MemcachedCache(String name, int expire, MemcachedClient memcachedClient)   
  8.     {   
  9.         this.name = name;   
  10.         this.memcachedClient = memcachedClient;    
  11.         this.memCache = new MemCache(name, expire, memcachedClient);   
  12.     }   
  13.   
  14.     @Override  
  15.     public void clear()   
  16.     {   
  17.         memCache.clear();   
  18.     }   
  19.   
  20.     @Override  
  21.     public void evict(Object key)   
  22.     {   
  23.         memCache.delete(key.toString());   
  24.     }   
  25.   
  26.     @Override  
  27.     public ValueWrapper get(Object key)   
  28.     {   
  29.         ValueWrapper wrapper = null;   
  30.         Object value = memCache.get(key.toString());   
  31.         if (value != null)   
  32.         {   
  33.             wrapper = new SimpleValueWrapper(value);   
  34.         }   
  35.         return wrapper;   
  36.     }   
  37.   
  38.     @Override  
  39.     public String getName()   
  40.     {   
  41.         return this.name;   
  42.     }   
  43.   
  44.     @Override  
  45.     public MemcachedClient getNativeCache()   
  46.     {   
  47.         return this.memcachedClient;   
  48.     }   
  49.   
  50.     @Override  
  51.     public void put(Object key, Object value)   
  52.     {   
  53.         memCache.put(key.toString(), value);   
  54.     }   
  55. }  

 

 3、MemCache.java

 

Java代码 复制代码  收藏代码
  1. public class MemCache   
  2. {   
  3.     private static Logger log = LoggerFactory.getLogger(MemCache.class);   
  4.   
  5.     private Set<String> keySet = new HashSet<String>();   
  6.     private final String name;   
  7.     private final int expire;   
  8.     private final MemcachedClient memcachedClient;   
  9.   
  10.     public MemCache(String name, int expire, MemcachedClient memcachedClient)   
  11.     {   
  12.         this.name = name;   
  13.         this.expire = expire;   
  14.         this.memcachedClient = memcachedClient;   
  15.     }   
  16.   
  17.     public Object get(String key)   
  18.     {   
  19.         Object value = null;   
  20.         try  
  21.         {   
  22.             key = this.getKey(key);   
  23.             value = memcachedClient.get(key);   
  24.         }   
  25.         catch (TimeoutException e)   
  26.         {   
  27.             log.warn("获取 Memcached 缓存超时", e);   
  28.         }   
  29.         catch (InterruptedException e)   
  30.         {   
  31.             log.warn("获取 Memcached 缓存被中断", e);   
  32.         }   
  33.         catch (MemcachedException e)   
  34.         {   
  35.             log.warn("获取 Memcached 缓存错误", e);   
  36.         }   
  37.         return value;   
  38.     }   
  39.   
  40.     public void put(String key, Object value)   
  41.     {   
  42.         if (value == null)   
  43.             return;   
  44.   
  45.         try  
  46.         {   
  47.             key = this.getKey(key);   
  48.             memcachedClient.setWithNoReply(key, expire, value);   
  49.             keySet.add(key);   
  50.         }   
  51.         catch (InterruptedException e)   
  52.         {   
  53.             log.warn("更新 Memcached 缓存被中断", e);   
  54.         }   
  55.         catch (MemcachedException e)   
  56.         {   
  57.             log.warn("更新 Memcached 缓存错误", e);   
  58.         }   
  59.     }   
  60.        
  61.        
  62.     public void clear()   
  63.     {   
  64.         for (String key : keySet)   
  65.         {   
  66.             try  
  67.             {   
  68.                 memcachedClient.deleteWithNoReply(this.getKey(key));   
  69.             }   
  70.             catch (InterruptedException e)   
  71.             {   
  72.                 log.warn("删除 Memcached 缓存被中断", e);   
  73.             }   
  74.             catch (MemcachedException e)   
  75.             {   
  76.                 log.warn("删除 Memcached 缓存错误", e);   
  77.             }   
  78.         }   
  79.     }   
  80.        
  81.        
  82.     public void delete(String key)   
  83.     {   
  84.         try  
  85.         {   
  86.             key = this.getKey(key);   
  87.             memcachedClient.deleteWithNoReply(key);   
  88.         }   
  89.         catch (InterruptedException e)   
  90.         {   
  91.             log.warn("删除 Memcached 缓存被中断", e);   
  92.         }   
  93.         catch (MemcachedException e)   
  94.         {   
  95.             log.warn("删除 Memcached 缓存错误", e);   
  96.         }   
  97.     }   
  98.        
  99.        
  100.     private String getKey(String key)   
  101.     {   
  102.         return name + "_" + key;   
  103.     }   
  104. }  

 

 4、配置文件 

 

Xml代码 复制代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xmlns:cache="http://www.springframework.org/schema/cache"  
  5.     xsi:schemaLocation="   
  6.         http://www.springframework.org/schema/beans   
  7.         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd   
  8.         http://www.springframework.org/schema/cache   
  9.         http://www.springframework.org/schema/cache/spring-cache-3.2.xsd"   
  10.         default-autowire="byName">  
  11.        
  12.     <bean id="memcachedClientBuilder" class="net.rubyeye.xmemcached.XMemcachedClientBuilder">  
  13.         <constructor-arg>  
  14.             <list>  
  15.                 <bean class="java.net.InetSocketAddress">  
  16.                     <constructor-arg value="localhost"/>  
  17.                     <constructor-arg value="11211"/>  
  18.                 </bean>  
  19.             </list>  
  20.         </constructor-arg>  
  21.         <property name="connectionPoolSize" value="5"/>  
  22.         <property name="commandFactory">  
  23.             <bean class="net.rubyeye.xmemcached.command.BinaryCommandFactory"/>  
  24.         </property>  
  25.         <property name="transcoder">  
  26.             <bean class="net.rubyeye.xmemcached.transcoders.SerializingTranscoder" />  
  27.         </property>  
  28.     </bean>  
  29.        
  30.     <bean id="memcachedClient" factory-bean="memcachedClientBuilder" factory-method="build" destroy-method="shutdown"/>  
  31.        
  32.     <bean id="cacheManager" class="xxx.MemcachedCacheManager">  
  33.         <property name="memcachedClient" ref="memcachedClient" />  
  34.         <property name="configMap">  
  35.             <map>  
  36.                 <!-- key:@Cacheable、@CachePut、@CacheEvict等的name属性。value:缓存过期时间(单位:秒),默认值:0 -->  
  37.                 <entry key="typeList" value="3600" />  
  38.             </map>  
  39.         </property>  
  40.     </bean>  
  41.        
  42.     <cache:annotation-driven cache-manager="cacheManager"/>  
  43.        
  44. </beans>  

 至于如何使用Spring的@Cachable,google上一大堆,我就不再重复了。

你可能感兴趣的:(xmemcached)