memcached与spring整合、测试

测试代码：
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工具类：
package com.chj.memcached;
import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
public class MemcachedUtil {
/**
* 
* memcached客户端单例
*/
private static MemCachedClient cachedClient = new MemCachedClient();
/**
* 
* 初始化连接池
*/
static {
// 获取连接池的实例
SockIOPool pool = SockIOPool.getInstance();
// 服务器列表及其权重
String[] servers = { "192.168.2.251:12000", "192.168.2.252:12000" };
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);
}


public static void main(String[] args) {
System.out.println(cachedClient);
}
}

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.创建测试用例：


package com.chj.memcached;
import org.junit.Test;
public class MemcachedUtilTest {
@Test
public void testMemcached1() {
MemcachedUtil.put("hello", "world", 60);
String hello = (String) MemcachedUtil.get("hello");
System.out.println("world".equals(hello));
for (int i = 0; i < 100; ++i) {
UserBean userBean = new UserBean("Jason" + i, "123456-" + i);
MemcachedUtil.put("user" + i, userBean, 60);
Object obj = MemcachedUtil.get("user" + i);
System.out.println(userBean.equals(obj));
}
}

@Test
public void testMemcached2() {
for (int i = 0; i < 100; ++i) {
UserBean obj = (UserBean) MemcachedUtil.get("user" + i);
System.out.println(obj.toString());
}
}
}


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>neeaMemcachedPool</value>
</constructor-arg>
<property name="servers">
<list>
<value>127.0.0.1:11211</value>
</list>
</property>
<property name="initConn">
<value>20</value>
</property>
<property name="minConn">
<value>10</value>
</property>
<property name="maxConn">
<value>50</value>
</property>
<property name="nagle">
<value>false</value>
</property>
<property name="socketTO">
<value>3000</value>
</property>
</bean>
<bean id="memcachedClient" class="com.danga.MemCached.MemCachedClient">
<constructor-arg>
<value>neeaMemcachedPool</value>
</constructor-arg>
</bean>
</beans>


6.创建测试用例：
public class MemcachedSpringTest {

  private MemCachedClient cachedClient;

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

  @Test
  public void testMemcachedSpring() {
      UserBean user = new UserBean("chj", "derek");
      cachedClient.set("user", user);

      UserBean cachedBean = (UserBean)user;

      System.out.println(userBean.equals(cachedBean ));

  }
}