MemcachedBasedCache.java

package org.dayatang.cache.memcached;

import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
import org.apache.commons.lang3.StringUtils;
import org.dayatang.cache.Cache;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Arrays;
import java.util.Date;
import java.util.Map;
import java.util.Set;

/**
 * 基于Memcached的缓存实现
 * 
 * @author chencao
 * 
 */
public class MemcachedBasedCache implements Cache {

	private static final Logger LOGGER = LoggerFactory
			.getLogger(MemcachedBasedCache.class);

	private MemCachedClient mcc;

	private String[] servers;

	private int initConn = 100;

	private int minConn = 100;

	private int maxConn = 250;

	private int connectTimeout = 3000;

	private String poolName;

	private boolean initialized = false;

	public Object get(String key) {
		init();
		Object obj = mcc.get(key);
		debug("命中缓存：{}，key：{}", new Object[] { (obj != null), key });
		return obj;
	}

	@Override
	public Map<String, Object> get(String... keys) {
		init();
		Map<String, Object> map = mcc.getMulti(keys);
		return map;
	}

	public boolean containsKey(String key) {
		init();
		return mcc.keyExists(key);
	}

	public void put(String key, Object value) {
		init();
		mcc.set(key, value);
		debug("缓存数据，key：{}", key);
	}

	public void put(String key, Object value, Date expiry) {
		init();
		mcc.set(key, value, expiry);
		debug("缓存数据，key：{}，过期日期：{}", key, expiry);
	}

	public void put(String key, Object value, long living) {
		init();
		Date now = new Date();
		Date expiry = new Date(now.getTime() + living);
		put(key, value, expiry);
	}

	public boolean remove(String key) {
		init();
		boolean result = mcc.delete(key);
		debug("删除缓存，key：{}", key);
		return result;
	}

	@SuppressWarnings("rawtypes")
	protected void prepareClient() {

		// grab an instance of our connection pool
		SockIOPool pool = null;
		if (StringUtils.isBlank(getPoolName())) {
			pool = SockIOPool.getInstance();
			mcc = new MemCachedClient();
		} else {
			pool = SockIOPool.getInstance(getPoolName());
			mcc = new MemCachedClient(getPoolName());
		}

		// Integer[] weights = { 5, 1 };

		// set the servers and the weights
		pool.setServers(servers);
		// pool.setWeights(weights);

		// set some basic pool settings
		// 5 initial, 5 min, and 250 max conns
		// and set the max idle time for a conn
		// to 6 hours
		pool.setInitConn(getInitConn());
		pool.setMinConn(getMinConn());
		pool.setMaxConn(getMaxConn());
		pool.setMaxIdle(1000 * 60 * 60 * 6);

		// set the sleep for the maint thread
		// it will wake up every x seconds and
		// maintain the pool size
		pool.setMaintSleep(30);
//		pool.setBufferSize(1024);

		// set some TCP settings
		// disable nagle
		// set the read timeout to 3 secs
		// and don't set a connect timeout
		pool.setNagle(false);
		pool.setSocketTO(3000);
		pool.setSocketConnectTO(getConnectTimeout());

		// initialize the connection pool
		pool.initialize();

		// lets set some compression on for the client
		// compress anything larger than 64k
		// mcc.setCompressEnable(true);
		// mcc.setCompressThreshold(64 * 1024);

		Map map = mcc.stats(servers);
		Set keys = map.keySet();
		if (keys.size() == 0) {
			error("客户端创建遇到错误，无法创建。");
		}
		for (Object key : keys) {
			// logger.info("客户端创建完成。key = 【{}】， status = 【{}】", key, map
			// .get(key));
			info("客户端创建完成。key = 【{}】", key);
		}

	}

	public String[] getServers() {
		return servers;
	}

	public void setServers(String... servers) {
		this.servers = Arrays.copyOf(servers, servers.length);
	}

	/**
	 * 获取初始化连接数
	 * 
	 * @return 初始化连接数
	 */
	public int getInitConn() {
		return initConn;
	}

	/**
	 * 设置初始化连接数
	 * 
	 * @param initConn
	 *            初始化连接数
	 */
	public void setInitConn(int initConn) {
		this.initConn = initConn;
	}

	/**
	 * 获取最小连接数
	 * 
	 * @return 最小连接数
	 */
	public int getMinConn() {
		return minConn;
	}

	/**
	 * 设置最小连接数
	 * 
	 * @param minConn
	 *            最小连接数
	 */
	public void setMinConn(int minConn) {
		this.minConn = minConn;
	}

	/**
	 * 获取最大连接数
	 * 
	 * @return 最大连接数
	 */
	public int getMaxConn() {
		return maxConn;
	}

	/**
	 * 设置最大连接数
	 * 
	 * @param maxConn
	 *            最大连接数
	 */
	public void setMaxConn(int maxConn) {
		this.maxConn = maxConn;
	}

	/**
	 * 获取连接超时时间（毫秒）
	 * 
	 * @return 连接超时时间（毫秒）
	 */
	public int getConnectTimeout() {
		return connectTimeout;
	}

	/**
	 * 设置连接超时时间（毫秒）
	 * 
	 * @param connectTimeout
	 *            连接超时时间（毫秒）
	 */
	public void setConnectTimeout(int connectTimeout) {
		this.connectTimeout = connectTimeout;
	}

	/**
	 * 获取socket pool名称
	 * 
	 * @return socket pool名称
	 */
	public String getPoolName() {
		return poolName;
	}

	/**
	 * 设置socket pool名称
	 * 
	 * @param poolName
	 *            socket pool名称
	 */
	public void setPoolName(String poolName) {
		this.poolName = poolName;
	}

	public void init() {

		if (initialized) {
			return;
		}
		if (servers == null || servers.length == 0) {
			throw new IllegalStateException("Must assign memcached server address");
		}

		for (String server : servers) {
			info("准备为Memcached服务器{}创建客户端...", server);
			info("最小连接数为：{}", minConn);
			info("最大接数为：{}", maxConn);
			info("初始化连接数为：{}", initConn);
			info("连接超时时间为：{}毫秒", connectTimeout);
		}
		prepareClient();
		// if (logger.isDebugEnabled()) {
		// logger.debug("客户端创建完成。...");
		// }
		initialized = true;

	}

	private void debug(String message, Object... params) {
		if (LOGGER.isDebugEnabled()) {
			LOGGER.debug(message, params);
		}
	}

	private void info(String message, Object... params) {
		if (LOGGER.isInfoEnabled()) {
			LOGGER.info(message, params);
		}
	}

	private void error(String message, Object... params) {
		if (LOGGER.isErrorEnabled()) {
			LOGGER.error(message, params);
		}
	}

}