高性能分布式对象缓存系统MemCached

1简介

MemCached是高性能分布式的内存对象缓存系统，用于在动态应用中减少数据库负载，提升访问速度。MemCached由Danga Interactive开发，用于提升LiveJournal.com访问速度的。MemCached将数据库负载大幅度降低，更好的分配资源，更快速访问。

 

MemCached的最新版是采用c语言进行开发和设计的，是作为缓存服务器的服务器端运行在服务器上的，需要使用特定的语言编写客户端与其进行通信来进行数据的缓存和获取。通常我们是把MemCached安装运行在web服务器上，然后通过对需要的数据进行缓存，数据的缓存设置和存取操作需要程序来进行。

2安装

2.1下载

http://danga.com/MemCached/下载MemCached的windows版本和java客户端jar包：MemCached和java_MemCached。

2.2安装

首先是安装运行MemCached服务器，我们将MemCached解压后，进入其目录，然后安装MemCached成为服务：

c:>MemCached.exe -d install

 

运行如下命令启动MemCached：

c:>MemCached.exe -l 127.0.0.1 -m 32 -d start

作为测试我们就分配32M内存(-memory)，然后监听本机端口(-listen)和以守护进程(-daemon)运行。执行完毕后，我们就可以在任务管理器中见到MemCached.exe这个进程了。

3客户端

下面我们来写java的客户端连接程序。

我们将java_MemCached解压后的目录中的java_MemCached.jar文件复制到java项目的lib目录下，然后我们来编写代码，比如我提供的一个应用类如下：

package utils.cache;

 

import java.util.Date;

import com.danga.MemCached.MemCachedClient;

import com.danga.MemCached.SockIOPool;

 

public class MemCachedMy

{

protected static MemCachedClient mcc = new MemCachedClient();

// 创建全局的唯一实例

protected static MemCachedMy cachemy = new MemCachedMy();

 

// 设置与缓存服务器的连接池

static {

// 服务器列表和其权重

String[] servers = {"127.0.0.1:11211"};

Integer[] weights = {3};

 

// 获取socke连接池的实例对象

SockIOPool pool = SockIOPool.getInstance();

 

// 设置服务器信息

pool.setServers( servers );

pool.setWeights( weights );

 

// 设置初始连接数、最小和最大连接数以及最大处理时间

pool.setInitConn( 5 );

pool.setMinConn( 5 );

pool.setMaxConn( 250 );

pool.setMaxIdle( 1000 * 60 * 60 * 6 );

 

// 设置主线程的睡眠时间

pool.setMaintSleep( 30 );

 

// 设置TCP的参数，连接超时等

pool.setNagle( false );

pool.setSocketTO( 3000 );

pool.setSocketConnectTO( 0 );

 

// 初始化连接池

pool.initialize();

 

// 压缩设置，超过指定大小（单位为K）的数据都会被压缩

mcc.setCompressEnable( true );

mcc.setCompressThreshold( 64 * 1024 );

}

 

protected MemCachedMy() { }// 构造器

public static MemCachedMy getInstance() // 单例模式

{

return cachemy;

}

 

/**

 * 添加一个指定的值到缓存中.

 * @param key

 * @param value

 */

public boolean add(String key, Object value)

{

return mcc.add(key, value);

}

 

public boolean add(String key, Object value, Date expiry)

{

return mcc.add(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 Object

 */

public Object get(String key)

{

return mcc.get(key);

}

 

public static void main(String[] args)

{

MemCached cache = MemCached.getInstance();

cache.add("hello", 123);

System.out.print("get value : " + cache.get("hello"));

}

}

 

那么我们就可以通过简单的像main方法中操作的一样存入一个变量，然后再取出进行查看，我们可以看到先调用了add，然后再进行get，我们运行一次后，123这个值已经被我们存入了MemCached的缓存中的了，我们将main方法中蓝色的那一行注释掉后，我们再运行还是可以看到get到的value也是123，即缓存中我们已经存在了数据了。

 

对基本的数据我们可以操作，对于普通的POJO而言，如果要进行存储的话，那么比如让其实现java.io.Serializable接口，因为MemCached是一个分布式的缓存服务器，多台服务器间进行数据共享需要将对象序列化的，所以必须实现该接口，否则会报错的。比如我们写一个简单的测试Bean如下：

 

class TDOBean implements java.io.Serializable

{

private String name;

 

public String getName()

{

return name;

}

 

public void setName(String name)

{

this.name = name;

}

}

 

然后我们在main方法中加入如下几行代码：

TDOBean tb = new TDOBean();

tb.setName("猪八戒");

cache.add("abean", tb);

 

TDOBean tb1 = (TDOBean )cache.get("abean");

System.out.print("name=" + tb1.getName());

 

tb1.setName("孙悟空");

tb1 = (TDOBean )cache.get("abean");

System.out.print("name=" + tb1.getName());

 

我们首先把TDOBean 的一个实例放入缓存中，然后再取出来，并进行名称的修改，然后我们再取这个对象，我们再看其名称，发现修改的对象并不是缓存中的对象，而是通过序列化过来的一个实例对象，这样我们就无须担心对原生类的无意修改导致缓存数据失效了。