Java开发中的Memcache简单使用（二）

Memcached的java客户端已经存在三种了：

1  官方提供的基于传统阻塞io由Greg Whalin维护的客户端

2  Dustin Sallings实现的基于java nio的Spymemcached

3  XMemcached

比较：

较早推出的memcached JAVA客户端API，应用广泛，运行比较稳定。

A simple, asynchronous, single-threaded memcached client written in java. 支持异步，单线程的memcached客户端，用到了java1.5版本的concurrent和nio，存取速度会高于前者，但是稳定性不好，测试中常 报timeOut等相关异常。

XMemcached同样是基于java nio的客户端，java nio相比于传统阻塞io模型来说，有效率高（特别在高并发下）和资源耗费相对较少的优点。传统阻塞IO为了提高效率，需要创建一定数量的连接形成连接 池，而nio仅需要一个连接即可（当然,nio也是可以做池化处理），相对来说减少了线程创建和切换的开销，这一点在高并发下特别明显。因此 XMemcached与Spymemcached在性能都非常优秀，在某些方面（存储的数据比较小的情况下）Xmemcached比 Spymemcached的表现更为优秀，具体可以看这个Java Memcached Clients Benchmark。

建议：

由于memcached client for java发布了新版本，性能上有所提高，并且运行稳定，所以建议使用memcached client for java。

XMemcached也使用得比较广泛，而且有较详细的中文API文档，具有如下特点：高性 能、支持完整的协议、支持客户端分布、允许设置节点权重、动态增删节点、支持JMX、与Spring框架和Hibernate-memcached的集 成、客户端连接池、可扩展性好等。

memcached client for java的示例：

package memcache;

import com.whalin.MemCached.MemCachedClient;
import com.whalin.MemCached.SockIOPool;

import java.util.Date;

public class MemcacheManager {
   /**
    * 构建缓存客户端
    */
   private static MemCachedClient cachedClient;
   /**
    * 单例模式实现客户端管理类
    */
   private static MemcacheManager INSTANCE = new MemcacheManager();

   private MemcacheManager() {
      cachedClient = new MemCachedClient();
      // 获取连接池实例
      SockIOPool pool = SockIOPool.getInstance();
      // 设置缓存服务器地址，可以设置多个实现分布式缓存
      pool.setServers(new String[] {"127.0.0.1:11211"});
      // 设置初始连接5
      pool.setInitConn(5);
      // 设置最小连接5
      pool.setMinConn(5);
      // 设置最大连接250
      pool.setMaxConn(250);
      // 设置每个连接最大空闲时间3个小时
      pool.setMaxIdle(1000 * 60 * 60 * 3);
      // 设置连接池维护线程的睡眠时间
      // 设置为0，维护线程不启动
      // 维护线程主要通过log输出socket的运行状况，监测连接数目及空闲等待时间等参数以控制连接创建和关闭。
      pool.setMaintSleep(30);
      // 设置是否使用Nagle算法，因为我们的通讯数据量通常都比较大（相对TCP控制数据）而且要求响应及时，因此该值需要设置为false（默认是true）
      pool.setNagle(false);
      // 设置socket的读取等待超时值
      pool.setSocketTO(3000);
      // 设置socket的连接等待超时值
      pool.setSocketConnectTO(0);
      // 设置完pool参数后最后调用该方法，启动pool。
      pool.initialize();
   }

   /**
    * 获取缓存管理器唯一实例
    * @return
    */
   public static MemcacheManager getInstance() {
      return INSTANCE;
   }

   public void add(String key, Object value) {
      cachedClient.set(key, value);
   }

   public void add(String key, Object value, int milliseconds) {
      cachedClient.set(key, value, milliseconds);
   }

   public void remove(String key) {
      cachedClient.delete(key);
   }

   public void remove(String key, int milliseconds) {
      cachedClient.delete(key, milliseconds, new Date());
   }

   public void update(String key, Object value, int milliseconds) {
      cachedClient.replace(key, value, milliseconds);
   }

   public void update(String key, Object value) {
      cachedClient.replace(key, value);
   }

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

package memcache;

import java.io.Serializable;

public class User implements Serializable{
   private int id;
   private String name;
   private String password;

   @Override
   public String toString() {
      return "User{" +
            "id=" + id +
            ", name='" + name + '\'' +
            ", password='" + password + '\'' +
            '}';
   }

   public User(int id, String name, String password) {
      this.id = id;
      this.name = name;
      this.password = password;
   }

   public int getId() {
      return id;
   }

   public void setId(int id) {
      this.id = id;
   }

   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }

   public String getPassword() {
      return password;
   }

   public void setPassword(String password) {
      this.password = password;
   }
}

package memcache;

import java.util.ArrayList;
import java.util.List;
import java.util.logging.Logger;

public class Test {
   // 日志打印对象
   private static final Logger LOG = Logger.getLogger("memcached");
   /**
    * ---------- java_memcached-release ----------
    */
   private static MemcacheManager memcacheManager = MemcacheManager.getInstance();

   public static void addCached() {
      User user = null;
      for(int i=1; i<=8; ++i) {
         user = new User(i, "第 " + i + " 个用户创建成功！", "000000");
         // 将User对象添加memcache缓存
         memcacheManager.add("T" + i, user);
      }
   }

   public static void showCached() {
      for(int i=1; i<=8; ++i) {
         // 获取memcache缓存中的对象
         LOG.warning(memcacheManager.get("T" + i).toString());
      }
   }



   public static void main(String[] args) {
      addCached();

      for(int i=1; i<=16; ++i) {
         User user= (User)memcacheManager.get("T"+i);
         if(user !=null){
            System.out.println(user);
           }else {
           System.out.println("id"+i+"用户从数据库取");
          }
      }
   }
}

结果：

User{id=1, name='第 1 个用户创建成功！', password='000000'}

User{id=2, name='第 2 个用户创建成功！', password='000000'}
User{id=3, name='第 3 个用户创建成功！', password='000000'}
User{id=4, name='第 4 个用户创建成功！', password='000000'}
User{id=5, name='第 5 个用户创建成功！', password='000000'}
User{id=6, name='第 6 个用户创建成功！', password='000000'}
User{id=7, name='第 7 个用户创建成功！', password='000000'}
User{id=8, name='第 8 个用户创建成功！', password='000000'}
id9用户从数据库取
id10用户从数据库取
id11用户从数据库取
id12用户从数据库取
id13用户从数据库取
id14用户从数据库取
id15用户从数据库取
id16用户从数据库取