package memcached.test;
import java.util.Date;
import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
/**
 * 使用memcached的緩存實用類.
 */
public class MemCached {
  // 創(chuàng)建全局的唯一實例
  protected static MemCachedClient mcc = new MemCachedClient();
  protected static MemCached memCached = new MemCached();
  // 設(shè)置與緩存服務(wù)器的連接池
  static {
    // 服務(wù)器列表和其權(quán)重
    String[] servers = { "127.0.0.1:11211" };
    Integer[] weights = { 3 };
    // 獲取socke連接池的實例對象
    // 這個類用來創(chuàng)建管理客戶端和服務(wù)器通訊連接池，
    // 客戶端主要的工作（包括數(shù)據(jù)通訊、服務(wù)器定位、hash碼生成等）都是由這個類完成的。
    SockIOPool pool = SockIOPool.getInstance();
    // 設(shè)置服務(wù)器信息
    pool.setServers(servers);
    
    // 設(shè)置Server權(quán)重
    pool.setWeights(weights);
    // 設(shè)置初始連接數(shù)、最小和最大連接數(shù)以及最大處理時間
    pool.setInitConn(5);
    pool.setMinConn(5);
    pool.setMaxConn(250);
    pool.setMaxIdle(1000 * 60 * 60 * 6);
    // 設(shè)置主線程的睡眠時間
    pool.setMaintSleep(30);
    // 設(shè)置連接心跳監(jiān)測開關(guān)
    // true:每次通信都要進行連接是否有效的監(jiān)測，造成通信次數(shù)倍增，加大網(wǎng)絡(luò)負(fù)載，
    // 因此在對HighAvailability要求比較高的場合應(yīng)該設(shè)為true
    // 默認(rèn)狀態(tài)是false，建議保持默認(rèn)。
    pool.setAliveCheck(false);
    // 設(shè)置連接失敗恢復(fù)開關(guān)
    // 設(shè)置為true，當(dāng)宕機的服務(wù)器啟動或中斷的網(wǎng)絡(luò)連接后，這個socket連接還可繼續(xù)使用，否則將不再使用.
    // 默認(rèn)狀態(tài)是true，建議保持默認(rèn)。
    pool.setFailback(true);
    // 設(shè)置容錯開關(guān)
    // true:當(dāng)當(dāng)前socket不可用時，程序會自動查找可用連接并返回，否則返回NULL
    // 默認(rèn)狀態(tài)是true，建議保持默認(rèn)。
    pool.setFailover(true);
    // 設(shè)置hash算法
    // alg=0 使用String.hashCode()獲得hash code,該方法依賴JDK，可能和其他客戶端不兼容，建議不使用
    // alg=1 使用original 兼容hash算法，兼容其他客戶端
    // alg=2 使用CRC32兼容hash算法，兼容其他客戶端，性能優(yōu)于original算法
    // alg=3 使用MD5 hash算法
    // 采用前三種hash算法的時候，查找cache服務(wù)器使用余數(shù)方法。采用最后一種hash算法查找cache服務(wù)時使用consistent方法。
    // 默認(rèn)值為0
    pool.setHashingAlg(0);
    // 設(shè)置是否使用Nagle算法，因為我們的通訊數(shù)據(jù)量通常都比較大（相對TCP控制數(shù)據(jù)）而且要求響應(yīng)及時，
    // 因此該值需要設(shè)置為false（默認(rèn)是true）
    pool.setNagle(false);
    
    // 設(shè)置socket的讀取等待超時值
    pool.setSocketTO(3000);
    
    // 設(shè)置socket的連接等待超時值
    pool.setSocketConnectTO(0);
    // 初始化連接池
    pool.initialize();
    // 壓縮設(shè)置，超過指定大小（單位為K）的數(shù)據(jù)都會被壓縮
    // 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);
  }
  
  
  /**
   * 根據(jù)指定的關(guān)鍵字獲取對象.
   * 
   * @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));// 設(shè)置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("調(diào)用set : " + result3);
    
    System.out.println("Value : " + cache.get("hello"));

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

第一次add : true
Value : 1234
第二次add : false
調(diào)用set : true
Value : 12345
已經(jīng)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());
  }