memcached spring中 的配置

<!-- memcached配置 -->
    <bean id="memcachedClientBuilder" class="net.rubyeye.xmemcached.XMemcachedClientBuilder"> 
        <constructor-arg> 
                <bean class="net.rubyeye.xmemcached.utils.AddrUtil" factory-method="getAddresses"> 
                 <constructor-arg value="${cache.iplist}" />                                                                        <!-- 这里的value 是 memcached 的ip地址：比如本机的：127.0.0.1:11211 -->
             </bean>
        </constructor-arg> 
        <property name="connectionPoolSize" value="25"/>
        <property name="connectTimeout" value="18000"/>
        <property name="failureMode" value="false"/>
        <property name="commandFactory"> 
            <bean class="net.rubyeye.xmemcached.command.TextCommandFactory"/> 
        </property> 
        <property name="transcoder"> 
            <bean class="net.rubyeye.xmemcached.transcoders.SerializingTranscoder" /> 
        </property>
        <property name="keyProvider">                                                                                                              <!--  这里是key的生成  用户可以自定义 -->
            <bean class="com.haha.common.cache.CacheKeyProvider">
               <property name="keyPrefix" value="${cfg.env}_"/>
            </bean> 
        </property>   
    </bean>
    <bean id="memcachedClient" factory-bean="memcachedClientBuilder" factory-method="build" destroy-method="shutdown">
     <property name="enableHeartBeat" value="true"/>
    </bean>
    <bean id="cacheClient" class="com.haha.common.cache.CacheClient">                                                  <!--  这里是memcached 客户端 用户可以自定义 -->
     <property name="memcachedClient" ref="memcachedClient"></property>
     <property name="defaultTimeout" value="${cache.defaultTimeout}"/>
    </bean>

com.haha.common.cache.CacheKeyProvider 类 如下：

public class CacheKeyProvider implements keyProvider {
 private String keyPrefix;
 
 @Override
 public String process(String key) {
  if (key.startsWith("@")) {
   return key.substring(1);
  }
  return keyPrefix + key;
 }

 public String getKeyPrefix() {
  return keyPrefix;
 }

 public void setKeyPrefix(String keyPrefix) {
  this.keyPrefix = keyPrefix;
 }
 
}

com.haha.common.cache.CacheClient 类如下：

public class CacheClient {

 private static Logger logger = LoggerFactory.getLogger(CacheClient.class);

 // 默认操作超时时间 30000ms
 private long defaultTimeout = 30000;

 // 过期时间一分钟
 public static final int CACHE_EXPIRE_TIME_1_MIN = 60;

 // memcached 对象
 private MemcachedClient memcachedClient;

 /**
  * 向缓存设置数据，默认操作超时时间为500ms
  *
  * @param key
  * @param data
  * @param expireTime
  *            缓存数据有效期,以秒为单位
  * @return
  * @throws Exception
  */
 public boolean set(String key, int expireTime, Object data) {
  return set(key, expireTime, data, defaultTimeout);
 }

 /**
  * 向缓存设置数据，默认操作超时时间为500ms
  *
  * @param key
  *            缓存key
  * @param data
  *            缓存对象
  * @param expireTime
  *            缓存数据有效期,以秒为单位
  * @param timeout
  *            操作缓存超时时间，单位为ms
  * @return
  * @throws Exception
  */
 public boolean set(String key, int expireTime, Object data, long timeout) {
  if (data == null) {
   return false;
  }
  try {
   boolean ret = memcachedClient.set(key, expireTime, data, timeout);
   return ret;
  } catch (TimeoutException e) {
   logger.error(e.getMessage(), e);
  } catch (InterruptedException e) {
   logger.error(e.getMessage(), e);
  } catch (MemcachedException e) {
   logger.error(e.getMessage(), e);
  }
  return false;
 }

 /**
  * 从缓存取数据，默认操作缓存超时时间500ms
  *
  * @param key
  *            缓存数据key
  * @return
  * @throws Exception
  */
 public Object get(String key) {
  return get(key, defaultTimeout);
 }

 /**
  * 从缓存取数据
  *
  * @param key
  *            缓存数据key
  * @param timeout
  *            操作缓存超时时间，单位为ms
  * @return
  * @throws Exception
  */
 public Object get(String key, long timeout) {
  try {
   Object ret = memcachedClient.get(key, timeout);
   return ret;
  } catch (TimeoutException e) {
   logger.error(e.getMessage(), e);
  } catch (InterruptedException e) {
   logger.error(e.getMessage(), e);
  } catch (MemcachedException e) {
   logger.error(e.getMessage(), e);
  }
  return null;
 }

 /**
  * 从缓存取数据
  *
  * @param key
  * @return
  */
 public GetsResponse<Object> gets(String key) {
  try {
   return memcachedClient.gets(key);
  } catch (TimeoutException e) {
   logger.error(e.getMessage(), e);
  } catch (InterruptedException e) {
   logger.error(e.getMessage(), e);
  } catch (MemcachedException e) {
   logger.error(e.getMessage(), e);
  }
  return null;
 }

 /**
  * 从缓存中删除数据
  *
  * @param key
  *            缓存数据key
  * @return
  * @throws Exception
  */
 public boolean delete(String key) {
  return delete(key, defaultTimeout);
 }

 /**
  * 从缓存中删除数据
  *
  * @param key
  *            缓存数据key
  * @param timeout
  *            操作缓存超时时间，单位为ms
  * @return
  * @throws Exception
  */
 public boolean delete(String key, long timeout) {
  try {
   boolean ret = memcachedClient.delete(key, timeout);
   return ret;
  } catch (TimeoutException e) {
   logger.error(e.getMessage(), e);
  } catch (InterruptedException e) {
   logger.error(e.getMessage(), e);
  } catch (MemcachedException e) {
   logger.error(e.getMessage(), e);
  }
  return false;
 }

 /**
  * 向缓存设置数据
  *
  * @param key
  * @param operation
  * @return
  */
 public boolean cas(String key, CASOperation operation) {
  try {
   return (boolean) memcachedClient.cas(key, operation);
  } catch (TimeoutException e) {
   logger.error(e.getMessage(), e);
  } catch (InterruptedException e) {
   logger.error(e.getMessage(), e);
  } catch (MemcachedException e) {
   logger.error(e.getMessage(), e);
  }

  return false;
 }

 /**
  * 向缓存设置数据
  *
  * @param key
  * @param expireTime
  * @param data
  * @param cas
  * @return
  */
 public boolean cas(String key, int expireTime, Object data, long cas) {
  if (data == null) {
   return false;
  }
  try {
   return (boolean) memcachedClient.cas(key, expireTime, data, cas);
  } catch (TimeoutException e) {
   logger.error(e.getMessage(), e);
  } catch (InterruptedException e) {
   logger.error(e.getMessage(), e);
  } catch (MemcachedException e) {
   logger.error(e.getMessage(), e);
  }

  return false;
 }

 public void setMemcachedClient(MemcachedClient memcachedClient) {
  this.memcachedClient = memcachedClient;
 }

 public MemcachedClient getMemcachedClient() {
  return this.memcachedClient;
 }

 public long getDefaultTimeout() {
  return defaultTimeout;
 }

 public void setDefaultTimeout(long defaultTimeout) {
  this.defaultTimeout = defaultTimeout;
 }

}