MemcachedUtil 工具类

/**
*
*/
package org.lang2hong.utils;

import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Properties;
import java.util.concurrent.TimeoutException;

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;

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

/**
* @author jianping.gao
*
*/
public class MemcachedUtil {
/**
* slf4j logback
*/
private final static Logger logger = LoggerFactory
.getLogger(MemcachedUtil.class);

public static MemcachedClient memcachedClient;

/*
 * 本地ip 支持多个测试人员同时使用同一个缓存
 */
private static String ip;

/*
 * 缓存时间
 */
private static int catchTime = 5 * 60 * 60;

/*
 * 支持多个测试人员同时使用同一个缓存
 */
static {
    InetAddress addr;
    try {
        addr = InetAddress.getLocalHost();
        ip = addr.getHostAddress().toString();// 获得本机IP
    } catch (UnknownHostException e) {
        logger.error("Unknown host exception ", e);
        ip = "127.0.0.1";
    }
}

/*
 * memcachedClient Instance
 */
public static void memcachedClientInstance(Properties p) {
    MemcachedClientBuilder builder = null;
    try {
        builder = new XMemcachedClientBuilder(AddrUtil.getAddresses(p
                .getProperty("memcached.server1.host")
                + ":"
                + p.getProperty("memcached.server1.port")
                + " "
                + p.getProperty("memcached.server2.host")
                + ":"
                + p.getProperty("memcached.server2.port")), new int[] { 4,
                3 });
        // 宕机报警
        builder.setFailureMode(true);
        memcachedClient = builder.build();
    } catch (IOException e) {
        logger.error("memcachedClient　Exception : {}", e);
        try {
            memcachedClient = builder.build();
        } catch (IOException e1) {
            logger.error("reinit memcachedClient　Exception : {}", e);
        }
    }
}

/**
 *
 * 再次尝试连接服务器
 *
 */
private static void reConnectMemcachedServer() {
    int i = 0;
    memcachedClient = null;
    Properties p = PropertiesBundle
            .loadProperties(PropertiesBundle.MEMCACHED);
    while (i < 3) {
        memcachedClientInstance(p);
        if (memcachedClient != null) {
            logger.info("try connect Memcached Server is success again ");
            break;
        }
    }
    if (i >= 3) {
        logger.info("try connect Memcached Server is fail !");
    }
}

/**
 * 从缓存中获取对应value
 *
 * true:被测试系统 false：本系统
 */
public static Object getValue(String key, boolean isAuto) {
    Object val = null;
    try {
        if (memcachedClient == null) {
            reConnectMemcachedServer();
        }
        if (isAuto) {
            val = memcachedClient.get(key + ip);
            logger.debug("memcached : key=[{}]    val=[{}]", key, val);
        } else {
            val = memcachedClient.get(key);
            logger.debug("memcached : key=[{}]    val=[{}]", key + ip, val);
        }
    } catch (TimeoutException e) {
        logger.debug("Memcache TimeoutException  : {}", e);
        return getValue(key, isAuto, null);
    } catch (InterruptedException e) {
        logger.debug("Memcache InterruptedException  : {}", e);
        return getValue(key, isAuto, null);
    } catch (MemcachedException e) {
        logger.debug("Memcache MemcachedException  : {}", e);
        return getValue(key, isAuto, null);
    }
    return val;
}

/**
 * 如果第一次获取缓存异常，则再次获取
 *
 * @param key
 * @param isAuto
 * @return
 * @throws IOException
 */
private static Object getValue(String key, boolean isAuto, String re) {
    reConnectMemcachedServer();
    return getValue(key, isAuto);
}

/**
 * 删除缓存中对应key和value
 *
 * @param key
 * @return
 */
public static void delValue(String key) {
    try {
        if (memcachedClient == null) {
            reConnectMemcachedServer();
        }
        memcachedClient.delete(key + ip);
        logger.info("delete memcached : key=[{}]", key + ip);
        return;
    } catch (MemcachedException e) {
        logger.debug("Memcache MemcachedException  : {}", e);
        delValue(key, null);
        return;
    } catch (TimeoutException e) {
        logger.debug("Memcache TimeoutException  : {}", e);
        delValue(key, null);
        return;
    } catch (InterruptedException e) {
        logger.debug("Memcache MemcachedException  : {}", e);
        delValue(key, null);
        return;
    }
}

/**
 * 删除缓存中对应key和value
 *
 * @param key
 * @param re
 * @return
 */
public static void delValue(String key, String re) {
    reConnectMemcachedServer();
    delValue(key);
}


/**
 * 将数据放入缓存
 *
 * @param key
 * @return
 */
public static void setValue(
        String key, Object value) {
    try {
        memcachedClient.set(key + ip, catchTime, value);
        logger.info("set memcached : key=[{}]    val=[{}]", key + ip, value);
    } catch (MemcachedException e) {
        logger.info("Memcache MemcachedException  : {}", e);
        setValue(key, value, null);
        return;
    } catch (TimeoutException e) {
        setValue(key, value, null);
        return;
    } catch (InterruptedException e) {
        setValue(key, value, null);
        return;
    }
}

/**
 * 再次尝试将数据放入缓存
 *
 * @param key
 * @param value
 * @param re
 */
public static void setValue(String key, Object value, String re) {
    reConnectMemcachedServer();
    setValue(key, value);
}

/**
 * memcached shut down
 */
public static void shutDown() {
    try {
        memcachedClient.shutdown();
    } catch (IOException e) {
        logger.info("Memcache IOException  : {}", e);
    }
}

}