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工具类：

 

01 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. 创建需要缓存的对象：

 

 

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

 

 

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

 

 

01 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 }

来自：http://blog.csdn.net/loujinhe/article/details/8491673