Java环境下Memcached应用详解

本文将对在Java环境下Memcached应用进行详细介绍。Memcached主要是集群环境下的缓存解决方案，可以运行在Java或者.NET平台上，这里我们主要讲的是Windows下的Memcached应用。

这些天在设计SNA的架构，接触了一些远程缓存、集群、session复制等的东西，以前做企业应用的时候感觉作用不大，现在设计面对internet的系统架构时就非常有用了，而且在调试后看到压力测试的情况还是比较好的。

在缓存的选择上有过很多的思考，虽然说memcached结合java在序列化上性能不怎么样，不过也没有更好的集群环境下的缓存解决方案了，就选择了memcached。本来计划等公司买的服务器到位装个linux再来研究memcached，但这两天在找到了一个windows下的Memcached版本，就动手开始调整现有的框架了。

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

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

1、缓存工具类

2、hibernate的provider

3、用缓存实现session机制

今天先研究研究缓存工具类的改造，在旧框架中部分函数用了ehcache对执行结果进行了缓存处理，现在目标是提供一个缓存工具类，在配置文件中配置使用哪种缓存（memcached或ehcached），使其它程序对具体的缓存不依赖，同时使用AOP方式来对方法执行结果进行缓存。

首先是工具类的实现：

在Spring中配置
Java代码

1. 
   
2. <beanid="cacheManager"
3. class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
4. <propertyname="configLocation">
5. <value>classpath:ehcache.xmlvalue>
6. property>
7. bean>
8. 
   
9. <beanid="localCache"
10. class="org.springframework.cache.ehcache.EhCacheFactoryBean">
11. <propertyname="cacheManager" ref="cacheManager"/>
12. <propertyname="cacheName"
13. value="×××.cache.LOCAL_CACHE"/>
14. bean>
15. 
    
16. <beanid="cacheService"
17. class="×××.core.cache.CacheService" init-method="init" destroy-method="destory">
18. <propertyname="cacheServerList" value="${cache.servers}"/>
19. <propertyname="cacheServerWeights" value="${cache.cacheServerWeights}"/>
20. <propertyname="cacheCluster" value="${cache.cluster}"/>
21. <propertyname="localCache" ref="localCache"/>
22. bean>
23. 
    
24. <beanid="cacheManager"
25. class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
26. <propertyname="configLocation">
27. <value>classpath:ehcache.xmlvalue>
28. property>
29. bean>
30. <beanid="localCache"
31. class="org.springframework.cache.ehcache.EhCacheFactoryBean">
32. <propertyname="cacheManager" ref="cacheManager"/>
33. <propertyname="cacheName"
34. value="×××.cache.LOCAL_CACHE"/>
35. bean>
36. 
    
37. <beanid="cacheService"
38. class="×××.core.cache.CacheService" init-method="init" destroy-method="destory">
39. <propertyname="cacheServerList" value="${cache.servers}"/>
40. <propertyname="cacheServerWeights" value="${cache.cacheServerWeights}"/>
41. <propertyname="cacheCluster" value="${cache.cluster}"/>
42. <propertyname="localCache" ref="localCache"/>
43. bean>

在properties文件中配置${cache.servers} ${cache.cacheServerWeights} ${cache.cluster}

具体工具类的代码

Java代码

1. /**
2. * @author Marc
3. *
4. */
5. publicclassCacheService {
6. privateLog logger = LogFactory.getLog(getClass());
7. privateCache localCache;
8. String cacheServerList;
9. String cacheServerWeights;
10. booleancacheCluster =false;
11. intinitialConnections = 10;
12. intminSpareConnections = 5;
13. intmaxSpareConnections = 50;
14. longmaxIdleTime = 1000 * 60 * 30; // 30 minutes
15. longmaxBusyTime = 1000 * 60 * 5; // 5 minutes
16. longmaintThreadSleep = 1000 * 5; // 5 seconds
17. intsocketTimeOut = 1000 * 3; // 3 seconds to block on reads
18. intsocketConnectTO = 1000 * 3; // 3 seconds to block on initial
19. // connections. If 0, then will use blocking
20. // connect (default)
21. booleanfailover =false; // turn off auto-failover in event of server
22. // down
23. booleannagleAlg =false; // turn off Nagle's algorithm on all sockets in
24. // pool
25. MemCachedClient mc;
26. publicCacheService(){
27. mc =newMemCachedClient();
28. mc.setCompressEnable(false);
29. }
30. /**
31. * 放入
32. *
33. */
34. publicvoidput(String key, Object obj) {
35. Assert.hasText(key);
36. Assert.notNull(obj);
37. Assert.notNull(localCache);
38. if(this.cacheCluster) {
39. mc.set(key, obj);
40. }else{
41. Element element =newElement(key, (Serializable) obj);
42. localCache.put(element);
43. }
44. }
45. /**
46. * 删除
47. */
48. publicvoidremove(String key){
49. Assert.hasText(key);
50. Assert.notNull(localCache);
51. if(this.cacheCluster) {
52. mc.delete(key);
53. }else{
54. localCache.remove(key);
55. }
56. }
57. /**
58. * 得到
59. */
60. publicObject get(String key) {
61. Assert.hasText(key);
62. Assert.notNull(localCache);
63. Object rt =null;
64. if(this.cacheCluster) {
65. rt = mc.get(key);
66. }else{
67. Element element =null;
68. try{
69. element = localCache.get(key);
70. }catch(CacheException cacheException) {
71. thrownewDataRetrieval（"Cache failure: "
72. + cacheException.getMessage());
73. }
74. if(element !=null)
75. rt = element.getValue();
76. }
77. returnrt;
78. }
79. /**
80. * 判断是否存在
81. *
82. */
83. publicbooleanexist(String key){
84. Assert.hasText(key);
85. Assert.notNull(localCache);
86. if(this.cacheCluster) {
87. returnmc.keyExists(key);
88. }else{
89. returnthis.localCache.isKeyInCache(key);
90. }
91. }
92. privatevoidinit() {
93. if(this.cacheCluster) {
94. String[] serverlist = cacheServerList.split(",");
95. Integer[] weights =this.split(cacheServerWeights);
96. // initialize the pool for memcache servers
97. SockIOPool pool = SockIOPool.getInstance();
98. pool.setServers(serverlist);
99. pool.setWeights(weights);
100. pool.setInitConn(initialConnections);
101. pool.setMinConn(minSpareConnections);
102. pool.setMaxConn(maxSpareConnections);
103. pool.setMaxIdle(maxIdleTime);
104. pool.setMaxBusyTime(maxBusyTime);
105. pool.setMaintSleep(maintThreadSleep);
106. pool.setSocketTO(socketTimeOut);
107. pool.setSocketConnectTO(socketConnectTO);
108. pool.setNagle(nagleAlg);
109. pool.setHashingAlg(SockIOPool.NEW_COMPAT_HASH);
110. pool.initialize();
111. logger.info("初始化memcached pool!");
112. }
113. }
114. 
     
115. privatevoiddestory() {
116. if(this.cacheCluster) {
117. SockIOPool.getInstance().shutDown();
118. }
119. }
120. }
121. /**
122. * @author Marc
123. *
124. */
125. publicclassCacheService {
126. privateLog logger = LogFactory.getLog(getClass());
127. privateCache localCache;
128. String cacheServerList;
129. String cacheServerWeights;
130. booleancacheCluster =false;
131. intinitialConnections = 10;
132. intminSpareConnections = 5;
133. intmaxSpareConnections = 50;
134. longmaxIdleTime = 1000 * 60 * 30; // 30 minutes
135. longmaxBusyTime = 1000 * 60 * 5; // 5 minutes
136. longmaintThreadSleep = 1000 * 5; // 5 seconds
137. intsocketTimeOut = 1000 * 3; // 3 seconds to block on reads
138. intsocketConnectTO = 1000 * 3; // 3 seconds to block on initial
139. // connections. If 0, then will use blocking
140. // connect (default)
141. booleanfailover =false; // turn off auto-failover in event of server
142. // down
143. booleannagleAlg =false; // turn off Nagle's algorithm on all sockets in
144. // pool
145. MemCachedClient mc;
146. publicCacheService(){
147. mc =newMemCachedClient();
148. mc.setCompressEnable(false);
149. }
150. /**
151. * 放入
152. *
153. */
154. publicvoidput(String key, Object obj) {
155. Assert.hasText(key);
156. Assert.notNull(obj);
157. Assert.notNull(localCache);
158. if(this.cacheCluster) {
159. mc.set(key, obj);
160. }else{
161. Element element =newElement(key, (Serializable) obj);
162. localCache.put(element);
163. }
164. }
165. /**
166. * 删除
167. */
168. publicvoidremove(String key){
169. Assert.hasText(key);
170. Assert.notNull(localCache);
171. if(this.cacheCluster) {
172. mc.delete(key);
173. }else{
174. localCache.remove(key);
175. }
176. }
177. /**
178. * 得到
179. */
180. publicObject get(String key) {
181. Assert.hasText(key);
182. Assert.notNull(localCache);
183. Object rt =null;
184. if(this.cacheCluster) {
185. rt = mc.get(key);
186. }else{
187. Element element =null;
188. try{
189. element = localCache.get(key);
190. }catch(CacheException cacheException) {
191. thrownewDataRetrieval（"Cache failure: "
192. + cacheException.getMessage());
193. }
194. if(element !=null)
195. rt = element.getValue();
196. }
197. returnrt;
198. }
199. /**
200. * 判断是否存在
201. *
202. */
203. publicbooleanexist(String key){
204. Assert.hasText(key);
205. Assert.notNull(localCache);
206. if(this.cacheCluster) {
207. returnmc.keyExists(key);
208. }else{
209. returnthis.localCache.isKeyInCache(key);
210. }
211. }
212. privatevoidinit() {
213. if(this.cacheCluster) {
214. String[] serverlist = cacheServerList.split(",");
215. Integer[] weights =this.split(cacheServerWeights);
216. // initialize the pool for memcache servers
217. SockIOPool pool = SockIOPool.getInstance();
218. pool.setServers(serverlist);
219. pool.setWeights(weights);
220. pool.setInitConn(initialConnections);
221. pool.setMinConn(minSpareConnections);
222. pool.setMaxConn(maxSpareConnections);
223. pool.setMaxIdle(maxIdleTime);
224. pool.setMaxBusyTime(maxBusyTime);
225. pool.setMaintSleep(maintThreadSleep);
226. pool.setSocketTO(socketTimeOut);
227. pool.setSocketConnectTO(socketConnectTO);
228. pool.setNagle(nagleAlg);
229. pool.setHashingAlg(SockIOPool.NEW_COMPAT_HASH);
230. pool.initialize();
231. logger.info("初始化memcachedpool!");
232. }
233. }
234. privatevoiddestory() {
235. if(this.cacheCluster) {
236. SockIOPool.getInstance().shutDown();
237. }
238. }
239. }

然后实现函数的AOP拦截类，用来在函数执行前返回缓存内容

Java代码

1. public class CachingInterceptor implements MethodInterceptor {
2. 
   
3. private CacheService cacheService;
4. private String cacheKey;
5. 
   
6. public void setCacheKey(String cacheKey) {
7. this.cacheKey = cacheKey;
8. }
9. 
   
10. public void setCacheService(CacheService cacheService) {
11. this.cacheService = cacheService;
12. }
13. 
    
14. public Object invoke(MethodInvocation invocation) throws Throwable {
15. Object result = cacheService.get(cacheKey);
16. //如果函数返回结果不在Cache中,执行函数并将结果放入Cache
17. if (result == null) {
18. result = invocation.proceed();
19. cacheService.put(cacheKey,result);
20. }
21. return result;
22. }
23. }
24. public class CachingInterceptor implements MethodInterceptor {
25. 
    
26. private CacheService cacheService;
27. private String cacheKey;
28. 
    
29. public void setCacheKey(String cacheKey) {
30. this.cacheKey = cacheKey;
31. }
32. 
    
33. public void setCacheService(CacheService cacheService) {
34. this.cacheService = cacheService;
35. }
36. 
    
37. public Object invoke(MethodInvocation invocation) throws Throwable {
38. Object result = cacheService.get(cacheKey);
39. //如果函数返回结果不在Cache中,执行函数并将结果放入Cache
40. if (result == null) {
41. result = invocation.proceed();
42. cacheService.put(cacheKey,result);
43. }
44. return result;
45. }
46. }

Spring的AOP配置如下：

Java代码

1. <aop:configproxy-target-class="true">
2. <aop:advisor
3. pointcut="execution(* ×××.PoiService.getOne(..))"
4. advice-ref="PoiServiceCachingAdvice"/>
5. aop:config>
6. 
   
7. <beanid="BasPoiServiceCachingAdvice"
8. class="×××.core.cache.CachingInterceptor">
9. <propertyname="cacheKey" value="PoiService"/>
10. <propertyname="cacheService" ref="cacheService"/>
11. bean>