Memcached客户端(memcached-Java-client)与 Spring集成(单服务器)

Memcached客户端与Spring集成,客户端使用的是Memcached-Java-Client-release_2.6.3

1. 配置Maven

  1. <!-- Memcached client -->  
  2. <dependency>   
  3.     <groupId>com.danga</groupId>  
  4.     <artifactId>memcached-java-client</artifactId>  
  5.     <version>2.6.3</version>  
  6. </dependency>  

2. Properties配置

[plain] view plain copy
  1. #######################Memcached配置#######################  
  2. #服务器地址  
  3. memcached.server=127.0.0.1:11211  
  4. #初始化时对每个服务器建立的连接数目  
  5. memcached.initConn=20  
  6. #每个服务器建立最小的连接数  
  7. memcached.minConn=10  
  8. #每个服务器建立最大的连接数  
  9. memcached.maxConn=50  
  10. #自查线程周期进行工作,其每次休眠时间  
  11. memcached.maintSleep=3000  
  12. #Socket的参数,如果是true在写数据时不缓冲,立即发送出去  
  13. memcached.nagle=false  
  14. #Socket阻塞读取数据的超时时间  
  15. memcached.socketTO=3000  

3. Spring配置

  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:context="http://www.springframework.org/schema/context"  
  5.     xmlns:aop="http://www.springframework.org/schema/aop"  
  6.     xmlns:util="http://www.springframework.org/schema/util"   
  7.     xmlns:mvc="http://www.springframework.org/schema/mvc"  
  8.     xmlns:tx="http://www.springframework.org/schema/tx"  
  9.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  10.            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  11.            http://www.springframework.org/schema/aop   
  12.            http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
  13.            http://www.springframework.org/schema/context  
  14.            http://www.springframework.org/schema/context/spring-context-3.0.xsd  
  15.            http://www.springframework.org/schema/util   
  16.            http://www.springframework.org/schema/util/spring-util-3.1.xsd  
  17.            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd  
  18.            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
  19.       
  20.     <!-- properties config   -->  
  21.     <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
  22.       <property name="order" value="1"/>  
  23.       <property name="ignoreUnresolvablePlaceholders" value="true"/>  
  24.       <property name="locations">  
  25.         <list>  
  26.             <value>classpath:config/memcached.properties</value>  
  27.         </list>  
  28.       </property>  
  29.     </bean>  
  30.       
  31.     <!-- Memcached配置 -->  
  32.     <bean id="memcachedPool" class="com.danga.MemCached.SockIOPool"  
  33.         factory-method="getInstance" init-method="initialize" destroy-method="shutDown">  
  34.         <property name="servers">  
  35.             <list>  
  36.                 <value>${memcached.server}</value>  
  37.             </list>  
  38.         </property>  
  39.         <property name="initConn">  
  40.             <value>${memcached.initConn}</value>  
  41.         </property>  
  42.         <property name="minConn">  
  43.             <value>${memcached.minConn}</value>  
  44.         </property>  
  45.         <property name="maxConn">  
  46.             <value>${memcached.maxConn}</value>  
  47.         </property>  
  48.         <property name="maintSleep">  
  49.             <value>${memcached.maintSleep}</value>  
  50.         </property>  
  51.         <property name="nagle">  
  52.             <value>${memcached.nagle}</value>  
  53.         </property>  
  54.         <property name="socketTO">  
  55.             <value>${memcached.socketTO}</value>  
  56.         </property>  
  57.     </bean>  
  58. </beans>  

4. Memcached工具类

  1. package com.wyy.snail.core.util;  
  2.   
  3. import java.io.BufferedWriter;  
  4. import java.io.FileWriter;  
  5. import java.io.IOException;  
  6. import java.io.PrintWriter;  
  7. import java.io.StringWriter;  
  8. import java.lang.management.ManagementFactory;  
  9. import java.lang.management.RuntimeMXBean;  
  10. import java.util.Date;  
  11.   
  12. import org.apache.log4j.Logger;  
  13.   
  14. import com.danga.MemCached.MemCachedClient;  
  15. import com.snail.base.utils.DateUtils;  
  16.   
  17. /** 
  18.  *  
  19.  * @ClassName: MemcachedUtils 
  20.  * @Description: Memcached工具类 
  21.  * @author yinjw 
  22.  * @date 2014-6-18 下午5:28:08 
  23.  *  
  24.  */  
  25. public class MemcachedUtils {  
  26.     private static final Logger logger = Logger.getLogger(MemcachedUtils.class);  
  27.     private static MemCachedClient cachedClient;  
  28.     static {  
  29.         if (cachedClient == null)  
  30.             cachedClient = new MemCachedClient();  
  31.     }  
  32.   
  33.     private MemcachedUtils() {  
  34.     }  
  35.   
  36.     /** 
  37.      * 向缓存添加新的键值对。如果键已经存在,则之前的值将被替换。 
  38.      *  
  39.      * @param key 
  40.      *            键 
  41.      * @param value 
  42.      *            值 
  43.      * @return 
  44.      */  
  45.     public static boolean set(String key, Object value) {  
  46.         return setExp(key, value, null);  
  47.     }  
  48.   
  49.     /** 
  50.      * 向缓存添加新的键值对。如果键已经存在,则之前的值将被替换。 
  51.      *  
  52.      * @param key 
  53.      *            键 
  54.      * @param value 
  55.      *            值 
  56.      * @param expire 
  57.      *            过期时间 New Date(1000*10):十秒后过期 
  58.      * @return 
  59.      */  
  60.     public static boolean set(String key, Object value, Date expire) {  
  61.         return setExp(key, value, expire);  
  62.     }  
  63.   
  64.     /** 
  65.      * 向缓存添加新的键值对。如果键已经存在,则之前的值将被替换。 
  66.      *  
  67.      * @param key 
  68.      *            键 
  69.      * @param value 
  70.      *            值 
  71.      * @param expire 
  72.      *            过期时间 New Date(1000*10):十秒后过期 
  73.      * @return 
  74.      */  
  75.     private static boolean setExp(String key, Object value, Date expire) {  
  76.         boolean flag = false;  
  77.         try {  
  78.             flag = cachedClient.set(key, value, expire);  
  79.         } catch (Exception e) {  
  80.             // 记录Memcached日志  
  81.             MemcachedLog.writeLog("Memcached set方法报错,key值:" + key + "\r\n" + exceptionWrite(e));  
  82.         }  
  83.         return flag;  
  84.     }  
  85.   
  86.     /** 
  87.      * 仅当缓存中不存在键时,add 命令才会向缓存中添加一个键值对。 
  88.      *  
  89.      * @param key 
  90.      *            键 
  91.      * @param value 
  92.      *            值 
  93.      * @return 
  94.      */  
  95.     public static boolean add(String key, Object value) {  
  96.         return addExp(key, value, null);  
  97.     }  
  98.   
  99.     /** 
  100.      * 仅当缓存中不存在键时,add 命令才会向缓存中添加一个键值对。 
  101.      *  
  102.      * @param key 
  103.      *            键 
  104.      * @param value 
  105.      *            值 
  106.      * @param expire 
  107.      *            过期时间 New Date(1000*10):十秒后过期 
  108.      * @return 
  109.      */  
  110.     public static boolean add(String key, Object value, Date expire) {  
  111.         return addExp(key, value, expire);  
  112.     }  
  113.   
  114.     /** 
  115.      * 仅当缓存中不存在键时,add 命令才会向缓存中添加一个键值对。 
  116.      *  
  117.      * @param key 
  118.      *            键 
  119.      * @param value 
  120.      *            值 
  121.      * @param expire 
  122.      *            过期时间 New Date(1000*10):十秒后过期 
  123.      * @return 
  124.      */  
  125.     private static boolean addExp(String key, Object value, Date expire) {  
  126.         boolean flag = false;  
  127.         try {  
  128.             flag = cachedClient.add(key, value, expire);  
  129.         } catch (Exception e) {  
  130.             // 记录Memcached日志  
  131.             MemcachedLog.writeLog("Memcached add方法报错,key值:" + key + "\r\n" + exceptionWrite(e));  
  132.         }  
  133.         return flag;  
  134.     }  
  135.   
  136.     /** 
  137.      * 仅当键已经存在时,replace 命令才会替换缓存中的键。 
  138.      *  
  139.      * @param key 
  140.      *            键 
  141.      * @param value 
  142.      *            值 
  143.      * @return 
  144.      */  
  145.     public static boolean replace(String key, Object value) {  
  146.         return replaceExp(key, value, null);  
  147.     }  
  148.   
  149.     /** 
  150.      * 仅当键已经存在时,replace 命令才会替换缓存中的键。 
  151.      *  
  152.      * @param key 
  153.      *            键 
  154.      * @param value 
  155.      *            值 
  156.      * @param expire 
  157.      *            过期时间 New Date(1000*10):十秒后过期 
  158.      * @return 
  159.      */  
  160.     public static boolean replace(String key, Object value, Date expire) {  
  161.         return replaceExp(key, value, expire);  
  162.     }  
  163.   
  164.     /** 
  165.      * 仅当键已经存在时,replace 命令才会替换缓存中的键。 
  166.      *  
  167.      * @param key 
  168.      *            键 
  169.      * @param value 
  170.      *            值 
  171.      * @param expire 
  172.      *            过期时间 New Date(1000*10):十秒后过期 
  173.      * @return 
  174.      */  
  175.     private static boolean replaceExp(String key, Object value, Date expire) {  
  176.         boolean flag = false;  
  177.         try {  
  178.             flag = cachedClient.replace(key, value, expire);  
  179.         } catch (Exception e) {  
  180.             MemcachedLog.writeLog("Memcached replace方法报错,key值:" + key + "\r\n" + exceptionWrite(e));  
  181.         }  
  182.         return flag;  
  183.     }  
  184.   
  185.     /** 
  186.      * get 命令用于检索与之前添加的键值对相关的值。 
  187.      *  
  188.      * @param key 
  189.      *            键 
  190.      * @return 
  191.      */  
  192.     public static Object get(String key) {  
  193.         Object obj = null;  
  194.         try {  
  195.             obj = cachedClient.get(key);  
  196.         } catch (Exception e) {  
  197.             MemcachedLog.writeLog("Memcached get方法报错,key值:" + key + "\r\n" + exceptionWrite(e));  
  198.         }  
  199.         return obj;  
  200.     }  
  201.   
  202.     /** 
  203.      * 删除 memcached 中的任何现有值。 
  204.      *  
  205.      * @param key 
  206.      *            键 
  207.      * @return 
  208.      */  
  209.     public static boolean delete(String key) {  
  210.         return deleteExp(key, null);  
  211.     }  
  212.   
  213.     /** 
  214.      * 删除 memcached 中的任何现有值。 
  215.      *  
  216.      * @param key 
  217.      *            键 
  218.      * @param expire 
  219.      *            过期时间 New Date(1000*10):十秒后过期 
  220.      * @return 
  221.      */  
  222.     public static boolean delete(String key, Date expire) {  
  223.         return deleteExp(key, expire);  
  224.     }  
  225.   
  226.     /** 
  227.      * 删除 memcached 中的任何现有值。 
  228.      *  
  229.      * @param key 
  230.      *            键 
  231.      * @param expire 
  232.      *            过期时间 New Date(1000*10):十秒后过期 
  233.      * @return 
  234.      */  
  235.     private static boolean deleteExp(String key, Date expire) {  
  236.         boolean flag = false;  
  237.         try {  
  238.             flag = cachedClient.delete(key, expire);  
  239.         } catch (Exception e) {  
  240.             MemcachedLog.writeLog("Memcached delete方法报错,key值:" + key + "\r\n" + exceptionWrite(e));  
  241.         }  
  242.         return flag;  
  243.     }  
  244.   
  245.     /** 
  246.      * 清理缓存中的所有键/值对 
  247.      *  
  248.      * @return 
  249.      */  
  250.     public static boolean flashAll() {  
  251.         boolean flag = false;  
  252.         try {  
  253.             flag = cachedClient.flushAll();  
  254.         } catch (Exception e) {  
  255.             MemcachedLog.writeLog("Memcached flashAll方法报错\r\n" + exceptionWrite(e));  
  256.         }  
  257.         return flag;  
  258.     }  
  259.   
  260.     /** 
  261.      * 返回异常栈信息,String类型 
  262.      *  
  263.      * @param e 
  264.      * @return 
  265.      */  
  266.     private static String exceptionWrite(Exception e) {  
  267.         StringWriter sw = new StringWriter();  
  268.         PrintWriter pw = new PrintWriter(sw);  
  269.         e.printStackTrace(pw);  
  270.         pw.flush();  
  271.         return sw.toString();  
  272.     }  
  273.   
  274.     /** 
  275.      *  
  276.      * @ClassName: MemcachedLog 
  277.      * @Description: Memcached日志记录 
  278.      * @author yinjw 
  279.      * @date 2014-6-18 下午5:01:37 
  280.      *  
  281.      */  
  282.     private static class MemcachedLog {  
  283.         private final static String MEMCACHED_LOG = "D:\\memcached.log";  
  284.         private final static String LINUX_MEMCACHED_LOG = "/usr/local/logs/memcached.log";  
  285.         private static FileWriter fileWriter;  
  286.         private static BufferedWriter logWrite;  
  287.         // 获取PID,可以找到对应的JVM进程  
  288.         private final static RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();  
  289.         private final static String PID = runtime.getName();  
  290.   
  291.         /** 
  292.          * 初始化写入流 
  293.          */  
  294.         static {  
  295.             try {  
  296.                 String osName = System.getProperty("os.name");  
  297.                 if (osName.indexOf("Windows") == -1) {  
  298.                     fileWriter = new FileWriter(MEMCACHED_LOG, true);  
  299.                 } else {  
  300.                     fileWriter = new FileWriter(LINUX_MEMCACHED_LOG, true);  
  301.                 }  
  302.                 logWrite = new BufferedWriter(fileWriter);  
  303.             } catch (IOException e) {  
  304.                 logger.error("memcached 日志初始化失败", e);  
  305.                 closeLogStream();  
  306.             }  
  307.         }  
  308.   
  309.         /** 
  310.          * 写入日志信息 
  311.          *  
  312.          * @param content 
  313.          *            日志内容 
  314.          */  
  315.         public static void writeLog(String content) {  
  316.             try {  
  317.                 logWrite.write("[" + PID + "] " + "- [" + DateUtils.formateTime(new Date().getTime()) + "]\r\n"  
  318.                         + content);  
  319.                 logWrite.newLine();  
  320.                 logWrite.flush();  
  321.             } catch (IOException e) {  
  322.                 logger.error("memcached 写入日志信息失败", e);  
  323.             }  
  324.         }  
  325.   
  326.         /** 
  327.          * 关闭流 
  328.          */  
  329.         private static void closeLogStream() {  
  330.             try {  
  331.                 fileWriter.close();  
  332.                 logWrite.close();  
  333.             } catch (IOException e) {  
  334.                 logger.error("memcached 日志对象关闭失败", e);  
  335.             }  
  336.         }  
  337.     }  
  338. }  

5. 使用工具类操作Memcached

  1. @Test  
  2. public void testMemcachedSpring() {  
  3.     MemcachedUtils.set("aa""bb"new Date(1000 * 60));  
  4.     Object obj = MemcachedUtils.get("aa");  
  5.     System.out.println("***************************");  
  6.     System.out.println(obj.toString());  
  7. }  
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值