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

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

具体工具类的代码

Java代码

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

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

Java代码

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

Spring的AOP配置如下：

Java代码

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

【责任编辑：彭凡 TEL：（010）68476606】

网页标题：Java环境下Memcached应用详解
文章出自：http://www.shufengxianlan.com/qtweb/news11/200861.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

外贸建站知识

分类信息网站

升施印刷　　 　一元广告　　 　犀浦防护栏定制　　 　成都微信二次开发　　 　成都网站建设　　 　域名ssl证书　　 　成都网站建设　　 　特丽尔硅藻泥　　 　成都网络公司　　 　手机app　　 　成都网站建设报价　　 　成都网站改版　　 　成都微信开发　　 　崇州湖霆科技　　 　高端网站建设　　 　瑞捷酒店用品　　 　小程序开发　　 　java虚拟主机　　 　成都营销网站制作　　 　网上商城管理系统