redis配置 && memcache配置 及对

Redis

1.配置Jedis参数

redis.clients.jedis.JedisPoolConfig

<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!-- 最大能够保持idel状态的对象数  -->
        <property name="maxIdle" value="${jedis.maxIdle}" /> 
        <!-- 最大分配的对象数  高版本中用来替换maxWait参数 -->
        <property name="maxWaitMillis" value="${jedis.maxWait}" />
        <!-- 最大分配的对象数 -->
        <property name="maxTotal" value="${jedis.maxTotal}" />
        <!-- 当调用borrowObject获取jedis实例方法时，是否进行有效性检查（ping） -->
        <property name="testOnBorrow" value="true" /> 

        <!------------------------------ 通常配置以上参数，以下参数可选 ---------------------------------->
        <!-- 最大能获得jedis实例的个数,高版本中删除 -->
        <property name="maxActive" value="${jedis.maxActive}"/> 
       <!-- pool中的jedis实例被用完时的策略  
                        WHEN_EXHAUSTED_FAIL      表示无jedis实例时，直接抛出NoSuchElementException；  
                        WHEN_EXHAUSTED_BLOCK      表示阻塞住，超时抛出JedisConnectionException；
                        WHEN_EXHAUSTED_GROW    表示自动增长，新建一个jedis实例，不受maxTotal限制 -->
        <property name="whenExhaustedAction" value="${jedis.whenExhaustedAction}">
        <!-- borrowObject返回jedis实例时采用FIFO策略还是LIFO策略  默认为true（LIFO策略），false为FIFO  -->
        <property name="lifo" value="${jedis.lifo}">
</bean>

2.配置redis池

redis.clients.jedis.JedisPool

<bean id="jedisPool0" class="redis.clients.jedis.JedisPool">
        <!-- jedis配置  -->
        <constructor-arg name="poolConfig" ref="jedisPoolConfig" />
        <!-- jedis服务器地址 -->
        <constructor-arg name="host" value="${jedis.host}" />
        <!-- jedis服务器端口 -->
        <constructor-arg name="port" value="${jedis.port}" type="int" />
        <!-- 指定在空闲多少秒后断开连接 -->
        <constructor-arg name="timeout" value="${jedis.timeout}" type="int" />
        <!-- jedis服务器密码 -->
        <constructor-arg name="password" value="#{'${jedis.pwd}'!=''?'${jedis.pwd}':null}" />
        <!-- jedis数据库index -->
        <constructor-arg name="database" value="${jedis.db.index0}" type="int" />
</bean>
<!-- 配置多个redis池 -->   
<bean id="jedisPool1" class="redis.clients.jedis.JedisPool">
        <constructor-arg name="poolConfig" ref="jedisPoolConfig" />
        <constructor-arg name="host" value="${jedis.host}" />
        <constructor-arg name="port" value="${jedis.port}" type="int" />
        <constructor-arg name="timeout" value="${jedis.timeout}" type="int" />
        <constructor-arg name="password" value="#{'${jedis.pwd}'!=''?'${jedis.pwd}':null}" />
        <constructor-arg name="database" value="${jedis.db.index1}" type="int" />
</bean>

3.配置工具map

<bean id="jedisPoolsMap" class="java.util.HashMap">
        <constructor-arg>
            <map>
                <entry key="${jedis.db.index0}" value-ref="jedisPool0"/>
                <entry key="${jedis.db.index1}" value-ref="jedisPool1"/>
            </map>
        </constructor-arg>
</bean>

4.jedis的使用

文末会附上jedis工具类的java代码

5.服务器查看redis的键值

ps -ef | grep redis-server   #查看redis信息
netstat -ano | grep -6379  #按端口查找
redis-cli -h 127.0.0.1 -p 6379 --raw  #登陆redis服务器，-h 主机ip ， -p 端口号  ， -a  密码   --raw按中文原有方式输出
KEYS  #返回所有关键字
GET key   #根据关键字获取字符串类型的值
HEYS key    #返回哈希表key中所有的域 
HGET key field     #返回哈希表key中给定域的值
HMGET key field[filed....]  #返回哈希表key中给定的多个域的值
DEL key[key...]   #删除给定的一个或多个key
Quit 

---

*************************************************************华丽的分割线*************************************************************

---

Memcache

1.配置IO线程池

<bean id="memcacheResource" class="com.whalin.MemCached.SockIOPool"
        factory-method="getInstance" init-method="initialize" destroy-method="shutDown">
     <!-- 构造函数参数 -->
    <constructor-arg><value>memcacheResource</value></constructor-arg>
    <!-- memcache服务器的地址,可以设置多个服务器 -->
    <property name="servers"><list><value>${memcacheURL}</value></list></property>
    <!-- 每个服务器初始连接数 -->
    <property name="initConn"><value>10</value></property>
    <!-- 每个服务器最小连接数 -->
    <property name="minConn"><value>10</value></property>
    <!-- 每个服务器最大连接数 -->
    <property name="maxConn"><value>150</value></property>
    <!-- 每隔5秒维护一次连接数 -->
    <property name="maintSleep"><value>5000</value></property>
    <!-- 最大空闲时间 -->
    <property name="maxIdle"><value>600000</value></property>
    <!-- 禁用nagle算法  -->
    <property name="nagle"><value>false</value></property>
    <!-- TCP连接读取超时   3秒钟 -->
    <property name="socketTO"><value>3000</value></property>
</bean>

2.配置客户端和包装类

<bean id="mccResource" class="com.whalin.MemCached.MemCachedClient">
    <constructor-arg>
        <value>memcacheResource</value>
    </constructor-arg>
</bean>
<!-- 自定义封装的包装类，文末会附上示例代码 -->
<bean id="cacheWrapper" class="com.revo.eeducation.server.memcached.MemCacheWrapper">
    <constructor-arg>
        <ref bean="mccResource" />
    </constructor-arg>
</bean>

3.服务器查看缓存

get key[key...]   #返回储存在键中的值
set key 0 900 9      #设置键值对   key键   flags  一般为0   exptime 缓存时效（秒）bytes 在缓存中存储的字节
memcache    #设置存储的值   必须换行，且长度要跟设置的字节数一致，不然会报错CLIENT_ERROR bad data chunk
replace、append、prepend的语法跟set一致
stats   #统计命令

Redis 和 memcache 比较

内存使用效率：用简单的key-value存储，memcache的效率更好，而如果redis使用Hash结构来存储key-value，则redis的效率要高于memcache
性能方面: 在小数据量存储时，redis要高于memcache；在超过100K的数据中，memcache的性能更优
另外： redis对复杂数据提供的支持更多，而memcache可以设置多个服务器

---

---

JedisUtil.java

@Component
public class JedisUtil {
    
    private static final Logger LOGGER = Logger.getLogger(JedisUtil.class);
    
    /**默认数据库*/
    public static final int DB_DEFAULT = 0;
    
    /**数据库缓存*/
    public static final int DB_SQL = 1;
    
    /**jedis连接池对象名前缀*/
    public static final String JEDIS_POOL_PREFIX = "jedisPool";
    
    @Autowired
    private Map<String,JedisPool> jedisPoolsMap;


    /**
     * 获取jedis对象
     * @param database 数据库
     * @return Jedis对象
     */
    private Jedis getJedis(int database){
        
        if(MapUtils.isEmpty(jedisPoolsMap)){
            LOGGER.info("=============================注入连接池jedisPoolsMap失败=========================================");
        }
        return jedisPoolsMap.get(JEDIS_POOL_PREFIX+database).getResource();
    }
    
    
    /**
     * 检测redis是否OK
     * @return ok返回<code>true</code>
     */
    public boolean isOK(){
        Boolean bl = Boolean.FALSE;
        Jedis jedis = getJedis(DB_DEFAULT);
        if(!CommonUtils.isEmpty(jedis)){
            bl = Boolean.TRUE;
        }
        jedis.close();
        return bl;
    }

    /**
     * 设置缓存
     * @param database 数据库
     * @param key 缓存KEY
     * @param value 缓存值
     * @return Status code reply
     */
    public String set(int databse,String key,String value){
        Jedis jedis = getJedis(databse);
        
        String val = jedis.set(key, value);
        jedis.close();
        return val;
    }
    
    
    /**
     * 设置缓存
     * @param key 缓存KEY
     * @param value 缓存值
     * @return Status code reply
     */
    public String set(String key,String value){
        return set(DB_DEFAULT, key, value);
    }
    
    /**
     * 设置缓存
     * @param database 数据库
     * @param key 缓存KEY
     * @param value 缓存值
     * @return Status code reply
     */
    public String set(int databse,String key,Serializable value){
        Jedis jedis = getJedis(databse);
        String val = jedis.set(key.getBytes(), SerializableUtil.toByteArray(value));
        jedis.close();
        return val;
    }
    
    /**
     * 设置缓存
     * @param key 缓存KEY
     * @param value 缓存值
     * @return Status code reply
     */
    public String set(String key,Serializable value){
        return set(DB_DEFAULT, key, value);
    }
    
    /**
     * 设置带有时间长度的缓存
     * @param database 数据库
     * @param key 缓存KEY
     * @param value 缓存值
     * @param time 缓存时间 ，毫秒
     * @return Status code reply
     */
    public String set(int database,String key,String value,long time){
        Jedis jedis = getJedis(database);
        String nxxx = "NX";
        if(jedis.exists(key)){
            nxxx = "XX";
        }
        String val = jedis.set(key, value,nxxx,"PX",time);
        jedis.close();
        return val;
    }
    
    /**
     * 设置带有时间长度的缓存
     * @param key 缓存KEY
     * @param value 缓存值
     * @param time 缓存时间 ，毫秒
     * @return Status code reply
     */
    public String set(String key,String value,long time){
        return set(DB_DEFAULT, key, value, time);
    }
    
    /**
     * 设置带有时间长度的缓存
     * @param database 数据库
     * @param key 缓存KEY
     * @param value 缓存值
     * @param time 缓存时间 ，毫秒
     * @return Status code reply
     */
    public String set(int database,String key,Serializable value,long time){
        Jedis jedis = getJedis(database);
        byte[] byteKey = SerializableUtil.toByteArray(key);
        
        String nxxx = "NX";
        if(jedis.exists(byteKey)){
            nxxx = "XX";
        }
        
        byte[] nxxxByte = nxxx.getBytes();
        byte[] epxxByte = "PX".getBytes();
        
        String val = jedis.set(byteKey, SerializableUtil.toByteArray(value),nxxxByte,epxxByte,time);
        jedis.close();
        return val;
    }
    
    /**
     * 设置带有时间长度的缓存
     * @param key 缓存KEY
     * @param value 缓存值
     * @param time 缓存时间 ，毫秒
     * @return Status code reply
     */
    public String set(String key,Serializable value,long time){
        return set(DB_DEFAULT, key, value, time);
    }
    
    /**
     * 检查redis中是否包含key
     * @param database 数据库
     * @param key redis key
     * @return true if key is exists
     */
    public boolean containsKey(int database,String key){
        Jedis jedis = getJedis(database);
        boolean result =  jedis.exists(key);
        jedis.close();
        return result;
    }

    /**
     * 检查redis中是否包含key
     * @param key redis key
     * @return true if key is exists
     */
    public boolean containsKey(String key){
        return containsKey(DB_DEFAULT, key);
    }
    
    /**
     * 调用Redis的LPUSH命令
     * @param database 数据库
     * @param key redis key
     * @param val redis value
     * @return true if key is exists
     */
    public Long lpush(int database,String key,String... val){
        Long ret = -1L;
        Jedis jedis = getJedis(database);
        ret = jedis.lpush(key, val);
        jedis.close();
        return ret;
    }
    
    /**
     * 调用Redis的LPUSH命令
     * @param key redis key
     * @param val redis value
     * @return true if key is exists
     */
    public Long lpush(String key,String... val){
        return lpush(DB_DEFAULT, key, val);
    }
    
    /**
     * 调用Redis的hmset 将map保存到redis缓存中
     * @param database 数据库
     * @param key
     * @param map
     */
    public void hmset(int database,String key,Map<String, String> map){
        Jedis jedis = getJedis(database);
        jedis.hmset(key, map);
        jedis.close();
    }
    
    /**
     * 调用Redis的hmset 将map保存到redis缓存中
     * @param key
     * @param map
     */
    public void hmset(String key,Map<String, String> map){
        hmset(DB_DEFAULT, key, map);
    }
    
    /**
     * 调用Redis的hmget 获取对应key保存map中存储的fields对应的数据
     * @param key
     * @param fields
     * @return
     */
    public List<String> hmget(int database,String key,String... fields){
        Jedis jedis = getJedis(database);
        List<String> list = jedis.hmget(key, fields);
        jedis.close();
        return list;
    }
    
    /**
     * 调用Redis的hmget 获取对应key保存map中存储的fields对应的数据
     * @param key
     * @param fields
     * @return
     */
    public List<String> hmget(String key,String... fields){
        return hmget(DB_DEFAULT, key, fields);
    }
    
    /**
     * 调用Redis的hmget 获取对应key保存map中存储的fields对应的数据
     * @param database 数据库
     * @param key 缓存的KEY
     * @param cls 需要转换的对象
     * @param fields map的key
     * @return
     */
    public <T> List<T> hmget(int database,String key,Class<T> cls,String... fields){
        Jedis jedis = getJedis(database);
        List<String> list = jedis.hmget(key, fields);
        if(CollectionUtils.isNotEmpty(list) && !list.contains(null)){
            String retStr = Joiner.on(",").join(list);
            retStr = StringUtils.appendIfMissing(retStr, "]", "]");
            retStr = StringUtils.prependIfMissing(retStr, "[", "[");
            
            jedis.close();
            return JSON.parseArray(retStr, cls);
        }
        jedis.close();
        return null;
    }

    /**
     * 调用Redis的hmget 获取对应key保存map中存储的fields对应的数据
     * @param key 缓存的KEY
     * @param cls 需要转换的对象
     * @param fields map的key
     * @return
     */
    public  <T> List<T> hmget(String key,Class<T> cls,String... fields){
        return hmget(DB_DEFAULT, key, cls, fields);
    }
    
    /**
     * 调用Redis的hmget 获取对应key保存map中存储的fields对应的数据
     * @param database 数据库
     * @param key 缓存的KEY
     * @param type 需要转换的对象
     * @param fields map的key
     * @return
     */
    public  <T> List<T> hmget(int database,String key,Type type,String... fields){
        Jedis jedis = getJedis(database);
        List<String> list = jedis.hmget(key, fields);
        if(CollectionUtils.isNotEmpty(list) && !list.contains(null)){
            String retStr = Joiner.on(",").join(list);
            retStr = StringUtils.appendIfMissing(retStr, "]", "]");
            retStr = StringUtils.prependIfMissing(retStr, "[", "[");
            
            jedis.close();
            return JSON.parseObject(retStr, type);
        }
        jedis.close();
        return null;
    }
    
    /**
     * 调用Redis的hmget 获取对应key保存map中存储的fields对应的数据
     * @param key 缓存的KEY
     * @param type 需要转换的对象
     * @param fields map的key
     * @return
     */
    public  <T> List<T> hmget(String key,Type type,String... fields){
        return hmget(DB_DEFAULT, key, type, fields);
    }
    
    /**
     * 调用Redis的hmget 获取全部数据
     * @param database 数据库
     * @param key
     * @return
     */
    public  Map<String,String> hgetAll(int dababase,String key){
        Jedis jedis = getJedis(dababase);
        Map<String,String> map = jedis.hgetAll(key);
        jedis.close();
        return map;
    }
    
    /**
     * 调用Redis的hmget 获取全部数据
     * @param key
     * @return
     */
    public  Map<String,String> hgetAll(String key){
        return hgetAll(DB_DEFAULT, key);
    }
    
    /**
     * 调用Redis的hmget 获取全部value数据
     * @param key
     * @return
     */
    public  List<Object> hgetAllValue2Object(int database,String key){
        Map<String, String> map = hgetAll(database,key);
        List<Object> valList = new ArrayList<>();
        if(map != null){
            for (Iterator<String> iterator = map.values().iterator(); iterator.hasNext();) {
                String val = iterator.next();
                if(JsonUtils.isJSONArray(val)){
                    JSONArray jsonArray = JSON.parseArray(val);
                    if(!jsonArray.isEmpty()){
                        for (Object json : jsonArray) {
                            valList.add(json);
                        }
                    }
                }else if(JsonUtils.isJSONObject(val)){
                    valList.add(JSON.parse(val));
                }else{
                    valList.add(val);
                }
            }
        }
        
        return valList;
    }
    
    /**
     * 调用Redis的hmget 获取全部value数据
     * @param key
     * @return
     */
    public  List<Object> hgetAllValue2Object(String key){
        return hgetAllValue2Object(DB_DEFAULT, key);
    }
    
    /**
     * 调用Redis的hmget 获取全部value数据
     * @param key
     * @return
     */
    public  String hgetAllValue2Str(String key){
        List<Object> valList = hgetAllValue2Object(key);
        return CollectionUtils.isEmpty(valList) ? StringUtils.EMPTY : JSON.toJSONString(valList);
    }
    
    /**
     * 调用Redis的hmget 获取全部value数据，并转换为对象
     * @param key
     * @param cls
     * @return
     */
    public  <T> List<T> hgetAllValue(String key,Class<T> cls){
        List<Object> valList = hgetAllValue2Object(key);
        return JSON.parseArray(JSON.toJSONString(valList),cls);
    }
    
    /**
     * 调用Redis的hmget 获取全部value数据，并转换为对象
     * @param key
     * @param cls
     * @return
     */
    public  <T> T hgetAllValue(String key,Type type){
        List<Object> valList = hgetAllValue2Object(key);
        return JSON.parseObject(JSON.toJSONString(valList),type);
    }
    
    /**
     * 调用Redis的hmget 获取全部key数据
     * @param key
     * @return
     */
    public  List<String> hgetAllKey2Str(String key){
        Map<String, String> map = hgetAll(key);
        
        List<String> ret = new ArrayList<>();
        ret.addAll(map.keySet());
        return ret;
    }
    
    /**
     * 调用Redis的hmget 获取对应key保存map中存储的fields对应的数据
     * @param database 数据库
     * @param key
     * @param fields
     * @return
     */
    public  String hmget4Single(int database,String key,String field){
        String ret = StringUtils.EMPTY;
        Jedis jedis = getJedis(database);
        List<String> list = jedis.hmget(key, field);
        if(CollectionUtils.isNotEmpty(list)){
            ret = list.get(0);
        }
        jedis.close();
        return ret;
    }
    
    /**
     * 调用Redis的hmget 获取对应key保存map中存储的fields对应的数据
     * @param key
     * @param fields
     * @return
     */
    public  String hmget4Single(String key,String field){
        return hmget4Single(DB_DEFAULT, key, field);
    }
    
    /**
     * 调用Redis的hmget 获取对应key保存map中存储的fields对应的数据
     * @param database 数据库
     * @param key
     * @param fields
     * @param cls 需要转换的对象
     * @return
     */
    public  <T> T hmget4Single(int database,String key,String field,Class<T> cls){
        String ret = StringUtils.EMPTY;
        Jedis jedis = getJedis(database);
        List<String> list = jedis.hmget(key, field);
        if(CollectionUtils.isNotEmpty(list)){
            ret = list.get(0);
        }
        jedis.close();
        return StringUtils.isNotEmpty(ret) ? JSON.parseObject(ret, cls) : null;
    }
    
    /**
     * 调用Redis的hmget 获取对应key保存map中存储的fields对应的数据
     * @param key
     * @param fields
     * @param cls 需要转换的对象
     * @return
     */
    public  <T> T hmget4Single(String key,String field,Class<T> cls){
        return hmget4Single(DB_DEFAULT, key, field, cls);
    }
    
    /**
     * 调用Redis的HSET命令-散列
     * @param database 数据库
     * @param key redis key
     * @param val redis value
     * @return true if key is exists
     */
    public  Long hset(int database,String key,String field,String value){
        Long ret = -1L;
        Jedis jedis = getJedis(database);
        ret = jedis.hset(key, field, value);
        jedis.close();
        return ret;
    }
    
    /**
     * 调用Redis的HSET命令-散列
     * @param key redis key
     * @param val redis value
     * @return true if key is exists
     */
    public  Long hset(String key,String field,String value){
        return hset(DB_DEFAULT, key, field, value);
    }

    /**
     * 根据key前缀获取所有匹配的value
     * @param database 数据库
     * @param prefixKey key 前缀
     * @return List
     */
    public  List<String> getAllElementByPrefixKey(int database,String prefixKey){
        Jedis jedis = getJedis(database);
        List<String> result = new ArrayList<>();
        Set<String> values = jedis.keys(prefixKey + "*");
        for (String value : values){
            result.add(value);
        }
        jedis.close();
        return result;
    }
    
    /**
     * 根据key前缀获取所有匹配的value
     * @param prefixKey key 前缀
     * @return List
     */
    public  List<String> getAllElementByPrefixKey(String prefixKey){
        return getAllElementByPrefixKey(DB_DEFAULT, prefixKey);
    }

    /**
     * 根据KEY获取缓存数据
     * @param database 数据库
     * @param key 缓存KEY
     * @return 获取的缓存值
     */
    public  String get(int database,String key){
        Jedis jedis = getJedis(database);
        String val = jedis.get(key);
        jedis.close();
        return val;
    }
    
    /**
     * 根据KEY获取缓存数据
     * @param key 缓存KEY
     * @return 获取的缓存值
     */
    public String get(String key){
        return get(DB_DEFAULT, key);
    }
    
    /**
     * 根据KEY获取缓存数据
     * @param key 缓存KEY
     * @return 获取的缓存值
     */
    @SuppressWarnings("unchecked")
    public  <T> T getSerializable(int database,String key){
        Jedis jedis = getJedis(database);
        byte[] byteKey = SerializableUtil.toByteArray(key);
        
        if(!jedis.exists(byteKey)){
            jedis.close();
            return null;
        }
        Serializable val = SerializableUtil.toObject(jedis.get(byteKey));
        jedis.close();
        return (T) val;
    }
    
    /**
     * 根据KEY获取缓存数据
     * @param key 缓存KEY
     * @return 获取的缓存值
     */
    public  <T> T getSerializable(String key){
        return getSerializable(DB_DEFAULT, key);
    }
    
    /**
     * 根据KEY获取缓存数据对象
     * @param key 缓存KEY
     * @param clasz 需要转换的对象
     * @return 从缓存中获取的对象
     */
    public  <T> T get(int database,String key,Class<T> clasz){
        Jedis jedis = getJedis(database);
        String val = jedis.get(key);
        jedis.close();
        return StringUtils.isEmpty(val) ? null : JSON.parseObject(val, clasz);
    }
    
    /**
     * 根据KEY获取缓存数据对象
     * @param key 缓存KEY
     * @param clasz 需要转换的对象
     * @return 从缓存中获取的对象
     */
    public  <T> T get(String key,Class<T> clasz){
        return get(DB_DEFAULT, key, clasz);
    }
    
    /**
     * 根据KEY获取缓存数据并转换成List
     * @param key
     * @return string集合
     */
    public  List<String> getRedisList(String key){
        String value = get(key);
        if(StringUtils.isEmpty(value)){
            return new ArrayList<>();
        }
        @SuppressWarnings("unchecked")
        List<String> list = JSON.parseObject(value, List.class);
        return list;
    }
    
    /**
     * 根据key删除client的缓存
     * @param database 数据库
     * @param key
     */
    public  void remove(int database,String key){
        Jedis jedis = getJedis(database);
        if(jedis.exists(key)){
            Long del = jedis.del(key);
        }
        jedis.close();
    }
    
    /**
     * 根据key删除client的缓存
     * @param key
     */
    public  void remove(String key){
        remove(DB_DEFAULT, key);
    }
    
    /**
     * 根据前缀删除缓存
     * @param database 数据库
     * @param regex 正则字符串
     */
    public  void removePattern(int database,String regex){
        Jedis jedis = getJedis(database);
        Set<String> keys = jedis.keys(regex);
        if(!CommonUtils.isEmpty(keys)){
            jedis.del((String[])keys.toArray(new String[keys.size()])); 
        }
        jedis.close();
    }
    
    /**
     * 根据前缀删除缓存
     * @param regex 正则字符串
     */
    public  void removePattern(String regex){
        removePattern(DB_DEFAULT, regex);
    }
    
    /**
     * 根据前缀删除缓存
     * @param regex 正则字符串
     */
    public  void removeSerializePattern(int database,String regex){
        Jedis jedis = getJedis(database);
        Set<byte[]> keys = jedis.keys(regex.getBytes());
        if(!CommonUtils.isEmpty(keys)){
            byte[][] keyByteArray = new byte[keys.size()][];
            
            int i = 0;
            for (Iterator<byte[]> iterator = keys.iterator(); iterator.hasNext();) {
                byte[] bs = (byte[]) iterator.next();
                keyByteArray[i++] = bs;
            }
            
            jedis.del(keyByteArray);    
        }
        jedis.close();
    }
    
    /**
     * 根据前缀删除缓存
     * @param regex 正则字符串
     */
    public  void removeSerializePattern(String regex){
        removeSerializePattern(DB_DEFAULT, regex);
    }
    
    /**
     * 向redis中添加字符串集合
     * @param database 数据库
     * @param key redis中key
     * @param valueList 字符串集合
     */
    public  void addListElement(int database,String key,List<String> valueList){
        if (CollectionUtils.isEmpty(valueList)){
            return;
        }
        Jedis jedis = getJedis(database);
        jedis.rpush(key, valueList.toArray(new String[valueList.size()]));
        jedis.close();
    }
    
    /**
     * 向redis中添加字符串集合
     * @param key redis中key
     * @param valueList 字符串集合
     */
    public  void addListElement(String key,List<String> valueList){
        addListElement(DB_DEFAULT, key, valueList);
    }
    
    /**
     * 向redis中添加字符串
     * @param database 数据库
     * @param key redis中key
     * @param strings 字符串
     */
    public  void addStrElement(int database,String key, String... strings) {
        if (strings.length <= 0) {
            return;
        }
        Jedis jedis = getJedis(database);
        jedis.rpush(key, strings);
        jedis.close();
    }
    
    /**
     * 向redis中添加字符串
     * @param key redis中key
     * @param strings 字符串
     */
    public  void addStrElement(String key, String... strings) {
        addStrElement(DB_DEFAULT, key, strings);
    }
    
    /**
     * 根据key获取list所有元素
     * @param key redis中key
     * @return List
     */
    public  List<String> getListByKey(int database,String key){
        Jedis jedis = getJedis(database);
        List<String> result = jedis.lrange(key, 0l, jedis.llen(key) - 1);
        jedis.close();
        return result;
    }

    /**
     * 根据key获取list所有元素
     * @param key redis中key
     * @return List
     */
    public  List<String> getListByKey(String key){
        return getListByKey(DB_DEFAULT, key);
    }
    
    /**
     * 取出并删除名称为key的list首元素
     * @param key redis中key
     * @return list中首元素
     */
    public  String removeListElement(int database,String key){
        Jedis jedis = getJedis(database);
        String result = jedis.lpop(key);
        jedis.close();
        return result;
    }

    /**
     * 取出并删除名称为key的list首元素
     * @param key redis中key
     * @return list中首元素
     */
    public  String removeListElement(String key){
        return removeListElement(DB_DEFAULT, key);
    }

    /**
     * 获取名称为key的list size
     * @param database 数据库
     * @param key redis中key
     * @return size
     */
    public  long getListSizeByKey(int database,String key){
        Jedis jedis = getJedis(database);
        long size = jedis.llen(key);
        jedis.close();
        return size;
    }
    /**
     * 获取名称为key的list size
     * @param key redis中key
     * @return size
     */
    public  long getListSizeByKey(String key){
        return getListSizeByKey(DB_DEFAULT, key);
    }

    /**
     * 获取redis中名称key的list中count个元素并删除(从头至尾删除)
     * @param database 数据库
     * @param key redis中key
     * @param count 需删除的元素个数
     * @return list,删除的元素集合,count必须大于零小于等于list size,否则返回empty list
     */
    public  List<String> removeList(int database,String key,int count){
        List<String> result = new ArrayList<>();
        if (count <= 0){
            return result;
        }
        Jedis jedis = getJedis(database);
        long listSize = jedis.llen(key);
        if (count > listSize){
            count = (int)listSize;
        }
        for (int x = 0,i = count; x < i; x++){
            result.add(jedis.lpop(key));
        }
        jedis.close();
        return result;
    }
    
    /**
     * 获取redis中名称key的list中count个元素并删除(从头至尾删除)
     * @param key redis中key
     * @param count 需删除的元素个数
     * @return list,删除的元素集合,count必须大于零小于等于list size,否则返回empty list
     */
    public  List<String> removeList(String key,int count){
        return removeList(DB_DEFAULT, key, count);
    }

    /**
     * 获取redis中名称key的MAP中 key为${mapKey}的value值
     * @param jedisKey
     * @param mapKey
     * @return List<String>
     */
    public  List<String> getMapValByKey(int database,String jedisKey, String mapKey) {
        Jedis jedis = getJedis(database);
        List<String> list = jedis.hmget(jedisKey, mapKey);
        jedis.close();
        return list;
    }
    
    /**
     * 获取redis中名称key的MAP中 key为${mapKey}的value值
     * @param jedisKey
     * @param mapKey
     * @return List<String>
     */
    public  List<String> getMapValByKey(String jedisKey, String mapKey) {
        return getMapValByKey(DB_DEFAULT, jedisKey, mapKey);
    }
   
    /**
     * 检查key在redis中是否存在
     * @param key
     * @return 存在返回<code>true</code>,否则返回<code>false</code>
     */
    public  boolean exists(int database,String key) {
        Jedis jedis = getJedis(database);
        Boolean exists = jedis.exists(key);
        jedis.close();

        return exists;
    }
    
    /**
     * 检查key在redis中是否存在
     * @param key
     * @return 存在返回<code>true</code>,否则返回<code>false</code>
     */
    public  boolean exists(String key) {
        return exists(DB_DEFAULT, key);
    }
    
    /**
     * 设置 list
     * @param database 数据库
     * @param <T>
     * @param key
     * @param value
     */
    public  <T> void setList(int database,String key, List<T> list) {
        Jedis jedis = getJedis(database);
        try {
            jedis.set(key.getBytes(), ObjectSerializableUtil.serialize(list));
        } catch (Exception e) {
            LOGGER.error("Set key error : " + e);
        }finally{
            jedis.close();
        }
    }
    
    /**
     * 设置 list
     * @param <T>
     * @param key
     * @param value
     */
    public  <T> void setList(String key, List<T> list) {
        setList(DB_DEFAULT, key, list);
    }

    /**
     * 获取list
     * @param database 数据库
     * @param <T>
     * @param key
     * @return list
     */
    @SuppressWarnings("unchecked")
    public  <T> List<T> getList(int database,String key) {
        if(StringUtils.isEmpty(key)){
            LOGGER.error("jedis-传入的KEY为空");
            return null;
        }
        Jedis jedis = getJedis(database);
        if (jedis == null || !jedis.exists(key.getBytes())) {
            jedis.close();
            return null;
        }
        byte[] in = jedis.get(key.getBytes());
        List<T> list = (List<T>) ObjectSerializableUtil.deserialize(in);
        jedis.close();
        return list;
    }
    
    /**
     * 获取list
     * @param <T>
     * @param key
     * @return list
     */
    public  <T> List<T> getList(String key) {
        return getList(DB_DEFAULT, key);
    }
}

MemCacheWrapper.java

/**
 * 包装 {@link MemCachedClient}，集中处理缓存错误不影响业务流程
 * 
 * 
 */
public class MemCacheWrapper
{
    private static ServerLogger logger = new ServerLogger(MemCacheWrapper.class);
    
    private MemCachedClient client;
    
    /**
     * 是否可写(默认为可写)
     */
    private boolean writable = true;
    
    private String[] servers;
    
    public MemCacheWrapper(MemCachedClient client)
    {
        this.client = client;
        try
        {
            com.whalin.MemCached.SockIOPool sockIOPool = BeanHolder.getBean("memcacheResource");
            this.servers = sockIOPool.getServers();
            String localIp = InetAddress.getLocalHost().getHostAddress();
            boolean matched = false;
            for (String server : this.servers)
            {
                //只有添加在里面的ip才会开启可写模式；
                if (server.contains("localhost") || server.contains("127.0.0.1") || server.contains(localIp))
                {
                    matched = true;
                    break;
                }
            }
            this.writable = matched;
        }
        catch (Exception e)
        {
            logger.error("判断memcached是否可写失败！", e);
        }
    }
    
    public <T> Map<String, T> getMulti(Class<T> type, String... keys)
    {
        return getMap(type, keys);
    }
    
    @SuppressWarnings("unchecked")
    private <T> Map<String, T> getMap(Class<T> type, String... keys)
    {
        Map<String, Object> map = client.getMulti(keys);
        if (map == null)
        {
            // 总是返回一个Map防止程序出现空指针异常
            return new HashMap<String, T>();
        }
        Iterator<Entry<String, Object>> it = map.entrySet().iterator();
        while (it.hasNext())// 类型转换检查
        {
            Entry<String, Object> entry = it.next();
            if (entry.getValue() == null)
            {
                continue;
            }
            entry.setValue(castAs(type, entry.getKey(), entry.getValue()));
            if (entry.getValue() == null)
            {
                it.remove();
            }
        }
        return (Map<String, T>)map;
    }
    
    public <T> T get(Class<T> type, String key)
    {
        Object t = client.get(key);
        return castAs(type, key, t);
    }
    
    @SuppressWarnings("unchecked")
    public <T> T[] getMultiArray(Class<T> type, String... keys)
    {
        Object[] values = client.getMultiArray(keys);
        if (values == null)
        {
            return (T[])Array.newInstance(type, 0);
        }
        T[] arr = (T[])Array.newInstance(type, values.length);
        for (int i = 0; i < values.length; i++)
        {
            arr[i] = castAs(type, null, values[i]);
        }
        return arr;
    }
    
    /**
     * 增加一个指定键的计数器+1
     * 
     * @param key
     * @return
     */
    public long incr(String key)
    {
        return client.incr(key);
    }
    
    /**
     * 增加一个指定键的计数器+value
     * 
     * @param key
     * @param value
     * @return
     */
    public long incr(String key, long value)
    {
        return client.incr(key, value);
    }
    
    public long decr(String key)
    {
        return client.decr(key);
    }
    
    public long decr(String key, long value)
    {
        return client.decr(key, value);
    }
    
    public boolean delete(String key)
    {
        return client.delete(key);
    }
    
    @SuppressWarnings("deprecation")
    public boolean delete(String key, Date expiry)
    {
        return client.delete(key, expiry);
    }
    
    public boolean set(String key, Object value)
    {
        if (!writable)
        {
            return false;
        }
        if (value == null)
        {
            Throwable t = new Throwable("null value to cache TraceStack");
            logger.error("set a null value to memcache with key[" + key + "] ,See follow invoke trace", t);
            return false;
        }
        return client.set(key, value);
    }
    
    public boolean set(String key, Object value, Date expire)
    {
        if (!writable)
        {
            return false;
        }
        if (value == null)
        {
            Throwable t = new Throwable("null value to cache TraceStack");
            logger.error("set a null value to memcache with key[" + key + "] ,See follow invoke trace", t);
            return false;
        }
        return client.set(key, value, expire);
    }
    
    /**
     * 执行stats命令，返回缓存的当前状态
     * 
     * @return
     */
    @SuppressWarnings({"unchecked", "rawtypes"})
    public Map<String, Map<String, String>> stats()
    {
        Map map = client.stats();
        if (map == null)
        {
            return new HashMap<String, Map<String, String>>();
        }
        return map;
    }
    
    /**
     * 在所有的Memcached服务端执行缓存清除动作
     * 
     * Will return true only if succeeds in clearing all servers.
     * 
     * @return success true/false
     */
    public boolean flushAll()
    {
        return client.flushAll();
    }
    
    /**
     * 在指定的Memcached服务端执行缓存清除动作 Will return true only if succeeds in clearing all servers. If pass in null, then will
     * try to flush all servers.
     * 
     * @param servers optional array of host(s) to flush (host:port)
     * @return success true/false
     */
    public boolean flushAll(String[] servers)
    {
        return client.flushAll(servers);
    }
    
    /**
     * 进行类型转换同时处理转换异常
     * 
     * @param type
     * @param value
     * @return
     */
    private <T> T castAs(Class<T> type, String key, Object value)
    {
        if (value == null)
        {
            return null;
        }
        try
        {
            T t = type.cast(value);
            return t;
        }
        catch (ClassCastException ignoreMe)
        {
            StringBuilder errMsg = new StringBuilder("+++ incorrect cache type[");
            errMsg.append(value.getClass().getName())
                .append("] with key[" + key + "], value [")
                .append(value)
                .append("]");
            errMsg.append(",expect type [").append(type.getName()).append("]");
            logger.error(errMsg, ignoreMe);
        }
        return null;
    }

    public boolean isWritable()
    {
        return writable;
    }

    public void setWritable(boolean writable)
    {
        this.writable = writable;
    }

    public String[] getServers()
    {
        return servers;
    }
    
}