Memcached 的Java应用

往memcached中插入数据，以及读取数据 

 

 

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. }  

 那么我们就可以通过简单的像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. }  

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

 

注意：memcached是以Key -Value 的方式进行数据存储的，Key的大小限制:key(max) <= 250个字符。 
       value 在存储是有限制：value(max) <= 1M ; 
   memcached默认过期时间：ExpiresTime(max)= 30(days).

 

 

通过Spring注入使用memcached 
Spring注入配置： 

<bean id="memcachedPool" class= "com.danga.MemCached.SockIOPool" factory-method="getInstance" 
      init-method="initialize" destory-method="shutDowm"> 
    <constructor-arg> 
        <value>neeaMemcachedPool</value>     
    </constructor-arg> 
    <property name="servers"> 
        <list> 
            <value>192.168.1.233:11211</value> 
        </list> 
    </property> 
    <property name="initConn"> 
        <value>20</value> 
    </property> 
    <property name="minConn"> 
        <value>10</value> 
    </property> 
    <property name="maxConn"> 
        <value>50</value> 
    </property> 
    <property name="mainSleep"> 
        <value>30</value> 
    </property> 
	<property name="nagle"> 
        <value>false</value> 
    </property> 
    <property name="socketTO"> 
        <value>3000</value> 
    </property> 
</bean> 
<bean id="memcachedClient" class="com.danga.MemCached.MemCachedClient"> 
    <constructor-arg> 
        <value>neeaMemcachedPool</value> 
    </constructor-arg> 
    <property name="compressEnable"> 
        <value>true</value> 
    </property> 
    <property name="compressThreshold"> 
        <value>4096</value> 
    </property> 
</bean>