Memcached 入门介绍(安装与配置)

package memcached.test;
import java.util.Date;
import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
/**
 * 运用memcached的缓存实用类.
 */
public class MemCached {
  // 新建全局的独一实例
  protected static MemCachedClient mcc = new MemCachedClient();
  protected static MemCached memCached = new MemCached();
  // 设置与缓存服务器的连贯池
  static {
    // 服务器列表和其权重
    String[] servers = { "127.0.0.1:11211" };
    Integer[] weights = { 3 };
    // 获取socke连贯池的实例对象
    // 这个类用来新建治理客户端和服务器通信连贯池，
    // 客户端主要的工作（包括数据通信、服务器定位、hash码生成等）都是由这个类完成的。
    SockIOPool pool = SockIOPool.getInstance();
    // 设置服务器信息
    pool.setServers(servers);
    
    // 设置Server权重
    pool.setWeights(weights);
    // 设置初始连贯数、最小和最大连贯数以及最大处置工夫
    pool.setInitConn(5);
    pool.setMinConn(5);
    pool.setMaxConn(250);
    pool.setMaxIdle(1000 * 60 * 60 * 6);
    // 设置主线程的睡眠工夫
    pool.setMaintSleep(30);
    // 设置连贯心跳监测开关
    // true:每次通讯都要进行连贯是否有效的监测，造成通讯次数陡增，加大网络负载，
    // 因而在对HighAvailability要求比较高的场所应当设为true
    // 默许状态是false，倡议维持默许。
    pool.setAliveCheck(false);
    // 设置连贯失败恢复开关
    // 设置为true，当宕机的服务器启动或中止的网络连贯后，这个socket连贯还可继续运用，否则将不再运用.
    // 默许状态是true，倡议维持默许。
    pool.setFailback(true);
    // 设置容错开关
    // true:当目前socket不可用时，程序会主动查找可用连贯并返回，否则返回NULL
    // 默许状态是true，倡议维持默许。
    pool.setFailover(true);
    // 设置hash算法
    // alg=0 运用String.hashCode()获得hash code,该要领依赖JDK，可能和其他客户端不兼容，倡议不运用
    // alg=1 运用original 兼容hash算法，兼容其他客户端
    // alg=2 运用CRC32兼容hash算法，兼容其他客户端，机能优于original算法
    // alg=3 运用MD5 hash算法
    // 采纳前三种hash算法的时候，查找cache服务器运用余数要领。采纳最后一种hash算法查找cache服务时运用consistent要领。
    // 默许值为0
    pool.setHashingAlg(0);
    // 设置是否运用Nagle算法，由于我们的通信数据量平常都比较大（相对TCP控制数据）而且要求相应及时，
    // 因而该值需要设置为false（默许是true）
    pool.setNagle(false);
    
    // 设置socket的读取期待超时值
    pool.setSocketTO(3000);
    
    // 设置socket的连贯期待超时值
    pool.setSocketConnectTO(0);
    // 初始化连贯池
    pool.initialize();
    // 紧缩设置，超过指定大小（单位为K）的数据都会被紧缩
    // mcc.setCompressEnable(true);  //UnsupportedOperation
    // mcc.setCompressThreshold(64 * 1024);
  }
  private MemCached() {
  }
  /**
   * 获取独一实例.
   * singleton
   * @return
   */
  public static MemCached getInstance() {
    return memCached;
  }
  /**
   * 增加一个指定的键值对到缓存中.
   * 
   * @param key
   * @param value
   * @return
   */
  public boolean add(String key, Object value) {
    return mcc.add(key, value);
  }
  /**
   * 增加一个指定的键值对到缓存中.
   * 
   * @param key
   * @param value
   * @param expiry 多久之后逾期
   * @return
   */
  public boolean add(String key, Object value, Date expiry) {
    return mcc.add(key, value, expiry);
  }
  
  
  public boolean set(String key, Object value) {
    return mcc.set(key, value);
  }
  public boolean set(String key, Object value, Date expiry) {
    return mcc.set(key, value, expiry);
  }
  public boolean replace(String key, Object value) {
    return mcc.replace(key, value);
  }
  public boolean replace(String key, Object value, Date expiry) {
    return mcc.replace(key, value, expiry);
  }
  
  
  /**
   * 依据指定的要害字获取对象.
   * 
   * @param key
   * @return
   */
  public Object get(String key) {
    return mcc.get(key);
  }
}
MemCached

public static void main(String[] args) {
    MemCached cache = MemCached.getInstance();
    boolean result1 = cache.add("hello", 1234, new Date(1000 * 2));// 设置2秒后逾期
    System.out.println("第一次add : " + result1);
    System.out.println("Value : " + cache.get("hello"));
    
    boolean result2 =cache.add("hello", 12345, new Date(1000 * 2));// add fail
    System.out.println("第二次add : " + result2);
    
    boolean result3 =cache.set("hello", 12345, new Date(1000 * 2));// set successes
    System.out.println("调用set : " + result3);
    
    System.out.println("Value : " + cache.get("hello"));

    try {
      Thread.sleep(1000 * 2);
      System.out.println("已经sleep2秒了....");
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("Value : " + cache.get("hello"));
  }

第一次add : true
Value : 1234
第二次add : false
调用set : true
Value : 12345
已经sleep2秒了....
Value : null

package memcached.test;
public class Person implements java.io.Serializable {
  private static final long serialVersionUID = 1L;

  private String name;

  public String getName() {
    return name;
  }

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

public static void main(String[] args) {
    MemCached cache = MemCached.getInstance();

    Person p1 = new Person();
    p1.setName("Jack");
    cache.add("bean", p1);
    
    Person p2 = (Person) cache.get("bean");
    System.out.println("name=" + p2.getName());//Jack
    p2.setName("Rose");
    
    // cache.replace("bean", p2);
    Person p3 = (Person) cache.get("bean");
    System.out.println("name=" + p3.getName());
  }