任何软件，首要条件就是可使用的，不能用的软件，哪怕就是设计再完美，算法再精妙，界面再绚丽，都只能成为反面教材被引以为戒。 其次就是软件的功能，性能。其中性能占着很大的比重。
高性能是用户体验的重要组成部分,而磁盘的互操作，线程等待，队列的效率影响着系统的性能。
什么是 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********************