在javaWeb上配置使用memcached
这里有一个官方传统的Memcached-Java-Client
首先在javaWeb工程中导入memcached架包
memcached架包下载地址
https://github.com/gwhalin/Memcached-Java-Client/downloads
其中会附有该版本对应的依赖包slf4j也要记得导入。
建立Manager类
package com.stats81813.cached;
import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
/**
* Memcached客服端操作
* @author WYL on 2011-10-09
*
*/
public class MemcachedManager {
protected static MemCachedClient mcc = new MemCachedClient();
// 设置与缓存服务器的连接池
static {
// 服务器列表和其权重
String[] servers = {"127.0.0.1:11211"};
Integer[] weights = {3};
// 获取socke连接池的实例对象
SockIOPool pool = SockIOPool.getInstance();
// 设置服务器信息
pool.setServers( servers );
pool.setWeights( weights );
// 设置初始连接数、最小和最大连接数以及最大处理时间
pool.setInitConn( 5 );
pool.setMinConn( 5 );
pool.setMaxConn( 250 );
pool.setMaxIdle( 1000 * 60 * 60 * 6 );
// 设置主线程的睡眠时间
pool.setMaintSleep( 30 );
// 设置TCP的参数,连接超时等
pool.setNagle( false );
pool.setSocketTO( 3000 );
pool.setSocketConnectTO( 0 );
// 初始化连接池
pool.initialize();
// 压缩设置,超过指定大小(单位为K)的数据都会被压缩
mcc.setCompressEnable( true );
mcc.setCompressThreshold( 64 * 1024 );
}
/**
* 根据指定的关键字获取对象.
* @param key
* @return
*/
public Object get(String key)
{
return mcc.get(key);
}
/**
* 删除指定关键字的缓存.
* @param key
* @return
*/
public boolean del(String key)
{
return mcc.delete(key);
}
/**
* 添加一个指定的值到缓存中.
* @param key
* @param value
* @return
*/
public boolean add(String key, Object value)
{
return mcc.add(key, value);
}
/**
* 添加并设置到期时间,如:
* Date expiry = new Date();
* expiry.setTime(expiry.getTime() + 500);单位毫秒
*
* @param key
* @param value
* @param expiry
* @return
*/
public boolean add(String key, Object value, Date expiry)
{
return mcc.add(key, value, expiry);
}
/**
* 替换已存在的key的value,注意类型是Object(统计切勿使用replace)
* @param key
* @param value
* @return
*/
public boolean replace(String key, Object value)
{
return mcc.replace(key, value);
}
/**
* 替换已存在的key的value,注意类型是Object(统计切勿使用replace)
* Date expiry = new Date();
* expiry.setTime(expiry.getTime() + 500);单位毫秒
*
* @param key
* @param value
* @param expiry
* @return
*/
public boolean replace(String key, Object value, Date expiry)
{
return mcc.replace(key, value, expiry);
}
/**
* 计数器+inc,如果计数器不存在,返回-1,保存inc作为计数器值
* @param key
* @param inc
* @return
*/
public long addOrIncr(String key,long inc)
{
return mcc.addOrIncr(key, inc);
}
/**
* 计数器+inc,如果计数器不存在,返回-1,但不保存任何值
* @param key
* @param inc
*/
public long incr(String key,long inc){
return mcc.incr(key,inc);
}
/**
* 获取计数器,-1表示不存在
* @param key
*/
public long getCounter(String key){
Object ob = mcc.getCounter(key);
if(null == ob){
return -1;
} else if(ob instanceof String){
//判断若不是long型,则删除该key,并返回-1
del(key);
return -1;
} else {
return Long.valueOf(ob.toString());
}
}
}
使用例子:
public static void main(String[] args){
MemcachedManager mc = new MemcachedManager();
String key1 = "test1";
String value1 = "abc";
mc.add(key1,value1);
System.out.println("value1 = " + mc.get(key1));
String key2 = "test2";
long value2 = 11111;
mc.addOrIncr(key2,value2);//在高并发的情况下,使用add、get方法就会出现读写不一致性的问题,这里需要使用累加器Incr
System.out.println("value2 = " + mc.getCounter(key2));
}
但是在压力测试的过程中,发现这个官方传统的Memcached-Java-Client在每次执行都会打印向java虚拟机打印日志,
致使linux配置的usr/local/resin-3.1.9/log/jvm-default.log 日志文件在压力测试一个晚上后,大小涨到几个G,同时打印日志不断在写入磁盘操作较耗性能。
反编译架包的class后发现,方法中是使用info级别的logger打印,关闭它,需要在logback-test.xml中配置:
<logger name="com.danga.MemCached.MemCachedClient">
<level value="error" />
</logger>
因此开始考虑使用另外的Memcached-Java-Client。
3.XMemcached(一个新java memcached client)
据说明文档描述,XMemcached相比于传统阻塞io模型来说,有效率高(特别在高并发下)和资源耗费相对较少的优点。能相对减少线程创建和切换的开销。
XMemcached架包下载地址
http://code.google.com/p/xmemcached/downloads/list
依赖包:
slf4j-api-1.6.4.jar
slf4j-log4j12-1.6.4.jar
log4j-1.2.16.jar
这些架包可以在对应的官网上下载到
http://www.slf4j.org/download.html
http://logging.apache.org/log4j/1.2/download.html
使用方法,同样也是建立Manager类
package com.stats81813.cached;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.MemcachedClientBuilder;
import net.rubyeye.xmemcached.XMemcachedClientBuilder;
import net.rubyeye.xmemcached.exception.MemcachedException;
import net.rubyeye.xmemcached.utils.AddrUtil;
/**
* Memcached客服端操作
* @author WYL on 2011-12-01
*
*/
public class MemcachedManager {
private static final Logger logger = LoggerFactory.getLogger(MemcachedManager.class);
private static MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses(127.0.0.1:11211));
private static MemcachedClient client = null;
static {
builder.setConnectionPoolSize(30);//设置连接数
try {
client = builder.build();
} catch (IOException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
client.setOpTimeout(20000);//设置缓存服务器连接时间
}
/**
* 根据指定的关键字获取对象.
* @param key
* @return
*/
public Object get(String key){
Object ob = null;
try {
ob = client.get(key);
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}/* finally {
if(null != client){
try {
client.shutdown();
} catch (IOException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
}
}*/
return ob;
}
/**
* 删除指定关键字的缓存.
* @param key
* @return
*/
public boolean del(String key){
boolean flag = false;
try {
flag = client.delete(key);
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}/* finally {
if(null != client){
try {
client.shutdown();
} catch (IOException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
}
}*/
return flag;
}
/**
* 添加一个指定的值到缓存中
* @param key
* @param expiry(单位秒),超过这个时间,memcached将这个数据替换出去,0表示永久存储(默认是一个月)
* @param value
* @return
*/
public boolean add(String key, int expiry, Object value){
boolean flag = false;
try {
flag = client.add(key, expiry, value);
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} /*finally {
if(null != client){
try {
client.shutdown();
} catch (IOException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
}
}*/
return flag;
}
/**
* 添加一个指定的值到缓存中
* @param key
* @param value
* @return
*/
public boolean add(String key, Object value){
return add(key, 0, value);
}
/**
* 添加并设置到期时间
* @param key
* @param expiry(单位秒),超过这个时间,memcached将这个数据替换出去,0表示永久存储(默认是一个月)
* @param value
* @param timeout(单位毫秒),设置过期时间,如果expiry还未到期,timeout到期,则该memcached过期
* @return
*/
public boolean add(String key, int expiry, Object value, long timeout){
boolean flag = false;
try {
flag = client.add(key, expiry, value, timeout);
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}/* finally {
if(null != client){
try {
client.shutdown();
} catch (IOException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
}
}*/
return flag;
}
/**
* 添加并设置到期时间
* @param key
* @param value
* @param timeout(单位毫秒),设置过期时间,如果expiry还未到期,timeout到期,则该memcached过期
* @return
*/
public boolean add(String key, Object value, long timeout){
return add(key, 0, value, timeout);
}
/**
* 替换已存在的key的value,注意类型是Object(统计切勿使用replace)
* @param key
* @param expiry(单位秒),超过这个时间,memcached将这个数据替换出去,0表示永久存储(默认是一个月)
* @param value
* @return
*/
public boolean replace(String key, int expiry, Object value){
boolean flag = false;
try {
flag = client.replace(key, expiry,value);
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} /*finally {
if(null != client){
try {
client.shutdown();
} catch (IOException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
}
}*/
return flag;
}
/**
* 替换已存在的key的value,注意类型是Object(统计切勿使用replace)
* @param key
* @param value
* @return
*/
public boolean replace(String key, Object value){
return replace(key, 0, value);
}
/**
* 替换已存在的key的value,注意类型是Object(统计切勿使用replace)
* @param key
* @param expiry(单位秒),超过这个时间,memcached将这个数据替换出去,0表示永久存储(默认是一个月)
* @param value
* @param timeout(单位毫秒),设置过期时间,如果expiry还未到期,timeout到期,则该memcached过期
* @return
*/
public boolean replace(String key, int expiry, Object value, long timeout){
boolean flag = false;
try {
flag = client.replace(key, expiry, value, timeout);
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}/* finally {
if(null != client){
try {
client.shutdown();
} catch (IOException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
}
}*/
return flag;
}
/**
* 替换已存在的key的value,注意类型是Object(统计切勿使用replace)
* @param key
* @param value
* @param timeout(单位毫秒),设置过期时间,如果expiry还未到期,timeout到期,则该memcached过期
* @return
*/
public boolean replace(String key, Object value, long timeout){
return replace(key, 0, value);
}
/**
* 计数器累加inc
* @param key
* @param inc 递增的幅度大小
* @return
*/
public long addStats(String key, long inc){
long rec = -1;
Counter counter = client.getCounter(key);
try {
rec = counter.incrementAndGet();
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
return rec;
}
/**
* 计数器累加inc
* @param key
* @param inc 递增的幅度大小
* @param original key不存在的情况下的初始值
* @return
*/
public long addStats(String key, long inc, long original){
long rec = -1;
Counter counter = client.getCounter(key,original);
try {
rec = counter.incrementAndGet();
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
return rec;
}
/**
* 获取计数器,key不存在则返回-1
* @param key
*/
public long getStats(String key){
long rec = -1;
Counter counter = client.getCounter(key,-1);//第二个参数是计数器的初始值
try {
rec = counter.get();
//使用count时实质是在创建一个key,因此需要将这个key清除掉
if(rec == -1)
del(key);
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
return rec;
}
}
调用方法与2类似,此处的统计Xmemcached还提供了一个称为计数器的封装,它封装了incr/decr方法。
此外XMemcached还提供使用指南和API文档,许多方法的具体使用可以在上面查到。
这里有一个官方传统的Memcached-Java-Client
首先在javaWeb工程中导入memcached架包
memcached架包下载地址
https://github.com/gwhalin/Memcached-Java-Client/downloads
其中会附有该版本对应的依赖包slf4j也要记得导入。
建立Manager类
package com.stats81813.cached;
import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
/**
* Memcached客服端操作
* @author WYL on 2011-10-09
*
*/
public class MemcachedManager {
protected static MemCachedClient mcc = new MemCachedClient();
// 设置与缓存服务器的连接池
static {
// 服务器列表和其权重
String[] servers = {"127.0.0.1:11211"};
Integer[] weights = {3};
// 获取socke连接池的实例对象
SockIOPool pool = SockIOPool.getInstance();
// 设置服务器信息
pool.setServers( servers );
pool.setWeights( weights );
// 设置初始连接数、最小和最大连接数以及最大处理时间
pool.setInitConn( 5 );
pool.setMinConn( 5 );
pool.setMaxConn( 250 );
pool.setMaxIdle( 1000 * 60 * 60 * 6 );
// 设置主线程的睡眠时间
pool.setMaintSleep( 30 );
// 设置TCP的参数,连接超时等
pool.setNagle( false );
pool.setSocketTO( 3000 );
pool.setSocketConnectTO( 0 );
// 初始化连接池
pool.initialize();
// 压缩设置,超过指定大小(单位为K)的数据都会被压缩
mcc.setCompressEnable( true );
mcc.setCompressThreshold( 64 * 1024 );
}
/**
* 根据指定的关键字获取对象.
* @param key
* @return
*/
public Object get(String key)
{
return mcc.get(key);
}
/**
* 删除指定关键字的缓存.
* @param key
* @return
*/
public boolean del(String key)
{
return mcc.delete(key);
}
/**
* 添加一个指定的值到缓存中.
* @param key
* @param value
* @return
*/
public boolean add(String key, Object value)
{
return mcc.add(key, value);
}
/**
* 添加并设置到期时间,如:
* Date expiry = new Date();
* expiry.setTime(expiry.getTime() + 500);单位毫秒
*
* @param key
* @param value
* @param expiry
* @return
*/
public boolean add(String key, Object value, Date expiry)
{
return mcc.add(key, value, expiry);
}
/**
* 替换已存在的key的value,注意类型是Object(统计切勿使用replace)
* @param key
* @param value
* @return
*/
public boolean replace(String key, Object value)
{
return mcc.replace(key, value);
}
/**
* 替换已存在的key的value,注意类型是Object(统计切勿使用replace)
* Date expiry = new Date();
* expiry.setTime(expiry.getTime() + 500);单位毫秒
*
* @param key
* @param value
* @param expiry
* @return
*/
public boolean replace(String key, Object value, Date expiry)
{
return mcc.replace(key, value, expiry);
}
/**
* 计数器+inc,如果计数器不存在,返回-1,保存inc作为计数器值
* @param key
* @param inc
* @return
*/
public long addOrIncr(String key,long inc)
{
return mcc.addOrIncr(key, inc);
}
/**
* 计数器+inc,如果计数器不存在,返回-1,但不保存任何值
* @param key
* @param inc
*/
public long incr(String key,long inc){
return mcc.incr(key,inc);
}
/**
* 获取计数器,-1表示不存在
* @param key
*/
public long getCounter(String key){
Object ob = mcc.getCounter(key);
if(null == ob){
return -1;
} else if(ob instanceof String){
//判断若不是long型,则删除该key,并返回-1
del(key);
return -1;
} else {
return Long.valueOf(ob.toString());
}
}
}
使用例子:
public static void main(String[] args){
MemcachedManager mc = new MemcachedManager();
String key1 = "test1";
String value1 = "abc";
mc.add(key1,value1);
System.out.println("value1 = " + mc.get(key1));
String key2 = "test2";
long value2 = 11111;
mc.addOrIncr(key2,value2);//在高并发的情况下,使用add、get方法就会出现读写不一致性的问题,这里需要使用累加器Incr
System.out.println("value2 = " + mc.getCounter(key2));
}
但是在压力测试的过程中,发现这个官方传统的Memcached-Java-Client在每次执行都会打印向java虚拟机打印日志,
致使linux配置的usr/local/resin-3.1.9/log/jvm-default.log 日志文件在压力测试一个晚上后,大小涨到几个G,同时打印日志不断在写入磁盘操作较耗性能。
反编译架包的class后发现,方法中是使用info级别的logger打印,关闭它,需要在logback-test.xml中配置:
<logger name="com.danga.MemCached.MemCachedClient">
<level value="error" />
</logger>
因此开始考虑使用另外的Memcached-Java-Client。
3.XMemcached(一个新java memcached client)
据说明文档描述,XMemcached相比于传统阻塞io模型来说,有效率高(特别在高并发下)和资源耗费相对较少的优点。能相对减少线程创建和切换的开销。
XMemcached架包下载地址
http://code.google.com/p/xmemcached/downloads/list
依赖包:
slf4j-api-1.6.4.jar
slf4j-log4j12-1.6.4.jar
log4j-1.2.16.jar
这些架包可以在对应的官网上下载到
http://www.slf4j.org/download.html
http://logging.apache.org/log4j/1.2/download.html
使用方法,同样也是建立Manager类
package com.stats81813.cached;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.MemcachedClientBuilder;
import net.rubyeye.xmemcached.XMemcachedClientBuilder;
import net.rubyeye.xmemcached.exception.MemcachedException;
import net.rubyeye.xmemcached.utils.AddrUtil;
/**
* Memcached客服端操作
* @author WYL on 2011-12-01
*
*/
public class MemcachedManager {
private static final Logger logger = LoggerFactory.getLogger(MemcachedManager.class);
private static MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses(127.0.0.1:11211));
private static MemcachedClient client = null;
static {
builder.setConnectionPoolSize(30);//设置连接数
try {
client = builder.build();
} catch (IOException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
client.setOpTimeout(20000);//设置缓存服务器连接时间
}
/**
* 根据指定的关键字获取对象.
* @param key
* @return
*/
public Object get(String key){
Object ob = null;
try {
ob = client.get(key);
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}/* finally {
if(null != client){
try {
client.shutdown();
} catch (IOException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
}
}*/
return ob;
}
/**
* 删除指定关键字的缓存.
* @param key
* @return
*/
public boolean del(String key){
boolean flag = false;
try {
flag = client.delete(key);
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}/* finally {
if(null != client){
try {
client.shutdown();
} catch (IOException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
}
}*/
return flag;
}
/**
* 添加一个指定的值到缓存中
* @param key
* @param expiry(单位秒),超过这个时间,memcached将这个数据替换出去,0表示永久存储(默认是一个月)
* @param value
* @return
*/
public boolean add(String key, int expiry, Object value){
boolean flag = false;
try {
flag = client.add(key, expiry, value);
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} /*finally {
if(null != client){
try {
client.shutdown();
} catch (IOException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
}
}*/
return flag;
}
/**
* 添加一个指定的值到缓存中
* @param key
* @param value
* @return
*/
public boolean add(String key, Object value){
return add(key, 0, value);
}
/**
* 添加并设置到期时间
* @param key
* @param expiry(单位秒),超过这个时间,memcached将这个数据替换出去,0表示永久存储(默认是一个月)
* @param value
* @param timeout(单位毫秒),设置过期时间,如果expiry还未到期,timeout到期,则该memcached过期
* @return
*/
public boolean add(String key, int expiry, Object value, long timeout){
boolean flag = false;
try {
flag = client.add(key, expiry, value, timeout);
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}/* finally {
if(null != client){
try {
client.shutdown();
} catch (IOException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
}
}*/
return flag;
}
/**
* 添加并设置到期时间
* @param key
* @param value
* @param timeout(单位毫秒),设置过期时间,如果expiry还未到期,timeout到期,则该memcached过期
* @return
*/
public boolean add(String key, Object value, long timeout){
return add(key, 0, value, timeout);
}
/**
* 替换已存在的key的value,注意类型是Object(统计切勿使用replace)
* @param key
* @param expiry(单位秒),超过这个时间,memcached将这个数据替换出去,0表示永久存储(默认是一个月)
* @param value
* @return
*/
public boolean replace(String key, int expiry, Object value){
boolean flag = false;
try {
flag = client.replace(key, expiry,value);
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} /*finally {
if(null != client){
try {
client.shutdown();
} catch (IOException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
}
}*/
return flag;
}
/**
* 替换已存在的key的value,注意类型是Object(统计切勿使用replace)
* @param key
* @param value
* @return
*/
public boolean replace(String key, Object value){
return replace(key, 0, value);
}
/**
* 替换已存在的key的value,注意类型是Object(统计切勿使用replace)
* @param key
* @param expiry(单位秒),超过这个时间,memcached将这个数据替换出去,0表示永久存储(默认是一个月)
* @param value
* @param timeout(单位毫秒),设置过期时间,如果expiry还未到期,timeout到期,则该memcached过期
* @return
*/
public boolean replace(String key, int expiry, Object value, long timeout){
boolean flag = false;
try {
flag = client.replace(key, expiry, value, timeout);
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}/* finally {
if(null != client){
try {
client.shutdown();
} catch (IOException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
}
}*/
return flag;
}
/**
* 替换已存在的key的value,注意类型是Object(统计切勿使用replace)
* @param key
* @param value
* @param timeout(单位毫秒),设置过期时间,如果expiry还未到期,timeout到期,则该memcached过期
* @return
*/
public boolean replace(String key, Object value, long timeout){
return replace(key, 0, value);
}
/**
* 计数器累加inc
* @param key
* @param inc 递增的幅度大小
* @return
*/
public long addStats(String key, long inc){
long rec = -1;
Counter counter = client.getCounter(key);
try {
rec = counter.incrementAndGet();
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
return rec;
}
/**
* 计数器累加inc
* @param key
* @param inc 递增的幅度大小
* @param original key不存在的情况下的初始值
* @return
*/
public long addStats(String key, long inc, long original){
long rec = -1;
Counter counter = client.getCounter(key,original);
try {
rec = counter.incrementAndGet();
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
return rec;
}
/**
* 获取计数器,key不存在则返回-1
* @param key
*/
public long getStats(String key){
long rec = -1;
Counter counter = client.getCounter(key,-1);//第二个参数是计数器的初始值
try {
rec = counter.get();
//使用count时实质是在创建一个key,因此需要将这个key清除掉
if(rec == -1)
del(key);
} catch (TimeoutException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (InterruptedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
} catch (MemcachedException e) {
logger.error("error ========== \r\n{}", e.getMessage());
}
return rec;
}
}
调用方法与2类似,此处的统计Xmemcached还提供了一个称为计数器的封装,它封装了incr/decr方法。
此外XMemcached还提供使用指南和API文档,许多方法的具体使用可以在上面查到。