memcached 的配置及 spymemcached 客户端简单使用

Memcached 是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。同时也可以用作不同系统之间的数据共享。应用比较广泛。下面介绍一下环境的memcached环境的搭建及简单实用

1. 1. 下载 libevent。官网下载 libevent
2. 2. 下载 memcached。官网下载 memcached
3. 3. 安装libevent，解压压缩包

      1:  ./configure –prefix=/usr/local/libevent

      2:  make

      3:  make install

4. 4.安装memcached。

5.    1:  ./configure-prefix=/usr/local/memcached-with-libevent –with-libevent=/usr/local/libevent

      2:  make

      3:  make install

   .csharpcode, .csharpcode pre
   {
   font-size: small;
   color: black;
   font-family: consolas, "Courier New", courier, monospace;
   background-color: #ffffff;
   /*white-space: pre;*/
   }
   .csharpcode pre { margin: 0em; }
   .csharpcode .rem { color: #008000; }
   .csharpcode .kwrd { color: #0000ff; }
   .csharpcode .str { color: #006080; }
   .csharpcode .op { color: #0000c0; }
   .csharpcode .preproc { color: #cc6633; }
   .csharpcode .asp { background-color: #ffff00; }
   .csharpcode .html { color: #800000; }
   .csharpcode .attr { color: #ff0000; }
   .csharpcode .alt
   {
   background-color: #f4f4f4;
   width: 100%;
   margin: 0em;
   }
   .csharpcode .lnum { color: #606060; }

6. 5. 运行

7.    1:  ./memcached -u root

   .csharpcode, .csharpcode pre
   {
   font-size: small;
   color: black;
   font-family: consolas, "Courier New", courier, monospace;
   background-color: #ffffff;
   /*white-space: pre;*/
   }
   .csharpcode pre { margin: 0em; }
   .csharpcode .rem { color: #008000; }
   .csharpcode .kwrd { color: #0000ff; }
   .csharpcode .str { color: #006080; }
   .csharpcode .op { color: #0000c0; }
   .csharpcode .preproc { color: #cc6633; }
   .csharpcode .asp { background-color: #ffff00; }
   .csharpcode .html { color: #800000; }
   .csharpcode .attr { color: #ff0000; }
   .csharpcode .alt
   {
   background-color: #f4f4f4;
   width: 100%;
   margin: 0em;
   }
   .csharpcode .lnum { color: #606060; }

8. 不出意外的话，服务器端的安装完毕了。
10. 简单的Java客户端Demo。使用的是spymemcached客户端

11. 最近上生产环境因为使用memcached差点导致宕机。由于spymemcached在发不通主机是会不断的请求连接。同时代码的写法有问题，每一次请求都新建了一个客户端。所以需要注意的是，SpyMemcachedManager 应该全局使用一个对象。减少开销。
12. /*
    * To change this template, choose Tools | Templates
    * and open the template in the editor.
    */
    package memcached;
    
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.SocketAddress;
    import java.util.Collection;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.Future;
    import java.util.concurrent.TimeUnit;
    import net.spy.memcached.AddrUtil;
    import net.spy.memcached.ConnectionObserver;
    import net.spy.memcached.MemcachedClient;
    import net.spy.memcached.transcoders.Transcoder;
    
    /**
    *
    * @author yingzi.zhu
    */
    public class SpyMemcachedManager {
    
        private List<String> servers;   // 192.168.159.129:11211
        private MemcachedClient memClient;
        public static int DEFAULT_TIMEOUT = 5;   
        public static TimeUnit DEFAULT_TIMEUNIT = TimeUnit.SECONDS;
       
        public SpyMemcachedManager(List<String> servers) {       
            this.servers = servers;       
        }   
       
        public void connect() throws IOException {       
            if (memClient != null) {           
                return;           
            }       
            StringBuffer buf = new StringBuffer();       
            for (int i = 0; i < servers.size(); i++) {           
                String server = servers.get(i);           
                buf.append(server).append(" ");           
            }       
            memClient = new MemcachedClient(AddrUtil.getAddresses(buf.toString()));       
        }   
       
        public void disConnect() {       
            if (memClient == null) {           
                return;           
            }       
            memClient.shutdown();       
        }   
       
        public void addObserver(ConnectionObserver obs) {       
            memClient.addObserver(obs);       
        }   
       
        public void removeObserver(ConnectionObserver obs) {       
            memClient.removeObserver(obs);       
        }
    
       
        public boolean set(String key, Object value, int expire) {       
            Future<Boolean> f = memClient.set(key, expire, value);       
            return getBooleanValue(f);       
        }   
       
        public Object get(String key) {       
            return memClient.get(key);       
        }   
       
        public Object asyncGet(String key) {       
            Object obj = null;       
            Future<Object> f = memClient.asyncGet(key);       
            try {           
                obj = f.get(SpyMemcachedManager.DEFAULT_TIMEOUT,
                        SpyMemcachedManager.DEFAULT_TIMEUNIT);           
            } catch (Exception e) {           
                f.cancel(false);           
            }       
            return obj;       
        }   
       
        public boolean add(String key, Object value, int expire) {       
            Future<Boolean> f = memClient.add(key, expire, value);       
            return getBooleanValue(f);       
        }   
       
        public boolean replace(String key, Object value, int expire) {       
            Future<Boolean> f = memClient.replace(key, expire, value);       
            return getBooleanValue(f);       
        }   
       
        public boolean delete(String key) {       
            Future<Boolean> f = memClient.delete(key);       
            return getBooleanValue(f);       
        }   
       
        public boolean flush() {       
            Future<Boolean> f = memClient.flush();       
            return getBooleanValue(f);       
        }   
       
        public Map<String, Object> getMulti(Collection<String> keys) {       
            return memClient.getBulk(keys);       
        }   
       
        public Map<String, Object> getMulti(String[] keys) {       
            return memClient.getBulk(keys);       
        }   
       
        public Map<String, Object> asyncGetMulti(Collection<String> keys) {       
            Map map = null;       
            Future<Map<String, Object>> f = memClient.asyncGetBulk(keys);       
            try {           
                map = f.get(SpyMemcachedManager.DEFAULT_TIMEOUT,
                        SpyMemcachedManager.DEFAULT_TIMEUNIT);           
            } catch (Exception e) {           
                f.cancel(false);           
            }       
            return map;       
        }   
       
        public Map<String, Object> asyncGetMulti(String keys[]) {       
            Map map = null;       
            Future<Map<String, Object>> f = memClient.asyncGetBulk(keys);       
            try {           
                map = f.get(SpyMemcachedManager.DEFAULT_TIMEOUT,
                        SpyMemcachedManager.DEFAULT_TIMEUNIT);           
            } catch (Exception e) {           
                f.cancel(false);           
            }       
            return map;       
        }
    
        public long increment(String key, int by, long defaultValue, int expire) {       
            return memClient.incr(key, by, defaultValue, expire);       
        }   
       
        public long increment(String key, int by) {       
            return memClient.incr(key, by);       
        }   
       
        public long decrement(String key, int by, long defaultValue, int expire) {       
            return memClient.decr(key, by, defaultValue, expire);       
        }   
       
        public long decrement(String key, int by) {       
            return memClient.decr(key, by);       
        }   
       
        public long asyncIncrement(String key, int by) {       
            Future<Long> f = memClient.asyncIncr(key, by);       
            return getLongValue(f);       
        }   
       
        public long asyncDecrement(String key, int by) {       
            Future<Long> f = memClient.asyncDecr(key, by);       
            return getLongValue(f);       
        }
       
        public void printStats() throws IOException {       
            printStats(null);       
        }   
       
        public void printStats(OutputStream stream) throws IOException {       
            Map<SocketAddress, Map<String, String>> statMap =
                    memClient.getStats();       
            if (stream == null) {           
                stream = System.out;           
            }       
            StringBuffer buf = new StringBuffer();       
            Set<SocketAddress> addrSet = statMap.keySet();       
            Iterator<SocketAddress> iter = addrSet.iterator();       
            while (iter.hasNext()) {           
                SocketAddress addr = iter.next();           
                buf.append(addr.toString() + "/n");           
                Map<String, String> stat = statMap.get(addr);           
                Set<String> keys = stat.keySet();           
                Iterator<String> keyIter = keys.iterator();           
                while (keyIter.hasNext()) {               
                    String key = keyIter.next();               
                    String value = stat.get(key);               
                    buf.append("  key=" + key + ";value=" + value + "/n");               
                }           
                buf.append("/n");           
            }       
            stream.write(buf.toString().getBytes());       
            stream.flush();       
        }   
       
        public Transcoder getTranscoder() {       
            return memClient.getTranscoder();       
        }   
       
        private long getLongValue(Future<Long> f) {       
            try {           
                Long l = f.get(SpyMemcachedManager.DEFAULT_TIMEOUT,
                        SpyMemcachedManager.DEFAULT_TIMEUNIT);           
                return l.longValue();           
            } catch (Exception e) {           
                f.cancel(false);           
            }       
            return -1;       
        }   
       
        private boolean getBooleanValue(Future<Boolean> f) {       
            try {           
                Boolean bool = f.get(SpyMemcachedManager.DEFAULT_TIMEOUT,
                        SpyMemcachedManager.DEFAULT_TIMEUNIT);           
                return bool.booleanValue();           
            } catch (Exception e) {           
                f.cancel(false);           
                return false;           
            }       
        }   
    }

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }