Java中使用memcached

<span style="font-size:14px;">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);
}

}</span>

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

<span style="font-size:14px;">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);
}
}
}</span>

<span style="font-size:14px;"><?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></span>

<span style="font-size:14px;">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);
}
}</span>