memcache测试代码及使用

用MemCachedClient的set(K,V)就没问题了，原来用的add(K,V)才有刚才提到的问题，

因为memcached的文档不全，所以我也不知道到底是为什么。看add(K,V)和set(K,V)的区别只知道是通过socket发给memcached服务器端的command不同，

一个是"add"，一个是"set"。

 

public static void main(String[] args)

{

    String[] serverlist = { "localhost:11211" };
    SockIOPool pool = SockIOPool.getInstance();
    pool.setServers(serverlist);

    pool.initialize();

    MemCachedClient client = new MemCachedClient();
    client.set("ramalama", "dingdong"); 

    String foo = (String) client.get("ramalama");
    System.out.println(foo);

}

==============================================================

 

/**
 * @author Marc
 * 具体工具类的代码
 */
public class CacheService {
 private Log logger = LogFactory.getLog(getClass());

 private Cache localCache;

 String cacheServerList;

 String cacheServerWeights;

 boolean cacheCluster = false;

 int initialConnections = 10;

 int minSpareConnections = 5;

 int maxSpareConnections = 50;

 long maxIdleTime = 1000 * 60 * 30; // 30 minutes

 long maxBusyTime = 1000 * 60 * 5; // 5 minutes

 long maintThreadSleep = 1000 * 5; // 5 seconds

 int socketTimeOut = 1000 * 3; // 3 seconds to block on reads

 int socketConnectTO = 1000 * 3; // 3 seconds to block on initial
         // connections. If 0, then will use blocking
         // connect (default)

 boolean failover = false; // turn off auto-failover in event of server
        // down

 boolean nagleAlg = false; // turn off Nagle's algorithm on all sockets in
        // pool

 MemCachedClient mc;

 public CacheService(){
  mc = new MemCachedClient();
  mc.setCompressEnable(false);
 }
 /**
  * 放入
  *
  */
 public void put(String key, Object obj) {
  Assert.hasText(key);
  Assert.notNull(obj);
  Assert.notNull(localCache);
  if (this.cacheCluster) {
   mc.set(key, obj);
  } else {
   Element element = new Element(key, (Serializable) obj);
   localCache.put(element);
  }
 }
 /**
  * 删除
  */
 public void remove(String key){
  Assert.hasText(key);
  Assert.notNull(localCache);
  if (this.cacheCluster) {
   mc.delete(key);
  }else{
   localCache.remove(key);
  }
 }
 /**
  * 得到
  */
 public Object get(String key) {
  Assert.hasText(key);
  Assert.notNull(localCache);
  Object rt = null;
  if (this.cacheCluster) {
   rt = mc.get(key);
  } else {
   Element element = null;
   try {
             element = localCache.get(key);
         } catch (CacheException cacheException) {
             throw new DataRetrievalFailureException("Cache failure: "
                     + cacheException.getMessage());
         }
   if(element != null)
    rt = element.getValue();
  }
  return rt;
 }
 /**
  * 判断是否存在
  *
  */
 public boolean exist(String key){
  Assert.hasText(key);
  Assert.notNull(localCache);
  if (this.cacheCluster) {
   return mc.keyExists(key);
  }else{
   return this.localCache.isKeyInCache(key);
  }
 }
 private void init() {
  if (this.cacheCluster) {
   String[] serverlist = cacheServerList.split(",");
   Integer[] weights = this.split(cacheServerWeights);
   // initialize the pool for memcache servers
   SockIOPool pool = SockIOPool.getInstance();
   pool.setServers(serverlist);
   pool.setWeights(weights);
   pool.setInitConn(initialConnections);
   pool.setMinConn(minSpareConnections);
   pool.setMaxConn(maxSpareConnections);
   pool.setMaxIdle(maxIdleTime);
   pool.setMaxBusyTime(maxBusyTime);
   pool.setMaintSleep(maintThreadSleep);
   pool.setSocketTO(socketTimeOut);
   pool.setSocketConnectTO(socketConnectTO);
   pool.setNagle(nagleAlg);
   pool.setHashingAlg(SockIOPool.NEW_COMPAT_HASH);
   pool.initialize();
   logger.info("初始化memcached pool!");
  }
 }

 private void destory() {
  if (this.cacheCluster) {
   SockIOPool.getInstance().shutDown();
  }
 }
}

 

//实现函数的AOP拦截类，用来在函数执行前返回缓存内容

public class CachingInterceptor implements MethodInterceptor {

    private CacheService cacheService;
    private String cacheKey;

    public void setCacheKey(String cacheKey) {
        this.cacheKey = cacheKey;
    }

    public void setCacheService(CacheService cacheService) {
        this.cacheService = cacheService;
    }

    public Object invoke(MethodInvocation invocation) throws Throwable {
        Object result = cacheService.get(cacheKey);
        //如果函数返回结果不在Cache中,执行函数并将结果放入Cache
        if (result == null) {
            result = invocation.proceed();
            cacheService.put(cacheKey,result);
        }
        return result;
    }
}

 

 

//实现hibernate的cache provider，让hibernate使用memcached缓存。
这里比较简单，由于memcached的SockIOPool已经在（一）中spring中初始化了，这里就不考虑pool的初始化，直接获得MemCachedClient使用即可

/**
 * @author Marc
 *
 */
public class MemcachedProvider implements CacheProvider {
 public Cache buildCache(String name, Properties properties) throws CacheException {
  return new MemCache(name);
 }

 public boolean isMinimalPutsEnabledByDefault() {
  return false;
 }

 public long nextTimestamp() {
  return Timestamper.next();
 }

 public void start(Properties properties) throws CacheException {
 }

 public void stop() {
 }

}

 

 

/**
 * @author Marc
 *
 */
public class MemCache implements Cache {
 private static final Log log = LogFactory.getLog(MemCache.class);

 private static final int SIXTY_THOUSAND_MS = 60000;

 MemCachedClient mc;
 String regionName;

 /**
  * Creates a new Hibernate pluggable cache based on a cache name. <p/>
  *
  * @param cache
  *            The underlying EhCache instance to use.
  */
 public MemCache(String regionName) {
  mc = new MemCachedClient();
  mc.setCompressEnable(false);
  this.regionName = regionName;
 }

 /**
  * Gets a value of an element which matches the given key.
  *
  * @param key
  *            the key of the element to return.
  * @return The value placed into the cache with an earlier put, or null if
  *         not found or expired
  * @throws CacheException
  */
 public Object get(Object key) throws CacheException {
  if (log.isDebugEnabled()) {
   log.debug("key: " + key);
  }
  if (key == null) {
   return null;
  } else {
   Object rt = mc.get(key.toString());
   if (rt == null) {
    if (log.isDebugEnabled()) {
     log.debug("Element for " + key + " is null");
    }
    return null;
   } else {
    return rt;
   }
  }

 }

 public Object read(Object key) throws CacheException {
  return get(key);
 }

 /**
  * Puts an object into the cache.
  *
  * @param key
  *            a key
  * @param value
  *            a value
  * @throws CacheException
  *             if the {@link CacheManager} is shutdown or another
  *             {@link Exception} occurs.
  */
 public void update(Object key, Object value) throws CacheException {
  put(key, value);
 }

 /**
  * Puts an object into the cache.
  *
  * @param key
  *            a key
  * @param value
  *            a value
  * @throws CacheException
  *             if the {@link CacheManager} is shutdown or another
  *             {@link Exception} occurs.
  */
 public void put(Object key, Object value) throws CacheException {
  mc.set(key.toString(), value);
 }

 /**
  * Removes the element which matches the key. <p/> If no element matches,
  * nothing is removed and no Exception is thrown.
  *
  * @param key
  *            the key of the element to remove
  * @throws CacheException
  */
 public void remove(Object key) throws CacheException {
  mc.delete(key.toString());
 }

 /**
  * Remove all elements in the cache, but leave the cache in a useable state.
  *
  * @throws CacheException
  */
 public void clear() throws CacheException {
  log.warn("cann't clear all items in memcached!");
  throw new CacheException("cann't clear all items in memcached!");
 }

 /**
  * Remove the cache and make it unuseable.
  *
  * @throws CacheException
  */
 public void destroy() throws CacheException {

 }

 /**
  * Calls to this method should perform there own synchronization. It is
  * provided for distributed caches. Because EHCache is not distributed this
  * method does nothing.
  */
 public void lock(Object key) throws CacheException {
 }

 /**
  * Calls to this method should perform there own synchronization. It is
  * provided for distributed caches. Because EHCache is not distributed this
  * method does nothing.
  */
 public void unlock(Object key) throws CacheException {
 }

 /**
  * Gets the next timestamp;
  */
 public long nextTimestamp() {
  return Timestamper.next();
 }

 /**
  * Returns the lock timeout for this cache.
  */
 public int getTimeout() {
  // 60 second lock timeout
  return Timestamper.ONE_MS * SIXTY_THOUSAND_MS;
 }

 public String getRegionName() {
  return this.regionName;
 }

 /**
  * Warning: This method can be very expensive to run. Allow approximately 1
  * second per 1MB of entries. Running this method could create liveness
  * problems because the object lock is held for a long period <p/>
  *
  * @return the approximate size of memory ehcache is using for the
  *         MemoryStore for this cache
  */
 public long getSizeInMemory() {
  log.warn("cann't getSizeInMemory in memcached!");
  throw new CacheException("cann't getSizeInMemory in memcached!");
 }

 public long getElementCountInMemory() {
  log.warn("cann't getElementCountInMemory in memcached!");
  throw new CacheException("cann't getElementCountInMemory in memcached!");
 }

 public long getElementCountOnDisk() {
  log.warn("cann't getElementCountOnDisk in memcached!");
  throw new CacheException("cann't getElementCountOnDisk in memcached!");
 }

 public Map toMap() {
  log.warn("cann't toMap in memcached!");
  throw new CacheException("cann't toMap in memcached!");
 }

 public String toString() {
  return "MemCached(" + getRegionName() + ')';
 }

}