Memcached学习笔记 — 第四部分:Memcached Java 客户端-gwhalin(1)-介绍及使用

介绍

Memcached java client是官方推荐的最早的memcached java客户端。最新版本：java_memcached-release_2.6.1。

官方下载地址：https://github.com/gwhalin/Memcached-Java-Client

采用阻塞式SOCKET通讯，据说目前版本进行了很多优化，性能有所提高（只看过1.5的源代码，还没来及看最新的）
提供key方式的连接池，默认连接池key为default。（老版本了）。2.6.1版本支持apache-commoms-pool作为连接池。
支持权重配置。
后期的版本提增加了cas支持和getMutl功能

官方示例代码

import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
import com.schooner.MemCached.MemcachedItem;
public class MemcachedForJavaExample {
// create a static client as most installs only need
// a single instance
protected static MemCachedClient mcc = new MemCachedClient();
// set up connection pool once at class load
static {
// server list and weights
String[] servers = { "localhost:11211", "localhost:11212", "localhost:11213" };
Integer[] weights = { , , };
// grab an instance of our connection pool
SockIOPool pool = SockIOPool.getInstance();
// set the servers and the weights
pool.setServers(servers);
pool.setWeights(weights);
pool.setHashingAlg(SockIOPool.CONSISTENT_HASH);
// 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();
pool.setMinConn();
pool.setMaxConn();
pool.setMaxIdle( * * * );
// set the sleep for the maint thread
// it will wake up every x seconds and
// maintain the pool size
pool.setMaintSleep();
// 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();
pool.setSocketConnectTO();
// initialize the connection pool
pool.initialize();
}
public static void main(String[] args) {
System.out.println("SET: " + mcc.set("key1", "value1"));
System.out.println("SET: " + mcc.set("key2", "value2"));
System.out.println("SET: " + mcc.set("key3", "value3"));
System.out.println("GET: " + mcc.get("key1"));
MemcachedItem item = mcc.gets("key1");
System.out.println("GETS: value=" + item.getValue() + ",CasUnique:"+item.getCasUnique());
System.out.println("SET: " + mcc.set("key1", "value1_1"));
System.out.println("CAS: " + mcc.cas("key1", "value1_2", item.getCasUnique())); //必须FALSE
System.out.println("getMulti:" + mcc.getMulti(new String[]{"key1","key2","key3"}));
}
}

import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
import com.schooner.MemCached.MemcachedItem;

public class MemcachedForJavaExample {

	// create a static client as most installs only need
	// a single instance
	protected static MemCachedClient mcc = new MemCachedClient();

	// set up connection pool once at class load
	static {

		// server list and weights
		String[] servers = { "localhost:11211", "localhost:11212", "localhost:11213" };

		Integer[] weights = { 3, 3, 2 };

		// grab an instance of our connection pool
		SockIOPool pool = SockIOPool.getInstance();

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

		// 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(5);
		pool.setMinConn(5);
		pool.setMaxConn(250);
		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);

		// 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(0);

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

	public static void main(String[] args) {
		System.out.println("SET: " + mcc.set("key1", "value1"));
		System.out.println("SET: " + mcc.set("key2", "value2"));
		System.out.println("SET: " + mcc.set("key3", "value3"));
		System.out.println("GET: " + mcc.get("key1"));
		MemcachedItem item = mcc.gets("key1");
		System.out.println("GETS: value=" + item.getValue() + ",CasUnique:"+item.getCasUnique());
		System.out.println("SET: " + mcc.set("key1", "value1_1"));
		System.out.println("CAS: " + mcc.cas("key1", "value1_2", item.getCasUnique())); //必须FALSE
		System.out.println("getMulti:" + mcc.getMulti(new String[]{"key1","key2","key3"}));
	}

}

我的代码

这个标题不好取，因为是我自己的想法，还需要大家多提意见，一起讨论。想叫“建议代码”或者“推荐代码”，觉得不合适，还是先叫“我的代码”吧，呵呵。

我的思路

1. 在原始客户端上层，根据业务需求封装MemcachedService(或叫MemcachedClient)，负责缓存功能的包装。如：你的业务只需要add,set,get,gets,cas,delete业务，那就只封装这几个功能。这样做的好处是，屏蔽了各种客户端的API差异，让你的业务系统与客户端实现解耦合，如果你以后需要换客户端实现，对你的业务系统不会照成影响。
2. 一般不要直接采用new的方式在你的代码中显示使用memcached客户端实现，应该采用单例的方式使用memcached客户端实现，或者使用Spring的singleton方式配置。Memcached客户端实现是线程安全的。
3. memcached客户端一般都需要大量的配置，考虑扩展和配置修改，应该把参数设置设计为可配置的，可以写到propertis配置文件中或是使用Spring进行配置。

我的实现

业务层封装接口

/**
* Memcached 常用功能接口定义,用于业务层直接使用，屏蔽各种客户端实现的API差异，实现解耦客户端与业务系统的目的
* 无过期时间和flags支持，无append,prepend,replace,incr,decr等操作
*
* @author zhangpu
*
*/
public interface MemcachedClientService {
String get(String key);
CacheItem gets(String key);
boolean add(String key, String value);
boolean set(String key, String value);
boolean cas(String key, String value, long unique);
boolean delete(String key)
boolean flushAll();
}

/**
 * Memcached 常用功能接口定义,用于业务层直接使用，屏蔽各种客户端实现的API差异，实现解耦客户端与业务系统的目的
 * 无过期时间和flags支持，无append,prepend,replace,incr,decr等操作
 *
 * @author zhangpu
 *
 */
public interface MemcachedClientService {

	String get(String key);

	CacheItem gets(String key);

	boolean add(String key, String value);

	boolean set(String key, String value);

	boolean cas(String key, String value, long unique);

	boolean delete(String key)

	boolean flushAll();

}

public class CacheItem {
private String key;
private String value;
private long unique;
public CacheItem() {
super();
}
public CacheItem(String key, String value, long unique) {
super();
this.key = key;
this.value = value;
this.unique = unique;
}
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public long getUnique() {
return unique;
}
public void setUnique(long unique) {
this.unique = unique;
}
}

public class CacheItem {

	private String key;
	private String value;
	private long unique;

	public CacheItem() {
		super();
	}

	public CacheItem(String key, String value, long unique) {
		super();
		this.key = key;
		this.value = value;
		this.unique = unique;
	}

	public String getKey() {
		return key;
	}

	public void setKey(String key) {
		this.key = key;
	}

	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
	}

	public long getUnique() {
		return unique;
	}

	public void setUnique(long unique) {
		this.unique = unique;
	}

}

客户端缓存服务实现

/**
* Memcached for java客户端缓存服务实现
* @author zhangpu
*
*/
public class MemcachedClientJava implements MemcachedClientService {
MemCachedClient mmc = MemcachedClientFactory.getInstance();
public boolean add(String key, String value) {
return mmc.add(key, value);
}
public boolean cas(String key, String value, long unique) {
return mmc.cas(key, value, unique);
}
public String get(String key) {
return (String) mmc.get(key);
}
public CacheItem gets(String key) {
MemcachedItem item = mmc.gets(key);
return new CacheItem(key, (String) item.getValue(), item.getCasUnique());
}
public boolean set(String key, String value) {
return mmc.set(key, value);
}
public boolean delete(String key) {
return mmc.delete(key);
}
public boolean flushAll() {
return mmc.flushAll();
}
}

/**
 * Memcached for java客户端缓存服务实现
 * @author zhangpu
 *
 */
public class MemcachedClientJava implements MemcachedClientService {

	MemCachedClient mmc = MemcachedClientFactory.getInstance();
	public boolean add(String key, String value) {
		return mmc.add(key, value);
	}

	public boolean cas(String key, String value, long unique) {
		return mmc.cas(key, value, unique);
	}

	public String get(String key) {
		return (String) mmc.get(key);
	}

	public CacheItem gets(String key) {
		MemcachedItem item = mmc.gets(key);
		return new CacheItem(key, (String) item.getValue(), item.getCasUnique());
	}

	public boolean set(String key, String value) {
		return mmc.set(key, value);
	}

	public boolean delete(String key) {
		return mmc.delete(key);
	}

	public boolean flushAll() {
		return mmc.flushAll();
	}

}

获取客户端实例

/**
* MemcachedClient 单例(JDK1.5以上)
* @author zhangpu
*
*/
public class MemcachedClientFactory extends ConfigurableConstants{
private static volatile MemCachedClient mmc;
static {
init("memcached-client.properties");
//{ "localhost:11211", "localhost:11212", "localhost:11213" };
String[] servers = getProperty("memcached-servers","").split(",");
Integer[] weights = null;
String weightsCfg = getProperty("memcached-weights","");
if(weightsCfg != null){
String[] wcfg = weightsCfg.split(",");
weights = new Integer[wcfg.length];
for (int i = ; i < weights.length; i++) {
weights[i] = Integer.valueOf(wcfg[i]);
}
}else{
weights = new Integer[servers.length];
for (int i = ; i < weights.length; i++) {
weights[i] = ;
}
}
SockIOPool pool = SockIOPool.getInstance();
pool.setServers(servers);
pool.setWeights(weights);
pool.setHashingAlg(SockIOPool.CONSISTENT_HASH);
pool.setInitConn(getProperty("memcached-initConn",));
pool.setMinConn(getProperty("memcached-minConn",));
pool.setMaxConn(getProperty("memcached-maxConn",));
pool.setMaxIdle( * * * );
pool.setMaintSleep();
pool.setNagle(false);
pool.setSocketTO();
pool.setSocketConnectTO();
pool.initialize();
}
private MemcachedClientFactory() {
}
public static MemCachedClient getInstance() {
if (mmc == null) {
synchronized (MemCachedClient.class) {
if (mmc == null) {
mmc = new MemCachedClient();
}
}
}
return mmc;
}
}

/**
 * MemcachedClient 单例(JDK1.5以上)
 * @author zhangpu
 *
 */
public class MemcachedClientFactory extends ConfigurableConstants{

	private static volatile MemCachedClient mmc;

	static {
		init("memcached-client.properties");

		//{ "localhost:11211", "localhost:11212", "localhost:11213" };
		String[] servers = getProperty("memcached-servers","").split(",");

		Integer[] weights = null;
		String weightsCfg = getProperty("memcached-weights","");
		if(weightsCfg != null){
			String[] wcfg = weightsCfg.split(",");
			weights = new Integer[wcfg.length];
			for (int i = 0; i < weights.length; i++) {
				weights[i] = Integer.valueOf(wcfg[i]);
			}
		}else{
			weights = new Integer[servers.length];
			for (int i = 0; i < weights.length; i++) {
				weights[i] = 1;
			}
		}

		SockIOPool pool = SockIOPool.getInstance();

		pool.setServers(servers);
		pool.setWeights(weights);
		pool.setHashingAlg(SockIOPool.CONSISTENT_HASH);

		pool.setInitConn(getProperty("memcached-initConn",5));
		pool.setMinConn(getProperty("memcached-minConn",5));
		pool.setMaxConn(getProperty("memcached-maxConn",250));
		pool.setMaxIdle(1000 * 60 * 60 * 6);

		pool.setMaintSleep(30);

		pool.setNagle(false);
		pool.setSocketTO(3000);
		pool.setSocketConnectTO(0);

		pool.initialize();
	}

	private MemcachedClientFactory() {

	}

	public static MemCachedClient getInstance() {
		if (mmc == null) {
			synchronized (MemCachedClient.class) {
				if (mmc == null) {
					mmc = new MemCachedClient();
				}
			}
		}
		return mmc;
	}

}

参数配置

/**
* 通过 properties 文件配置设置常量基类负责加载和读取 properties 属性文件并提供访问的静态工具方法
*
* @author zhangpu
*
*/
public class ConfigurableConstants {
protected static Log logger = LogFactory.getLog(ConfigurableConstants.class);
protected static Properties p = new Properties();
protected static void init(String propertyFileName) {
InputStream in = null;
try {
in = ConfigurableConstants.class.getClassLoader().getResourceAsStream(propertyFileName);
if (in != null)
p.load(in);
} catch (IOException e) {
logger.error("load " + propertyFileName + " into Constants error!");
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
logger.error("close " + propertyFileName + " error!");
}
}
}
}
protected static String getProperty(String key, String defaultValue) {
return p.getProperty(key, defaultValue);
}
protected static int getProperty(String key, int defaultValue) {
try {
return Integer.parseInt(getProperty(key, ""));
} catch (Exception e) {
return defaultValue;
}
}
}

/**

  * 通过 properties 文件配置设置常量基类 负责加载和读取 properties 属性文件并提供访问的静态工具方法

  *

  * @author zhangpu

  *

  */

public class ConfigurableConstants {

      protected static Log logger = LogFactory.getLog(ConfigurableConstants.class);

      protected static Properties p = new Properties();

      protected static void init(String propertyFileName) {

              InputStream in = null;

              try {

                     in = ConfigurableConstants.class.getClassLoader().getResourceAsStream(propertyFileName);

                     if (in != null)

                             p.load(in);

              } catch (IOException e) {

                     logger.error("load " + propertyFileName + " into Constants error!");

              } finally {

                     if (in != null) {

                             try {

                                    in.close();

                             } catch (IOException e) {

                                    logger.error("close " + propertyFileName + " error!");

                             }

                     }

              }

      }

      protected static String getProperty(String key, String defaultValue) {

              return p.getProperty(key, defaultValue);

      }

      protected static int getProperty(String key, int defaultValue) {

              try {

                     return Integer.parseInt(getProperty(key, ""));

              } catch (Exception e) {

                     return defaultValue;

              }

      }

}

配置文件

memcached-client.properties

memcached-client.properties
memcached-servers=localhost:,localhost:,localhost:
memcached-weights=,,
memcached-initConn=
memcached-minConn=
memcached-maxConn=

memcached-client.properties
memcached-servers=localhost:11211,localhost:11212,localhost:11213
memcached-weights=3,3,2
memcached-initConn=5
memcached-minConn=5
memcached-maxConn=250

后续提供性能测试，spring整合，版本差异测试，及其它客户端对比。