Java Memcached使用

1.加载commons-pool-1.5.6.jar、java_memcached-release_2.6.6.jar、slf4j-api-1.6.1.jar、slf4j-simple-1.6.1.jar

2.创建memcached工具类：

 public class MemcachedUtil {

     /**
      * memcached客户端单例
      */
     private static MemCachedClient cachedClient = new MemCachedClient();

     /**
      * 初始化连接池
      */
     static {
         //获取连接池的实例
         SockIOPool pool = SockIOPool.getInstance();

         //服务器列表及其权重
         String[] servers = {"127.0.0.1:11211"};
         Integer[] weights = {3};

         //设置服务器信息
         pool.setServers(servers);
         pool.setWeights(weights);

         //设置初始连接数、最小连接数、最大连接数、最大处理时间
         pool.setInitConn(10);
         pool.setMinConn(10);
         pool.setMaxConn(1000);
         pool.setMaxIdle(1000*60*60);

         //设置连接池守护线程的睡眠时间
         pool.setMaintSleep(60);

         //设置TCP参数，连接超时
         pool.setNagle(false);
         pool.setSocketTO(60);
         pool.setSocketConnectTO(0);

         //初始化并启动连接池
         pool.initialize();

         //压缩设置，超过指定大小的都压缩
 //      cachedClient.setCompressEnable(true);
 //      cachedClient.setCompressThreshold(1024*1024);
     }

     private MemcachedUtil(){
     }

     public static boolean add(String key, Object value) {
         return cachedClient.add(key, value);
     }

     public static boolean add(String key, Object value, Integer expire) {
         return cachedClient.add(key, value, expire);
     }

     public static boolean put(String key, Object value) {
         return cachedClient.set(key, value);
     }

     public static boolean put(String key, Object value, Integer expire) {
         return cachedClient.set(key, value, expire);
     }

     public static boolean replace(String key, Object value) {
         return cachedClient.replace(key, value);
     }

     public static boolean replace(String key, Object value, Integer expire) {
         return cachedClient.replace(key, value, expire);
     }

     public static Object get(String key) {
         return cachedClient.get(key);
     }

 }

3. 创建需要缓存的对象：

 public class UserBean implements Serializable {

     private static final long serialVersionUID = 9174194101246733501L;

     private String username;

     private String password;

     public UserBean(String username, String password) {
         this.username = username;
         this.password = password;
     }

     public String getUsername() {
         return username;
     }

     public void setUsername(String username) {
         this.username = username;
     }

     public String getPassword() {
         return password;
     }

     public void setPassword(String password) {
         this.password = password;
     }

     @Override
     public int hashCode() {
         final int prime = 31;
         int result = 1;
         result = prime * result
                 + ((password == null) ? 0 : password.hashCode());
         result = prime * result
                 + ((username == null) ? 0 : username.hashCode());
         return result;
     }

     @Override
     public boolean equals(Object obj) {
         if (this == obj)
             return true;
         if (obj == null)
             return false;
         if (getClass() != obj.getClass())
             return false;
         UserBean other = (UserBean) obj;
         if (password == null) {
             if (other.password != null)
                 return false;
         } else if (!password.equals(other.password))
             return false;
         if (username == null) {
             if (other.username != null)
                 return false;
         } else if (!username.equals(other.username))
             return false;
         return true;
     }

     @Override
     public String toString() {
         return "username:" + username + ",password:" + password;
     }
 }

4.创建测试用例：

 public class MemcachedUtilTest {

     @Test
     public void testMemcached() {
         MemcachedUtil.put("hello", "world", 60);
         String hello = (String) MemcachedUtil.get("hello");
         Assert.assertEquals("world", hello);

         for(int i = 0; i < 10000000; ++i) {
             UserBean userBean = new UserBean("Jason" + i, "123456-" + i);
             MemcachedUtil.put("user" + i, userBean, 60);
             Object obj = MemcachedUtil.get("user" + i);
             Assert.assertEquals(userBean, obj);
         }
     }
 }

5.通过spring注入memcached：

 xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">

     <bean id="memcachedPool" class="com.danga.MemCached.SockIOPool"
         factory-method="getInstance" init-method="initialize">
         <constructor-arg>
             <value>neeaMemcachedPoolvalue>
         constructor-arg>
         <property name="servers">
             <list>
                 <value>127.0.0.1:11211value>
             list>
         property>
         <property name="initConn">
             <value>20value>
         property>
         <property name="minConn">
             <value>10value>
         property>
         <property name="maxConn">
             <value>50value>
         property>
         <property name="nagle">
             <value>falsevalue>
         property>
         <property name="socketTO">
             <value>3000value>
         property>
     bean>
     <bean id="memcachedClient" class="com.danga.MemCached.MemCachedClient">
         <constructor-arg>
             <value>neeaMemcachedPoolvalue>
         constructor-arg>
     bean>
 beans>

6.创建测试用例：

 public class MemcachedSpringTest {

     private MemCachedClient cachedClient;

     @Before
     public void init() {
         ApplicationContext context = new ClassPathXmlApplicationContext("com/loujinhe/config/beans.xml");
         cachedClient = (MemCachedClient)context.getBean("memcachedClient");
     }

     @Test
     public void testMemcachedSpring() {
         UserBean user = new UserBean("lou", "jason");
         cachedClient.set("user", user);
         UserBean cachedBean = (UserBean)user;
         Assert.assertEquals(user, cachedBean);
     }
 }