java中一个memcached案例

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

         下面来一个高度封装的memcached工具类；如下：

package com.hoodong.framework.cache;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
import com.hoodong.framework.util.FrameProperties;

public class MemCached {
    private static Map cachePool = new ConcurrentHashMap();

    /**
     * 取得指定memcached.
     * @param cacheName
     * @return
     */
    public static MemCachedClient getCache(String cacheName) {
        if (cacheName == null && "".equals(cacheName.trim())) {
            return null;
        }
        if (cachePool.get(cacheName) == null
                || !(cachePool.containsKey(cacheName))) {
                String fileName=cacheName+".xml";
                MemCachedClient cacheClient = initMemecached(fileName);
                if (cacheClient == null) {
                    return null;
                } else {
                    cachePool.put(cacheName, cacheClient);
                    return cacheClient;
                }
        }
        return (MemCachedClient) cachePool.get(cacheName);
    }
    
    //     设置与缓存服务器的连接池
    private static MemCachedClient initMemecached(String filename) {
        String poolName = FrameProperties.getProperties(filename, "poolName");
        // 得到一个实例对象SockIOPool
        SockIOPool pool = SockIOPool.getInstance(poolName);
        //先判断pool是否已经被初始化
        if(!pool.isInitialized()){
            String serverList = FrameProperties.getProperties(filename, "serverList");
            String weightList = FrameProperties.getProperties(filename, "weightList");
            String minConn = FrameProperties.getProperties(filename, "minConn");
            String initConn = FrameProperties.getProperties(filename, "initConn");
            String maxConn = FrameProperties.getProperties(filename, "maxConn");
            String maxIdle = FrameProperties.getProperties(filename, "maxIdle");
            String maintSleep = FrameProperties.getProperties(filename, "maintSleep");
            String socketTO = FrameProperties.getProperties(filename, "socketTO");
            String socketConnectTO = FrameProperties.getProperties(filename, "socketConnectTO");
            String aliveCheck = FrameProperties.getProperties(filename, "aliveCheck");
            String nagle = FrameProperties.getProperties(filename, "nagle");
            String failover = FrameProperties.getProperties(filename, "failover");
            String failback = FrameProperties.getProperties(filename, "failback");
            String[] serversStr = serverList.split(",");
            String[] servers = new String[serversStr.length];
            for (int i = 0; i < servers.length; i++) {
                servers[i] = serversStr[i];
            }

            String[] weightsStr = weightList.split(",");
            Integer[] weights = new Integer[weightsStr.length];
            for (int i = 0; i < weights.length; i++) {
                weights[i] = new Integer(weightsStr[i]);
            }
            // set the servers and the weights
            // 设置Memcached Server
            pool.setServers(servers);
            pool.setWeights(weights);
    
            // set some basic pool settings
            // 5 initial, 5 min, and 250 max conns
            // and set the max idle time for a conn
            // to 6 hours
            pool.setInitConn(Integer.parseInt(initConn));
            pool.setMinConn(Integer.parseInt(minConn));
            pool.setMaxConn(Integer.parseInt(maxConn));
            pool.setMaxIdle(Long.parseLong(maxIdle));

            // set the sleep for the maint thread
            // it will wake up every x seconds and
            // maintain the pool size
            pool.setMaintSleep(Long.parseLong(maintSleep));
    
            // Tcp的规则就是在发送一个包之前，本地机器会等待远程主机
            // 对上一次发送的包的确认信息到来；这个方法就可以关闭套接字的缓存，
            // 以至这个包准备好了就发；
            pool.setNagle(Boolean.parseBoolean(nagle));
            // 连接建立后对超时的控制
            pool.setSocketTO(Integer.parseInt(socketTO));
            // 连接建立时对超时的控制
            pool.setSocketConnectTO(Integer.parseInt(socketConnectTO));
            pool.setAliveCheck(Boolean.parseBoolean(aliveCheck));
            pool.setFailover(Boolean.parseBoolean(failover));
            pool.setFailback(Boolean.parseBoolean(failback));
            pool.setHashingAlg(SockIOPool.NEW_COMPAT_HASH);
            // initialize the connection pool
            // 初始化一些值并与MemcachedServer段建立连接
    
            // 初始化连接池
            pool.initialize();
        }
        // 压缩设置，超过指定大小（单位为K）的数据都会被压缩
        MemCachedClient mcc = new MemCachedClient(poolName);
        String primitiveAsString = FrameProperties.getProperties(filename, "primitiveAsString");
        String compressEnable = FrameProperties.getProperties(filename, "compressEnable");
        mcc.setCompressEnable(Boolean.parseBoolean(compressEnable));
        //mcc.setCompressThreshold(64 * 1024);//默认15k
        mcc.setPrimitiveAsString(Boolean.parseBoolean(primitiveAsString));
        mcc.setSanitizeKeys(false);
        return mcc;
    }
    /**
     * 销毁缓存
     */
    protected void finalize() throws Throwable {

        cachePool.clear();
        cachePool=null;
        super.finalize();    
    }
    
    public static void main(String a[])
    {
        MemCachedClient m= MemCached.getCache("mclient0");
        m.set("a", 1);
        m.set("b", 2);
        m.set("c", 3);
        System.out.println(m.get("a"));
        System.out.println(m.get("b"));
        System.out.println(m.get("c"));
    }
}

转载请指明出处：http://blog.csdn.net/yangkai_hudong

java中一个memcached案例,古老的榕树,5-wow.com