Memcached之——Memcached与Spring提供的cache接口整合

spring 从3.x就提供了cache接口，spring默认实现的缓存是ehcache，spring的cache接口：

1. public interface Cache {  
2.     String getName();  
3.     Object getNativeCache();  
4.     ValueWrapper get(Object key);  
5.     <T> T get(Object key, Class<T> type);  
6.     void put(Object key, Object value);  
7.     void evict(Object key);  
8.     void clear();  
9.     interface ValueWrapper {  
10.         Object get();  
11.     }  
12. }  

从spring的cache接口，我们可以看出spring的cache模型就是在内存中画一片内存区域出来，为这盘内存指定名称，在这盘内存区域中以key-value的方式存放数据，画个图来说明cache的存取方式，用户和部门的缓存，名称分别为DepartCache和UserCache

 

1. 要使用spring的cache，首先要实现cacheManager， 可以参考spring对ehcache的实现，整合memcached的代码如下：

 

1. /** 
2.  * Spring Cache整合Memcached实现  
3.  * @author liuyazhuang 
4.  */  
5. public class MemcachedCacheManager extends AbstractTransactionSupportingCacheManager {  
6.   
7.     private ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<String, Cache>();  
8.     private Map<String, Integer> expireMap = new HashMap<String, Integer>();   //缓存的时间  
9.     private MemcachedClient memcachedClient;   //xmemcached的客户端  
10.   
11.     public MemcachedCacheManager() {  
12.     }  
13.   
14.     @Override  
15.     protected Collection<? extends Cache> loadCaches() {  
16.         Collection<Cache> values = cacheMap.values();  
17.         return values;  
18.     }  
19.   
20.     @Override  
21.     public Cache getCache(String name) {  
22.         Cache cache = cacheMap.get(name);  
23.         if (cache == null) {  
24.             Integer expire = expireMap.get(name);  
25.             if (expire == null) {  
26.                 expire = 0;  
27.                 expireMap.put(name, expire);  
28.             }  
29.             cache = new MemcachedCache(name, expire.intValue(), memcachedClient);  
30.             cacheMap.put(name, cache);  
31.         }  
32.         return cache;  
33.     }  
34.   
35.     public void setMemcachedClient(MemcachedClient memcachedClient) {  
36.         this.memcachedClient = memcachedClient;  
37.     }  
38.   
39.     public void setConfigMap(Map<String, Integer> configMap) {  
40.         this.expireMap = configMap;  
41.     }  
42.   
43. }  

2. 接着看下MemcachedCache的实现，主要实现spring的cache接口

1. public class MemcachedCache implements Cache {  
2.   
3.     private final String name;  
4.     private final MemCache memCache;  
5.   
6.     public MemcachedCache(String name, int expire, MemcachedClient memcachedClient) {  
7.         this.name = name;  
8.         this.memCache = new MemCache(name, expire, memcachedClient);  
9.     }  
10.   
11.     @Override  
12.     public void clear() {  
13.         memCache.clear();  
14.     }  
15.   
16.     @Override  
17.     public void evict(Object key) {  
18.         memCache.delete(key.toString());  
19.     }  
20.   
21.     @Override  
22.     public ValueWrapper get(Object key) {  
23.         ValueWrapper wrapper = null;  
24.         Object value = memCache.get(key.toString());  
25.         if (value != null) {  
26.             wrapper = new SimpleValueWrapper(value);  
27.         }  
28.         return wrapper;  
29.     }  
30.   
31.     @Override  
32.     public String getName() {  
33.         return this.name;  
34.     }  
35.   
36.     @Override  
37.     public MemCache getNativeCache() {  
38.         return this.memCache;  
39.     }  
40.   
41.     @Override  
42.     public void put(Object key, Object value) {  
43.         memCache.put(key.toString(), value);  
44.     }  
45.   
46.     @Override  
47.     @SuppressWarnings("unchecked")  
48.     public <T> T get(Object key, Class<T> type) {  
49.         Object cacheValue = this.memCache.get(key.toString());  
50.         Object value = (cacheValue != null ? cacheValue : null);  
51.         if (type != null && !type.isInstance(value)) {  
52.             throw new IllegalStateException("Cached value is not of required type [" + type.getName() + "]: " + value);  
53.         }  
54.         return (T) value;  
55.     }  
56.   
57. }  

3. spring提供的这套缓存api其实就是底层缓存框架与应用程序之间的中间层转换， 这里还有一个类就是MemCache，这个类主要是对应memcached缓存的模型，spring的缓存只是提供了一套api，具体的实现要根据底层使用的什么缓存框架：

 

MemCache.Java

 

1. public class MemCache {  
2.     private static Logger log = LoggerFactory.getLogger(MemCache.class);  
3.   
4.     private Set<String> keySet = new HashSet<String>();  
5.     private final String name;  
6.     private final int expire;  
7.     private final MemcachedClient memcachedClient;  
8.   
9.     public MemCache(String name, int expire, MemcachedClient memcachedClient) {  
10.         this.name = name;  
11.         this.expire = expire;  
12.         this.memcachedClient = memcachedClient;  
13.     }  
14.   
15.     public Object get(String key) {  
16.         Object value = null;  
17.         try {  
18.             key = this.getKey(key);  
19.             value = memcachedClient.get(key);  
20.         } catch (TimeoutException e) {  
21.             log.warn("获取 Memcached 缓存超时", e);  
22.         } catch (InterruptedException e) {  
23.             log.warn("获取 Memcached 缓存被中断", e);  
24.         } catch (MemcachedException e) {  
25.             log.warn("获取 Memcached 缓存错误", e);  
26.         }  
27.         return value;  
28.     }  
29.   
30.     public void put(String key, Object value) {  
31.         if (value == null)  
32.             return;  
33.   
34.         try {  
35.             key = this.getKey(key);  
36.             memcachedClient.setWithNoReply(key, expire, value);  
37.             keySet.add(key);  
38.         } catch (InterruptedException e) {  
39.             log.warn("更新 Memcached 缓存被中断", e);  
40.         } catch (MemcachedException e) {  
41.             log.warn("更新 Memcached 缓存错误", e);  
42.         }  
43.     }  
44.   
45.     public void clear() {  
46.         for (String key : keySet) {  
47.             try {  
48.                 memcachedClient.deleteWithNoReply(this.getKey(key));  
49.             } catch (InterruptedException e) {  
50.                 log.warn("删除 Memcached 缓存被中断", e);  
51.             } catch (MemcachedException e) {  
52.                 log.warn("删除 Memcached 缓存错误", e);  
53.             }  
54.         }  
55.     }  
56.   
57.     public void delete(String key) {  
58.         try {  
59.             key = this.getKey(key);  
60.             memcachedClient.deleteWithNoReply(key);  
61.         } catch (InterruptedException e) {  
62.             log.warn("删除 Memcached 缓存被中断", e);  
63.         } catch (MemcachedException e) {  
64.             log.warn("删除 Memcached 缓存错误", e);  
65.         }  
66.     }  
67.   
68.     private String getKey(String key) {  
69.         return name + "_" + key;  
70.     }  
71. }  

4. 在spring的配置文件中使用MemcachedCacheManager

1. <!-- 开启缓存 -->  
2. <cache:annotation-driven cache-manager="cacheManager" proxy-target-class="true" />  
3. <!-- 配置memcached的缓存服务器 -->  
4. <bean id="memcachedClientBuilder" class="net.rubyeye.xmemcached.XMemcachedClientBuilder">     
5.     <constructor-arg>  
6.         <list>  
7.             <bean class="java.net.InetSocketAddress">  
8.                 <constructor-arg value="localhost" />  
9.                 <constructor-arg value="11211" />  
10.             </bean>  
11.         </list>  
12.     </constructor-arg>  
13. </bean>  
14. <bean id="memcachedClient" factory-bean="memcachedClientBuilder" factory-method="build" destroy-method="shutdown" />  
15. <bean id="cacheManager" class="com.hqhop.framework.common.cache.memcached.MemcachedCacheManager">  
16.     <property name="memcachedClient" ref="memcachedClient" />  
17.     <!-- 配置缓存时间 -->  
18.     <property name="configMap">    
19.             <map>    
20.                 <!-- key缓存对象名称   value缓存过期时间 -->  
21.                 <entry key="typeList" value="3600" />     
22.             </map>    
23.         </property>    
24. </bean>  

5. 到此为止，spring和memcached整合就完成了，spring的缓存还提供了很多的注解@Cachable，@cachePut.....，这里不多说了。

转载于:https://my.oschina.net/u/2365905/blog/852016