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 {
02  
03  /**
04  * memcached客户端单例
05  */
06  private static MemCachedClient cachedClient = new MemCachedClient();
07  
08  /**
09  * 初始化连接池
10  */
11  static {
12  //获取连接池的实例
13  SockIOPool pool = SockIOPool.getInstance();
14  
15  //服务器列表及其权重
16  String[] servers = {"127.0.0.1:11211"};
17  Integer[] weights = {3};
18  
19  //设置服务器信息
20  pool.setServers(servers);
21  pool.setWeights(weights);
22  
23  //设置初始连接数、最小连接数、最大连接数、最大处理时间
24  pool.setInitConn(10);
25  pool.setMinConn(10);
26  pool.setMaxConn(1000);
27  pool.setMaxIdle(1000*60*60);
28  
29  //设置连接池守护线程的睡眠时间
30  pool.setMaintSleep(60);
31  
32  //设置TCP参数，连接超时
33  pool.setNagle(false);
34  pool.setSocketTO(60);
35  pool.setSocketConnectTO(0);
36  
37  //初始化并启动连接池
38  pool.initialize();
39  
40  //压缩设置，超过指定大小的都压缩
41  // cachedClient.setCompressEnable(true);
42  // cachedClient.setCompressThreshold(1024*1024);
43  }
44  
45  private MemcachedUtil(){
46  }
47  
48  public static boolean add(String key, Object value) {
49  return cachedClient.add(key, value);
50  }
51  
52  public static boolean add(String key, Object value, Integer expire) {
53  return cachedClient.add(key, value, expire);
54  }
55  
56  public static boolean put(String key, Object value) {
57  return cachedClient.set(key, value);
58  }
59  
60  public static boolean put(String key, Object value, Integer expire) {
61  return cachedClient.set(key, value, expire);
62  }
63  
64  public static boolean replace(String key, Object value) {
65  return cachedClient.replace(key, value);
66  }
67  
68  public static boolean replace(String key, Object value, Integer expire) {
69  return cachedClient.replace(key, value, expire);
70  }
71  
72  public static Object get(String key) {
73  return cachedClient.get(key);
74  }
75  
76

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

public class UserBean implements Serializable {
02  
03  private static final long serialVersionUID = 9174194101246733501L;
04  
05  private String username;
06  
07  private String password;
08  
09  public UserBean(String username, String password) {
10  this.username = username;
11  this.password = password;
12  }
13  
14  public String getUsername() {
15  return username;
16  }
17  
18  public void setUsername(String username) {
19  this.username = username;
20  }
21  
22  public String getPassword() {
23  return password;
24  }
25  
26  public void setPassword(String password) {
27  this.password = password;
28  }
29  
30  @Override
31  public int hashCode() {
32  final int prime = 31;
33  int result = 1;
34  result = prime * result
35  + ((password == null) ? 0 : password.hashCode());
36  result = prime * result
37  + ((username == null) ? 0 : username.hashCode());
38  return result;
39  }
40  
41  @Override
42  public boolean equals(Object obj) {
43  if (this == obj)
44  return true;
45  if (obj == null)
46  return false;
47  if (getClass() != obj.getClass())
48  return false;
49  UserBean other = (UserBean) obj;
50  if (password == null) {
51  if (other.password != null)
52  return false;
53  } else if (!password.equals(other.password))
54  return false;
55  if (username == null) {
56  if (other.username != null)
57  return false;
58  } else if (!username.equals(other.username))
59  return false;
60  return true;
61  }
62  
63  @Override
64  public String toString() {
65  return "username:" + username + ",password:" + password;
66  }
67

4.创建测试用例：

public class MemcachedUtilTest {
02  
03  @Test
04  public void testMemcached() {
05  MemcachedUtil.put("hello", "world", 60);
06  String hello = (String) MemcachedUtil.get("hello");
07  Assert.assertEquals("world", hello);
08  
09  for(int i = 0; i < 10000000; ++i) {
10  UserBean userBean = new UserBean("Jason" + i, "123456-" + i);
11  MemcachedUtil.put("user" + i, userBean, 60);
12  Object obj = MemcachedUtil.get("user" + i);
13  Assert.assertEquals(userBean, obj);
14  }
15  }
16  }

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 {
02  
03  private MemCachedClient cachedClient;
04  
05  @Before
06  public void init() {
07  ApplicationContext context = new ClassPathXmlApplicationContext("com/loujinhe/config/beans.xml");
08  cachedClient = (MemCachedClient)context.getBean("memcachedClient");
09  }
10  
11  @Test
12  public void testMemcachedSpring() {
13  UserBean user = new UserBean("lou", "jason");
14  cachedClient.set("user", user);
15  UserBean cachedBean = (UserBean)user;
16  Assert.assertEquals(user, cachedBean);
17  }
18