memcached常用Java客户端有三种
1、Xmemcached
基于java nio实现的高性能可扩展的memcached客户端。它的主要特点:
- 高性能,稳定可靠,已经在众多公司的众多项目里得到应用。
- 功能完备:客户端分布式、权重、最新最完整的协议支持。
- 可扩展,易于集成
- 可动态增删memached节点
- 客户端操作统计
- NIO连接池
等等…………
详细参考https://code.google.com/archive/p/xmemcached/wikis/User_Guide_zh.wiki
2、spymemcached
- 是一个采用Java开发的异步、单线程的Memcached客户端
详细参考
https://code.google.com/archive/p/spymemcached/
3、Memcached-Java-Client
- 较早推出的memcached JAVA客户端API,应用广泛,运行比较稳定
详细参考https://github.com/gwhalin/Memcached-Java-Client
------------------------------------------------------------------------------------------------------------------------------------------------
Xmemcached使用:
import net.rubyeye.xmemcached.MemcachedClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class MemcachedHelper {
private static transient Logger log = LoggerFactory.getLogger(MemcachedHelper.class);
private MemcachedClient memcachedClient;
private boolean memcachedOpen;
public boolean flushAll() {
if (getMemcachedOpen()) {
try {
memcachedClient.flushAll();
return true;
} catch (Exception e) {
log.error("MemcachedHelper flushAll:" + e.getMessage());
return false;
}
}
return false;
}
/**
* 根据key得到value
*
* @param key
* @return
*/
public Object get(String key) {
if (getMemcachedOpen()) {
try {
return memcachedClient.get(key);
} catch (Exception e) {
log.error("MemcachedHelper key is " + key);
}
}
return null;
}
/**
* 将key-value存入缓存
*
* @param key 存储的key名称,
* @param value 实际存储的数据
* @param expiry 是expire时间(单位秒),超过这个时间,memcached将这个数据替换出去,0表示永久存储(默认是一个月)
* @return
*/
public boolean set(String key, Object value, int expiry) {
if (getMemcachedOpen()) {
if (null != value) {
try {
return memcachedClient.set(key, expiry, value);
} catch (Exception e) {
log.error("MemcachedHelper key is " + key);
}
} else {
log.error("MemcachedHelper key is " + key);
}
}
return false;
}
/**
* 将key-value存入缓存,永久存储(默认是一个月)
*
* @param key
* @param value
* @return
*/
public boolean set(String key, Object value) {
return set(key, value, 0);
}
/**
* 根据key删除value
*
* @param key
* @return
*/
public boolean delete(String key) {
if (getMemcachedOpen()) {
try {
return memcachedClient.delete(key);
} catch (Exception e) {
log.error("MemcachedHelper key is " + key);
}
}
return false;
}
public void setMemcachedClient(MemcachedClient memcachedClient) {
this.memcachedClient = memcachedClient;
}
public void setMemcachedOpen(boolean memcachedOpen) {
this.memcachedOpen = memcachedOpen;
}
public boolean getMemcachedOpen() {
return memcachedOpen;
}
}
Spring配置:
<?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="builder" class="net.rubyeye.xmemcached.XMemcachedClientBuilder">
<constructor-arg>
<bean class="net.rubyeye.xmemcached.utils.AddrUtil" factory-method="getAddresses">
<constructor-arg value="${memcached.address}" />
</bean>
</constructor-arg>
<property name="sessionLocator">
<bean class="net.rubyeye.xmemcached.impl.KetamaMemcachedSessionLocator" />
</property>
</bean>
<bean id="memcachedClient" class="net.rubyeye.xmemcached.MemcachedClient" factory-bean="builder" factory-method="build" destroy-method="shutdown" />
<bean id="memcachedHelper" class="org.ghost.common.util.MemcachedHelper" >
<property name="memcachedClient" ref="memcachedClient"/>
<property name="memcachedOpen" value="true"/>
</bean>
</beans>
controller中使用:
import org.ghost.common.util.MemcachedHelper;
import org.ghost.web.response.ResponseResult;
import org.apache.commons.collections.MapUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
@RequestMapping("/memcached")
@RestController
public class MemcachedController {
@Autowired
private MemcachedHelper memcachedHelper;
@RequestMapping(value = "/get/{key}", method = RequestMethod.GET)
public ResponseResult get(@PathVariable String key) {
Object result = memcachedHelper.get(key);
return getSucResultData(result);
}
@RequestMapping(value = "/get", method = RequestMethod.GET)
public ResponseResult get(@RequestParam Map condition) {
String key = MapUtils.getString(condition, "key");
Object result = memcachedHelper.get(key);
return getSucResultData(result);
}
@RequestMapping(value = "/set", method = RequestMethod.POST)
public ResponseResult set(@RequestBody Map condition) {
String key = MapUtils.getString(condition, "key");
String value = MapUtils.getString(condition, "value");
int time = MapUtils.getIntValue(condition, "time");
boolean result = false;
if (time <= 0) {
result = memcachedHelper.set(key, value);
} else {
result = memcachedHelper.set(key, value, time);
}
if (true == result) {
return getSucMessage();
} else {
return getFaultMessage();
}
}
@RequestMapping(value = "/delete/{key}", method = RequestMethod.GET)
public ResponseResult delete(@PathVariable String key) {
boolean result = memcachedHelper.delete(key);
if (true == result) {
return getSucMessage();
} else {
return getFaultMessage();
}
}
@RequestMapping(value = "/delete", method = RequestMethod.GET)
public ResponseResult delete(@RequestParam Map condition) {
String key = MapUtils.getString(condition, "key");
boolean result = memcachedHelper.delete(key);
if (true == result) {
return getSucMessage();
} else {
return getFaultMessage();
}
}
@RequestMapping(value = "/flushall", method = RequestMethod.GET)
public ResponseResult flushAll() {
boolean result = memcachedHelper.flushAll();
if (true == result) {
return getSucMessage();
} else {
return getFaultMessage();
}
}
}
-------------------------------------------------------------------------------------------------------------------------------