WEB-APP 高速缓存 Memcache 简单例子

  任何软件，首要条件就是可使用的，不能用的软件，哪怕就是设计再完美，算法再精妙，界面再绚丽，都只能成为反面教材被引以为戒。 其次就是软件的功能，性能。其中性能占着很大的比重。
  高性能是用户体验的重要组成部分,而磁盘的互操作，线程等待，队列的效率影响着系统的性能。
什么是 memcache ?
  memcache 是一种基于 C/S 架构的内存式缓存系统.

什么是 memcached ?
  Memcached 是memcache的运行服务端，核心文件，Memcached基于一个存储键/值对的hashmap，其守护进程（daemon ）是用C写的，但是客户端可以用任何语言来编写，并通过memcached协议与守护进程通信。

  对于web应用而言，高并发与高持续访问量时刻使用着CPU的资源，所以，Memcached基本只占用内存资源。能够很好弥补对于高频繁调用，却不经常变更的资源。
  这里介绍的是 服务端Windows操作系统memcached-1.2.4-Win32，客户端通过java代码.java_memcached-release_1.6的简单例子。
********************服务端 START********************
服务端很简单，只需要启动一下 守护进程即可。该进程会是依赖于操作系统，在后台以进程的形式存在的。
解压memcached-1.2.4-Win32.rar
    通过cmd命令行安装：


    通过cmd命令行运行：


    检测进程是否运行：


********************服务端 END********************

********************客户端 START********************
解压java_memcached-release_1.6.rar
将java_memcached-release_1.6.jar放到项目lib下。
这里我创建一个简单的工具类:

package test.memcached;

import java.util.Date;
import java.util.Map;

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

/**
 * 缓存类
 * @author 小G
 */
public class MemCachedCtl {
	protected static MemCachedClient mcc = new MemCachedClient();// 创建全局的唯一实例

	protected static MemCachedCtl memCached = new MemCachedCtl();
	
	//配置信息
	private static String[] servers = { "127.0.0.1:11211" };
	private static Integer[] weights = { 3 };
	private static int initialConnections  = 10;
	private static int minSpareConnections = 5;
	private static int maxSpareConnections = 50;   
	private static long maxIdleTime        = 1000 * 60 * 30;       
	private static long maxBusyTime        = 1000 * 60 * 5;        
	private static long maintThreadSleep   = 1000 * 5;                     
	private static int     socketTimeOut       = 1000 * 3;                 
	private static boolean nagleAlg        = false;                            
	
	/**
	 * 不允许通过构造方法创建实例
	 */
	protected MemCachedCtl() {
	
	}
	
	/**
	 * 获取唯一实例.
	 */
	public static MemCachedCtl getInstance() {
		return memCached;
	}
	
	/**
	 * 初始化基本信息
	 */
	public void init(){
		if(initConfig())
			initPool();
	}
	
	/**
	 * 初始化配置信息
	 */
	private boolean initConfig(){
		//TODO 初始化配置文件
		return true;
	}
	
	/**
	 * memcache服务器初始化连接池
	 */
	private void initPool(){
		SockIOPool pool = SockIOPool.getInstance();// 获取socke连接池的实例对象
		pool.setServers(servers);// 设置服务器信息
		pool.setWeights(weights);//设置权重
		
		pool.setInitConn( initialConnections );// 设置初始连接数
        pool.setMinConn( minSpareConnections );//设置最小连接数
        pool.setMaxConn( maxSpareConnections );//设置最大连接数
        pool.setMaxIdle( maxIdleTime );//设置最大处理时间
        pool.setMaxBusyTime( maxBusyTime );
        pool.setMaintSleep( maintThreadSleep );// 设置主线程的等待时间
        pool.setSocketTO( socketTimeOut ); //设置连接超时时间
        pool.setNagle( nagleAlg );      
        pool.setHashingAlg( SockIOPool.NEW_COMPAT_HASH );
        pool.setAliveCheck( true );
        pool.initialize();      
	}

	/**
	 * 判断key是否存在
	 */
	public boolean keyExists(String key){
		return mcc.keyExists(key);
	}
	
	/**
	 * 缓存一个对象
	 */
	public synchronized boolean add(String key, Object value) {
		return mcc.add(key, value);
	}
	
	/**
	 * 缓存一个对象(日期)
	 */
	public synchronized boolean add(String key, Object value, Date expiry) {
		return mcc.add(key, value, expiry);
	}
	
	/**
	 * 缓存一个对象(hashCode码) 
	 */
	public synchronized boolean add(String key,Object value,Integer hashCode){
		return mcc.add(key, value, hashCode);
	}
	
	/**
	 * 缓存一个对象
	 */
	public synchronized boolean set(String key, Object value) {
		return mcc.set(key, value);
	}
	
	/**
	 * 缓存一个对象(日期)
	 */
	public synchronized boolean set(String key, Object value, Date expiry) {
		return mcc.set(key, value, expiry);
	}
	
	/**
	 * 缓存一个对象(hashCode码) 
	 */
	public synchronized boolean set(String key,Object value,Integer hashCode){
		return mcc.set(key, value, hashCode);
	}
	
	/**
	 * 删除一个缓存对象
	 */
	public synchronized boolean delete(String key) {
		return mcc.delete(key);
	}
	
	/**
	 * 删除一个缓存对象(日期)
	 */
	public synchronized boolean delete(String key, Object value, Date expiry) {
		return mcc.delete(key, expiry);
	}
	
	/**
	 * 删除一个缓存对象(hashCode码) 
	 */
	public synchronized boolean delete(String key,Integer hashCode,Date expiry){
		return mcc.delete(key, hashCode, expiry);
	}
	
	/**
	 * 删除全部服务器上的缓存对象
	 */
	public synchronized boolean flushAll() {
		return mcc.flushAll();
	}
	
	/**
	 * 删除指定服务器上的缓存对象
	 */
	public synchronized boolean flushAll(String[] servers) {
		return mcc.flushAll(servers);
	}
	
	/**
	 * 替换原有的缓存(更新缓存)
	 */
	public synchronized boolean replace(String key, Object value) {
		return mcc.replace(key, value);
	}
	
	/**
	 * 替换原有的缓存(更新缓存)
	 */
	public synchronized boolean replace(String key, Object value, Date expiry) {
		return mcc.replace(key, value, expiry);
	}
	
	/**
	 * 替换原有的缓存(更新缓存)
	 */
	public synchronized boolean replace(String key, Object value, Integer hashCode) {
		return mcc.replace(key, value, hashCode);
	}
	
	/**
	 * 替换原有的缓存(更新缓存)
	 */
	public synchronized boolean replace(String key, Object value,Date expiry, Integer hashCode){
		return mcc.replace(key, value, expiry, hashCode);
	}
	
	/**
	 * 返回全部服务器状态
	 */
	public Map stats(){
		return mcc.stats();
	}
	
	/**
	 * 返回指定服务器状态
	 */
	public Map stats(String[] servers){
		return mcc.stats(servers);
	}
	
	/**
	 * 根据指定KEY获得缓存
	 */
	public Object get(String key) {
		return mcc.get(key);
	}
	
	/**
	 * 根据指定KEY,HASHCODE获得缓存
	 */
	public Object get(String key,Integer hashCode) {
		return mcc.get(key,hashCode);
	}
	
	/**
	 * 根据指定KEY,HASHCODE,状态值 获得缓存
	 */
	public Object get(String key,Integer hashCode,boolean asString) {
		return mcc.get(key,hashCode,asString);
	}
	
	
	/**
	 * 测试方法
	 */
	public static void main(String[] args) {
		MemCachedCtl cache = MemCachedCtl.getInstance();
		cache.init();
//		cache.add("helloworld_key", "helloworld_value");
		cache.set("helloworld_key", "helloworld_value");
		System.out.print("返回结果: " + cache.get("helloworld_key"));
	}
	
}

在java_memcached-release_1.6文件夹内，crc目录下有源码和测试类可供学习。
********************客户端 END********************