Windows下java memcached 使用

一，Memcached介绍

memcached是被广泛使用的分布式缓存技术，使用它的目的是，通过它缓存数据库查询结果，减少数据库访问次数，提高动态Web应用的速度。
memcached作为分布式缓存服务器，具有如下的特点：
（1）协议简单：
memcached的服务器和客户端使用的通信协议是简单的基于文本行的协议，因此我们可以通过telnet也能在memcached服务器上保存/获取数据，如下：

（2）基于libevent的事件处理：
libevent是个程序库，memcached通过libevent能在linux、BSD等操作系统上发挥其高性能的特性。
（3）内置内存存储方式：
为了提高性能，memcached将数据保存在其内置的内存存储空间里，同样也是因为如此，所以当memcached重启、重启操作系统等操作会导致memcached存储的数据丢失。
另外，当内容的容量达到指定的值后，memcached会使用LRU算法自动删除不使用的缓存，以释放空间。
（4）memcached不互相通信的分布式：
经常说到memcached是分布式的缓存技术，但是它的分布式不是指服务器端的分布式，因为服务器端并没有分布式的功能。它的分布式是通过客户端来实现的，见下图

二，Windows下memcached的使用

1， 用到的jar包

其中Memcached-Java-Client-3.0.0.jar为memcached客户端，jar和源码下载地址http://search.maven.org/。

2， 部分代码

public class MemcachedTest {

    protected static MemCachedClient mcc = new MemCachedClient();
    protected static MemcachedTest memcachedTest = new MemcachedTest();

    //设置与memcached服务器的连接信息
    static{
        /// 服务器列表和其权重
        String [] servers  = {"127.0.0.1:11211","192.168.0.101:11211"};
        Integer [] weights = {5,5};

        // 获取sock连接池的实例对象
        SockIOPool pool = SockIOPool.getInstance();

        pool.setServers(servers);
        pool.setWeights(weights);

        // 设置初始连接数、最小和最大连接数以及最大处理时间
        pool.setInitConn(5);
        pool.setMinConn(5);
        pool.setMaxConn(100);
        pool.setMaxIdle(1000*60*60*6);

        // 设置主线程的睡眠时间
        pool.setMaintSleep(30);

        // 设置TCP的参数，连接超时等
        pool.setNagle(false);
        pool.setSocketTO(3000);
        pool.setSocketConnectTO(0);

        pool.setHashingAlg(SockIOPool.CONSISTENT_HASH);

        // 初始化连接池
        pool.initialize();

    }

    /**
     * 保护型构造方法，不允许实例化！
     * 
     */
    protected MemcachedTest() {

    }

    /**
     * 获取唯一实例.
     * 
     * @return
     */
    public static MemcachedTest getInstance() {
        return memcachedTest;
    }

    /**
     * 添加数据
     * @param key
     * @param value
     * @return
     */
    public boolean add(String key, String value){
        return mcc.add(key, value);
    }

    public boolean add(String key, String value, Date expiry){
        return mcc.add(key, value, expiry);
    }

    public boolean replace(String key, String value){
        return mcc.replace(key,value);
    }

    public boolean replace(String key, String value, Date expiry){
        return mcc.replace(key, value, expiry);
    }

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

    public Object flush(){
        return mcc.flushAll();
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MemcachedTest mt = MemcachedTest.getInstance();
        mt.flush();
        for (int i = 0; i < 10; i ++){
            mt.add("hello"+ i, "world" + i);
        }
        for(int i = 0; i < 10; i ++){
            System.out.println("the value of key Hello" + i +" is: " + mt.get("hello" + i));
        }
    }

}

首先，我们需要一个memcachedClient对象，该对象实现将数据添加到memcached服务器或者从服务器读取数据。然后初始化一个SockIOPool对象，该对象用来维护一个到memcached服务器的持续的连接池，连接池必须在使用前初始化。

3， memcached Client源码解读

在将数据添加到服务器这个过程，主要涉及到了客户端的下面的几个类：
MemCachedClient：生成客户端的入口
AscIIClient： memcachedClient的子类，负责具体的client的实例化
SchoonerSockIOPool
SockIOPool

（1） 初始化一个memcached client对象
protected static MemCachedClient mcc = new MemCachedClient();
查看client的源码发现它会通过解析参数，生成一个子类AscIIClient的对象。

    /**
     * Creates a new instance of MemCachedClient.
     */
    public MemCachedClient() {
        this(null, true, false);
    }

    /**
     * Create memcached client.
     * 
     * @param poolName
     *            name of SockIOPool
     * @param isTCP
     *            use tcp protocol
     * @param binaryProtocal
     *            use binary protocol.
     */
     public MemCachedClient(String poolName, boolean isTcp, boolean binaryProtocal) {
        if (binaryProtocal)
            client = new BinaryClient(poolName);
        else
            client = isTcp ? new AscIIClient(poolName) : new AscIIUDPClient(poolName);
    }

（2）在子类AscIIClient中，定义了一个pool的实例如下：

// pool instance
    private SchoonerSockIOPool pool;

根据上面第一点，在生成memcached client实例时，其实实际上生成的AscIIClient的实例，如下：

/**
     * Creates a new instance of MemCachedClient accepting a passed in pool
     * name.
     * 
     * @param poolName
     *            name of SockIOPool
     * @param binaryProtocal
     *            whether use binary protocol.
     */
    public AscIIClient(String poolName) {
        super((MemCachedClient) null);
        this.poolName = poolName;
        init();
    }

其中init（）方法主要是完成一个默认的（default）client的初始化。

/**
     * Initializes client object to defaults.
     * 
     * This enables compression and sets compression threshhold to 15 KB.
     */
    private void init() {
        this.sanitizeKeys = true;
        this.primitiveAsString = false;
        this.compressEnable = false;
        this.compressThreshold = COMPRESS_THRESH;
        this.defaultEncoding = "UTF-8";
        this.poolName = (this.poolName == null) ? "default" : this.poolName;

        // get a pool instance to work with for the life of this instance
        this.pool = SchoonerSockIOPool.getInstance(poolName);
    }

（3）SockIOPool和SchoonerSockIOPool的关系：
在SockIOPool中，定义了一个SchoonerSockIOPool的实例，在初始化SockIOPool的时候，同时会获取一个SchoonerSockIOPool的对象。

// 获取sock连接池的实例对象
        SockIOPool pool = SockIOPool.getInstance();

/**
     * Single argument version of factory used for back compat. Simply creates a
     * pool named "default".
     * 
     * @return instance of SockIOPool
     */
    public static SockIOPool getInstance() {
        SockIOPool whalinSockIOPool = new SockIOPool();
        whalinSockIOPool.schoonerSockIOPool = SchoonerSockIOPool.getInstance("default");
        return whalinSockIOPool;
    }

（4） 通过SchoonerSockIOPool.getInstance方法获取一个SchoonerSockIOPool的实例时，程序会先检查连接池里面是否有名称为“default”的pool，若有，则取处理返回； 若无，生成名称为“default”的pool，并将该pool放置到连接池里面。

/**
     * Factory to create/retrieve new pools given a unique poolName.
     * 
     * @param poolName
     *            unique name of the pool
     * @return instance of SockIOPool
     */
    public static SchoonerSockIOPool getInstance(String poolName) {
        SchoonerSockIOPool pool;

        synchronized (pools) {
            if (!pools.containsKey(poolName)) {
                pool = new SchoonerSockIOPool(true);
                pools.putIfAbsent(poolName, pool);
            }
        }

        return pools.get(poolName);
    }

未完待续……