最近一直在做一个项目的前期设计工作，考虑到后期系统的扩展和性能问题也找了很多解决方法，有一个就是用到了数据库的缓存工具memcached（当然该工具并不仅仅局限于数据库的缓存）。先简单的介绍下什么是memcached。

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

    上网baidu了很多东西，几乎都差不多，而且基于java的说的很少，所有只有在研究了各个其他语言类的应用后再来尝试在java上进行简单的操作应 用。先从memcached上进行说明，memcached的最新版是采用c语言进行开发和设计的，据说旧版的是采用perl语言开发的，而且它是一个应 用软件来的，是作为缓存服务器的服务器端运行在服务器上的，需要使用特定的语言编写客户端与其进行通信来进行数据的缓存和获取。通常我们是把 memcached安装运行在web服务器上，然后通过对需要的数据进行缓存，据我目前所知，所有数据的缓存设置和存取操作，以及数据的更新后替换操作全 部需要程序来进行，而不是自动进行的（自动不知道能不能成功，呵呵）。下面从一个实际的例子来应用memcached。

    首先到http://danga.com/memcached/ 下 载memcached的windows版本和java客户端jar包，目前最新版本是memcached-1.2.1-win32.zip和 java_memcached-release_1.6.zip，分别解压后即可！首先是安装运行memcached服务器，我们将memcached- 1.2.1-win32.zip解压后，进入其目录，然后运行如下命令：

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

    第一行是安装memcached成为服务，这样才能正常运行，否则运行失败！第一行是启动memcached的，作为测试我们就简单的只分配32M内存 了，然后监听本机端口和以守护进行运行。执行完毕后，我们就可以在任务管理器中见到memcached.exe这个进程了。好了，我们的服务器已经正常运 行了， 下面我们就来写java的客户端连接程序。

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

Java代码  收藏代码
  1. package utils.cache;  
  2.   
  3. import java.util.Date;  
  4.   
  5. import com.danga.MemCached.MemCachedClient;  
  6. import com.danga.MemCached.SockIOPool;  
  7.   
  8.   
  9. /** 
  10. * 使用memcached的缓存实用类. 
  11. * 
  12. * @author 铁木箱子 
  13. * 
  14. */  
  15. public class MemCached  
  16. {  
  17.     // 创建全局的唯一实例  
  18.     protected static MemCachedClient mcc = new MemCachedClient();  
  19.      
  20.     protected static MemCached memCached = new MemCached();  
  21.      
  22.     // 设置与缓存服务器的连接池  
  23.     static {  
  24.         // 服务器列表和其权重  
  25.         String[] servers = {"127.0.0.1:11211"};  
  26.         Integer[] weights = {3};  
  27.   
  28.         // 获取socke连接池的实例对象  
  29.         SockIOPool pool = SockIOPool.getInstance();  
  30.   
  31.         // 设置服务器信息  
  32.         pool.setServers( servers );  
  33.         pool.setWeights( weights );  
  34.   
  35.         // 设置初始连接数、最小和最大连接数以及最大处理时间  
  36.         pool.setInitConn( 5 );  
  37.         pool.setMinConn( 5 );  
  38.         pool.setMaxConn( 250 );  
  39.         pool.setMaxIdle( 1000 * 60 * 60 * 6 );  
  40.   
  41.         // 设置主线程的睡眠时间  
  42.         pool.setMaintSleep( 30 );  
  43.   
  44.         // 设置TCP的参数，连接超时等  
  45.         pool.setNagle( false );  
  46.         pool.setSocketTO( 3000 );  
  47.         pool.setSocketConnectTO( 0 );  
  48.   
  49.         // 初始化连接池  
  50.         pool.initialize();  
  51.   
  52.         // 压缩设置，超过指定大小（单位为K）的数据都会被压缩  
  53.         mcc.setCompressEnable( true );  
  54.         mcc.setCompressThreshold( 64 * 1024 );  
  55.     }  
  56.      
  57.     /** 
  58.      * 保护型构造方法，不允许实例化！ 
  59.      * 
  60.      */  
  61.     protected MemCached()  
  62.     {  
  63.          
  64.     }  
  65.      
  66.     /** 
  67.      * 获取唯一实例. 
  68.      * @return 
  69.      */  
  70.     public static MemCached getInstance()  
  71.     {  
  72.         return memCached;  
  73.     }  
  74.      
  75.     /** 
  76.      * 添加一个指定的值到缓存中. 
  77.      * @param key 
  78.      * @param value 
  79.      * @return 
  80.      */  
  81.     public boolean add(String key, Object value)  
  82.     {  
  83.         return mcc.add(key, value);  
  84.     }  
  85.      
  86.     public boolean add(String key, Object value, Date expiry)  
  87.     {  
  88.         return mcc.add(key, value, expiry);  
  89.     }  
  90.      
  91.     public boolean replace(String key, Object value)  
  92.     {  
  93.         return mcc.replace(key, value);  
  94.     }  
  95.      
  96.     public boolean replace(String key, Object value, Date expiry)  
  97.     {  
  98.         return mcc.replace(key, value, expiry);  
  99.     }  
  100.      
  101.     /** 
  102.      * 根据指定的关键字获取对象. 
  103.      * @param key 
  104.      * @return 
  105.      */  
  106.     public Object get(String key)  
  107.     {  
  108.         return mcc.get(key);  
  109.     }  
  110.      
  111.     public static void main(String[] args)  
  112.     {  
  113.         MemCached cache = MemCached.getInstance();  
  114.         cache.add("hello", 234);  
  115.         System.out.print("get value : " + cache.get("hello"));  
  116.     }  
  117. }  
package utils.cache;

import java.util.Date;

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


/**
* 使用memcached的缓存实用类.
*
* @author 铁木箱子
*
*/
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连接池的实例对象
        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 MemCached()
    {
       
    }
   
    /**
     * 获取唯一实例.
     * @return
     */
    public static MemCached getInstance()
    {
        return memCached;
    }
   
    /**
     * 添加一个指定的值到缓存中.
     * @param key
     * @param value
     * @return
     */
    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
     */
    public Object get(String key)
    {
        return mcc.get(key);
    }
   
    public static void main(String[] args)
    {
        MemCached cache = MemCached.getInstance();
        cache.add("hello", 234);
        System.out.print("get value : " + cache.get("hello"));
    }
}

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

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

Java代码  收藏代码
  1. class TBean implements java.io.Serializable  
  2. {  
  3.     private static final long serialVersionUID = 1945562032261336919L;  
  4.      
  5.     private String name;  
  6.   
  7.     public String getName()  
  8.     {  
  9.         return name;  
  10.     }  
  11.   
  12.     public void setName(String name)  
  13.     {  
  14.         this.name = name;  
  15.     }  
  16. }  
class TBean implements java.io.Serializable
{
    private static final long serialVersionUID = 1945562032261336919L;
   
    private String name;

    public String getName()
    {
        return name;
    }

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

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

Java代码  收藏代码
  1. TBean tb = new TBean();  
  2. tb.setName("铁木箱子");  
  3. cache.add("bean", tb);  
  4. TBean tb1 = (TBean)cache.get("bean");  
  5. System.out.print("name=" + tb1.getName());  
  6. tb1.setName("铁木箱子_修改的");  
  7. tb1 = (TBean)cache.get("bean");  
  8. System.out.print("name=" + tb1.getName());  
TBean tb = new TBean();
tb.setName("铁木箱子");
cache.add("bean", tb);
TBean tb1 = (TBean)cache.get("bean");
System.out.print("name=" + tb1.getName());
tb1.setName("铁木箱子_修改的");
tb1 = (TBean)cache.get("bean");
System.out.print("name=" + tb1.getName());

 我们首先把TBean的一个实例放入缓存中，然后再取出来，并进行名称的 修改，然后我们再取这个对象，我们再看其名称，发现修改的对象并不是缓存中的对象，而是通过序列化过来的一个实例对象，这样我们就无须担心对原生类的无意 修改导致缓存数据失效了，呵呵~~看来我也是多此一想啊。所以这表明从缓存中获取的对象是存入对象的一个副本，对获取对象的修改并不能真正的修改缓存中的 数据，而应该使用其提供的replace等方法来进行修改 。

    以上是我在windows下对memcached的一点小学习和实践，在以后的项目开发过程中将会更深入的学习和应用这一缓存工具，也希望和有兴趣的同行一起讨论学习该工具的使用~~

[转自 :http://q.sohu.com/forum/5/topic/640252 ]