memcached缓存失效时间

在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文档，许多方法的具体使用可以在上面查到。