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

jingjihui

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

• 1. 下载 libevent。官网下载 libevent
  
• 2. 下载 memcached。官网下载 memcached
  
• 3. 安装libevent，解压压缩包  
     1:  ./configure –prefix=/usr/local/libevent   2:  make   3:  make install
  
• 
  
  4.安装memcached。
  
• 
  
  
  
     1:  ./configure-prefix=/usr/local/memcached-with-libevent –with-libevent=/usr/local/libevent   2:  make   3:  make install
  
• 
  
  5. 运行
  
• 
  
     1:  ./memcached -u root
  
• 不出意外的话，服务器端的安装完毕了。
  
• 
  
• 简单的Java客户端Demo。使用的是spymemcached客户端
  
• 最近上生产环境因为使用memcached差点导致宕机。由于spymemcached在发不通主机是会不断的请求连接。同时代码的写法有问题，每一次请求都新建了一个客户端。所以需要注意的是，SpyMemcachedManager 应该全局使用一个对象。减少开销。
  
• /*
  * 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;            
          }        
      }   
  }