memchache环境搭建

         本来我只知道memchached是一种缓存技术，但是后来才知道原来memchached也算是nosql的一种技术，就记录到数据库里面了。
        首先是memchached的安装，到相应的目录，memcached.exe –d install ，然后启动
memcached.exe -d start ，此时memcached已经注册为开机启动服务 ，安装完成。
        接下来搭建java环境，首先是需要的jar包：
memcached-release_2.5.1.jar
查阅资料说还需要：
slf4j-api-1.5.2.jar
slf4j-simple-1.5.2.jar
commons-pool-1.3.jar
但是我自己没有发展用途。可能是简单应用还没有碰到。
       接着首先是一个主类，读取配置：

package com.css.db.memcached;

import java.io.InputStream;
import java.util.Properties;

public class MemcachedConfiguration {
	private static MemcachedConfiguration instance;
	private String[] servers = null;
	private Integer[] weights = null;
	private Integer initConn = null;
	private Integer minConn = null;
	private Integer maxConn = null;
	private long maxIdle;
	private long maintSleep;
	private boolean nagle = false;
	private Integer socketTO = null;
	private Integer socketConnectTO = null;
	private boolean compressEnable = true;
	private long compressThreshold;
	private boolean primitiveAsString = true;

	static synchronized public MemcachedConfiguration getInstance() {
		// if (instance == null)
		{
			instance = new MemcachedConfiguration("/memcached.properties");
		}
		return instance;
	}

	protected MemcachedConfiguration(String propertiesFile) {
		InputStream fin = getClass().getResourceAsStream(propertiesFile);
		Properties dbProps = new Properties();
		try {
			dbProps.load(fin);
			this.servers = PropertiesHelper.getString("memcached.servers",
					dbProps, "127.0.0.1:11211").split(",");
			this.weights = toIntArray(PropertiesHelper.getString(
					"memcached.port", dbProps, "1").split(","));
			this.initConn = PropertiesHelper.getInt("memcached.initConn",
					dbProps, 20);
			this.minConn = PropertiesHelper.getInt("memcached.minConn",
					dbProps, 20);
			this.maxConn = PropertiesHelper.getInt("memcached.maxConn",
					dbProps, 250);
			this.maxIdle = PropertiesHelper.getLong("memcached.maxIdle",
					dbProps, 360000000);
			this.maintSleep = PropertiesHelper.getLong("memcached.maintSleep",
					dbProps, 3000);
			this.nagle = PropertiesHelper.getBoolean("memcached.nagle",
					dbProps, false);
			this.socketTO = PropertiesHelper.getInt("memcached.socketTO",
					dbProps, 3000);
			this.socketConnectTO = PropertiesHelper.getInt(
					"memcached.socketConnectTO", dbProps, 0);
			this.compressEnable = PropertiesHelper.getBoolean(
					"memcached.compressEnable", dbProps, true);
			this.compressThreshold = PropertiesHelper.getLong(
					"memcached.compressThreshold", dbProps, 20 * 1024);
			this.primitiveAsString = PropertiesHelper.getBoolean(
					"memcached.primitiveAsString", dbProps, true);
			fin.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static Integer[] toIntArray(String[] str) {
		Integer[] num = new Integer[str.length];
		for (int i = 0; i < num.length; i++) {
			num[i] = Integer.parseInt(str[i]);
		}
		return num;
	}

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

	public Integer[] getWeights() {
		return weights;
	}

	public Integer getInitConn() {
		return initConn;
	}

	public Integer getMinConn() {
		return minConn;
	}

	public Integer getMaxConn() {
		return maxConn;
	}

	public boolean getNagle() {
		return nagle;
	}

	public Integer getSocketTO() {
		return socketTO;
	}

	public Integer getSocketConnectTO() {
		return socketConnectTO;
	}

	public boolean getCompressEnable() {
		return compressEnable;
	}

	public boolean getPrimitiveAsString() {
		return primitiveAsString;
	}

	public long getMaxIdle() {
		return maxIdle;
	}

	public long getMaintSleep() {
		return maintSleep;
	}

	public long getCompressThreshold() {
		return compressThreshold;
	}
}

然后是配置文件：

#####memcached 服务器
memcached.servers=127.0.0.1\:11211
#####memcached 服务器权重
memcached.weights=3,3
#####memcached socke连接池的初始连接数
memcached.initConn=20
#####memcached socke连接池的最小连接数
memcached.minConn=20
#####memcached socke连接池的最大连接数
memcached.maxConn=250
#####memcached socke连接最大空闲时间
memcached.maxIdle=360000000
#####memcached 主线程睡眠时间
memcached.maintSleep=3000
#####memcached 关闭nagle算法
memcached.nagle=false
#####memcached 设置读取超时
memcached.socketTO=3000
#####memcached 设置连接超时
memcached.socketConnectTO=0
#####memcached 压缩设置
memcached.compressEnable=true
#####memcached 超过指定大小（单位B）的数据都会被压缩
memcached.compressThreshold=20480
#####memcached java默认的类型没有实现序列化，该参数设置为true
memcached.primitiveAsString=true

然后是主类：

package com.css.db.memcached;

import java.util.Date;

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

public class MemCachedFactory {
	private static MemCachedClient mcc = new MemCachedClient();
	static {
		MemcachedConfiguration mc = MemcachedConfiguration.getInstance();
		SockIOPool pool = SockIOPool.getInstance();
		pool.setServers(mc.getServers());
		pool.setWeights(mc.getWeights());
		pool.setInitConn(mc.getInitConn());
		pool.setMinConn(mc.getMinConn());
		pool.setMaxConn(mc.getMaxConn());
		pool.setMaxIdle(mc.getMaxIdle());
		pool.setMaintSleep(mc.getMaintSleep());
		pool.setNagle(mc.getNagle());
		pool.setSocketTO(mc.getSocketTO());
		pool.setSocketConnectTO(mc.getSocketConnectTO());
		pool.initialize();
		// mcc.setCompressEnable(mc.getCompressEnable());
		// mcc.setCompressThreshold(mc.getCompressThreshold());
		mcc.setPrimitiveAsString(mc.getPrimitiveAsString());
	}

	private MemCachedFactory() {

	}

	public static MemCachedClient INS() {
		return mcc;
	}

	public static boolean set(String key, Object value) {
		return mcc.set(key, value);
	}

	public static boolean set(String key, Object value, Date date) {
		return mcc.set(key, value, date);
	}

	public static boolean set(String key, Object value, Integer size) {
		return mcc.set(key, value, size);
	}

	public static Object get(String key) {
		return mcc.get(key);
	}

	public static Object delete(String key) {
		return mcc.delete(key);
	}
}

最后做个小测试：

package com.css.db.memcached;
import com.css.db.memcached.MemCachedFactory;
public class mainTest {
	public static void main(String[] args){
		MemCachedFactory.set("key","value");
		System.out.println(MemCachedFactory.get("key"));  
	}
	
}

        再次还要多说一点，就是存对象的时候key的处理，为了做到对象的唯一性，本地系统使用了，对象的getClass方法加上对象对应的id相加，然后MD5加密做的处理，这样能保持对象的唯一性，还能防止重名冲突。
        这里还要再说一点，要是存的是一个list对象，又应该则麽办呢，再次查询，发现存储的是对应的sql语句，然后MD5处理，这里有两种机制，一种是设立过期时间，这样，在时间过期以后就会重新取得新的数据，还有一种办法就是在对于有对list列表更新的业务逻辑处，对相对应的list缓存清除掉，这样再取的时候就也是新的。第二种比较繁琐，但是及时。
        分享让更多人受益！