XMemcachedUtil

package com.base.util;

import java.io.IOException;
import java.util.Properties;

import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.MemcachedClientBuilder;
import net.rubyeye.xmemcached.XMemcachedClientBuilder;
import net.rubyeye.xmemcached.command.BinaryCommandFactory;
import net.rubyeye.xmemcached.utils.AddrUtil;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.code.yanf4j.util.ResourcesUtils;


public class XMemcachedUtil {
    private final static Logger logger = LoggerFactory.getLogger(XMemcachedUtil.class);
    
    private static MemcachedClient memcachedClient = null;
    private static Properties prop = null;

    private static synchronized MemcachedClient getMemcachedClient()
            throws IOException {
        if (memcachedClient == null) {
            try {
                prop = ResourcesUtils.getResourceAsProperties("memcached.properties");
            } catch (IOException e) {
                e.printStackTrace();
                logger.error("请配置memcached服务地址!");
            }
            if (prop != null) {                
                MemcachedClientBuilder builder = new XMemcachedClientBuilder(
                        AddrUtil.getAddresses(prop.getProperty("memcached_host")));
                // 宕机报警
                builder.setFailureMode(true);
                // 使用二进制文件    
                builder.setCommandFactory(new BinaryCommandFactory());
              
                /**
                 * 设置连接池大小，即客户端个数   
                 */
                //builder.setConnectionPoolSize(10);
                
                memcachedClient = builder.build();
            }
        }
        return memcachedClient;
    }
    
    public static boolean set(String key, Object obj){
        return set(key, 0, obj);
    }
    
    /**
     * 设置缓存
     * @param key        键
     * @param obj        任意java可序列化对象
     * @param expire    过期时间，0表示永久存储，默认一个月；单位：秒
     * @return
     */
    public static boolean set(String key, int expire, Object obj){
        boolean flag = false;
        try {
            MemcachedClient memcachedClient = getMemcachedClient();
            flag = memcachedClient.set(key, expire, obj);
            
            //memcachedClient.shutdown();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }
    
    /**
     * 从缓存中获取数据
       * @param key
     * @return
     */
    public static Object get(String key){
        MemcachedClient memcachedClient;
        try {
            memcachedClient = getMemcachedClient();
            return memcachedClient.get(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }        
    }
    
    /**
     * 删除缓存中对应键的数据
     * @param key
     * @return
     */
    public static boolean delete(String key){
        boolean flag = false;
        try {
            MemcachedClient memcachedClient = getMemcachedClient();
            flag = memcachedClient.delete(key);
        } catch (Exception e) {
            e.printStackTrace();
        }    
        return flag;
    }
    /**
     * 更新缓存中数据的超时时间
     * 无需将对象get出来设置
      * @param key
     * @param expire
     * @return
     */
    public static boolean touch(String key, int expire){
        boolean flag = false;
        try {
            MemcachedClient memcachedClient = getMemcachedClient();
            flag = memcachedClient.touch(key, expire);
        } catch (Exception e) {
            e.printStackTrace();
        }    
        return flag;
    }
    
    /**
     * 原子递增
     * @param key
     * @param delta        递增幅度
     * @return
     */
    public static long incr(String key, long delta){
        return incr(key, delta, 0);
    }
    /**
     * 原子递增
     * @param key
     * @param delta        递增幅度
     * @param initValue    初始值
     * @return
     */
    public static long incr(String key, long delta, long initValue){
        long curValue = 0;
        try {
            MemcachedClient memcachedClient = getMemcachedClient();
            curValue = memcachedClient.incr(key, delta, initValue);
        } catch (Exception e) {
            e.printStackTrace();
        }    
        return curValue;
    }
    
    /**
     * 原子递减
      * @param key
     * @param delta        递减幅度
     * @return
     */
    public static long decr(String key, long delta){
        return incr(key, delta, 0);
    }
    /**
     * 递减递增
        * @param key
     * @param delta        递减幅度
     * @param initValue    初始值
     * @return
     */
    public static long decr(String key, long delta, long initValue){
        long curValue = 0;
        try {
            MemcachedClient memcachedClient = getMemcachedClient();
            curValue = memcachedClient.decr(key, delta, initValue);
        } catch (Exception e) {
            e.printStackTrace();
        }    
        return curValue;
    }
    
    /**
     * 替换键对应的数据
        * @param key
     * @param obj
     * @return
     */
    public static boolean replace(String key, Object obj){
        return replace(key, 0, obj);
    }
    
    /**
     * 替换键对应的数据
      * @param key
     * @param expire
     * @param obj
     * @return
     */
    public static boolean replace(String key, int expire, Object obj){
        boolean flag = false;
        try {
            MemcachedClient memcachedClient = getMemcachedClient();
            flag = memcachedClient.replace(key, expire, obj);
        } catch (Exception e) {
            e.printStackTrace();
        }    
        return flag;
    }
    
 
}