关于jedis2.4以上版本的连接池配置，及工具类

jedis.propertise 注意以前版本的maxAcitve和maxWait有所改变，JVM根据系统环境变量ServerType中的值 取不同的配置，实现多环境（测试环境、生产环境）集成。

redis.pool.maxTotal=redis.pool.maxActive.${ServerType}
redis.pool.maxIdle=redis.pool.maxIdle.${ServerType}
redis.pool.maxWaitMillis=redis.pool.maxWait.${ServerType}
redis.pool.minIdle=redis.pool.minIdle.${ServerType}
redis.host=redis.host.${ServerType}
redis.port=redis.port.${ServerType}
redis.password=redis.password.${ServerType}
redis.pool.testOnBorrow=true
redis.pool.testOnReturn=true
redis.timeout=1000
#C
#REL
redis.pool.maxActive.REL=200
redis.pool.maxIdle.REL=50
redis.pool.minIdle.REL=10
redis.pool.maxWait.REL=300
redis.host.REL=192.168.0.201
redis.port.REL=8989
redis.password.REL=beidou123

#VRF
redis.pool.maxActive.VRF=200
redis.pool.maxIdle.VRF=50
redis.pool.minIdle.VRF=10
redis.pool.maxWait.VRF=300
redis.host.VRF=192.168.0.201
redis.port.VRF=8989
redis.password.VRF=beidou123

config的包装便于后面xml的注入

/**
 * redis连接池配置文件包装类
 *
 * @author daxiong
 *         date: 2017/03/07 11:51
 */
public class GenericObjectPoolConfigWrapper extends GenericObjectPoolConfig {

    public GenericObjectPoolConfig getConfig() {
        return this;
    }

}

spring配置

<!--redis连接池配置-->
    <context:property-placeholder location="classpath:jedis.properties" ignore-unresolvable="true"/>
    <bean id="jedisPoolConfig" class="smm.mvc.CacheDb.GenericObjectPoolConfigWrapper">
        <!--最大连接数-->
        <property name="maxTotal" value="${${redis.pool.maxTotal}}" />
        <!--最大空闲连接数-->
        <property name="maxIdle" value="${${redis.pool.maxIdle}}" />
        <!--初始化连接数-->
        <property name="minIdle" value="${${redis.pool.minIdle}}"/>
        <!--最大等待时间-->
        <property name="maxWaitMillis" value="${${redis.pool.maxWaitMillis}}" />
        <!--对拿到的connection进行validateObject校验-->
        <property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
        <!--在进行returnObject对返回的connection进行validateObject校验-->
        <property name="testOnReturn" value="${redis.pool.testOnReturn}" />
        <!--定时对线程池中空闲的链接进行validateObject校验-->
        <property name="testWhileIdle" value="true" />
    </bean>

    <bean id="jedisPool" class="redis.clients.jedis.JedisPool" destroy-method="destroy">
        <constructor-arg index="0">
            <bean factory-bean="jedisPoolConfig" factory-method="getConfig"/>
        </constructor-arg>
        <constructor-arg index="1" value="${${redis.host}}"/>
        <constructor-arg index="2" value="${${redis.port}}"/>
        <!--timeout-->
        <constructor-arg index="3" value="${redis.timeout}"/>
        <constructor-arg index="4" value="${${redis.password}}"/>
    </bean>

jedis工具类

ublic abstract class JCacheTools {
    public abstract int getDBIndex();
    /**
     * 默认日志打印logger_default
     */
    public static Logger logger_default = Logger.getLogger("logger_jCache_default");
    /**
     * 失败日志logger，用于定期del指定的key
     */
    public static Logger logger_failure = Logger.getLogger("logger_jCache_failure");

    @Resource
    protected JedisPool jedisPool;

    protected Jedis getJedis() throws JedisException {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
        } catch (JedisException e) {
            LogContext.instance().warn(logger_failure, "failed:jedisPool getResource.", e);
            if(jedis!=null){
                jedisPool.returnBrokenResource(jedis);
            }
            throw e;
        }
        return jedis;
    }

    protected void release(Jedis jedis, boolean isBroken) {
        if (jedis != null) {
            if (isBroken) {
                jedisPool.returnBrokenResource(jedis);
            } else {
                jedisPool.returnResource(jedis);
            }
        }
    }

    protected String addStringToJedis(String key, String value, int cacheSeconds, String methodName) {
        Jedis jedis = null;
        boolean isBroken = false;
        String lastVal = null;
        try {
            jedis = this.getJedis();
            jedis.select(getDBIndex());
            lastVal = jedis.getSet(key, value);
            if(cacheSeconds!=0){
                jedis.expire(key,cacheSeconds);
            }
            LogContext.instance().debug(logger_default, "succeed:" + methodName, key, value);
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:" + methodName, key, value, e);
        } finally {
            release(jedis, isBroken);
        }
        return lastVal;
    }

    protected void addStringToJedis(Map<String,String> batchData, int cacheSeconds, String methodName) {
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = this.getJedis();
            jedis.select(getDBIndex());
            Pipeline pipeline = jedis.pipelined();
            for(Map.Entry<String,String> element:batchData.entrySet()){
                if(cacheSeconds!=0){
                    pipeline.setex(element.getKey(),cacheSeconds,element.getValue());
                }else{
                    pipeline.set(element.getKey(),element.getValue());
                }
            }
            pipeline.sync();
            LogContext.instance().debug(logger_default, "succeed:" + methodName,batchData.size());
        } catch (Exception e) {
            isBroken = true;
            e.printStackTrace();
        } finally {
            release(jedis, isBroken);
        }
    }

    protected void addListToJedis(String key, List<String> list, int cacheSeconds, String methodName) {
        if (list != null && list.size() > 0) {
            Jedis jedis = null;
            boolean isBroken = false;
            try {
                jedis = this.getJedis();
                jedis.select(getDBIndex());
                if (jedis.exists(key)) {
                    jedis.del(key);
                }
                for (String aList : list) {
                    jedis.rpush(key, aList);
                }
                if(cacheSeconds!=0){
                    jedis.expire(key, cacheSeconds);
                }
                LogContext.instance().debug(logger_default, "succeed:" + methodName, key, list.size());
            } catch (JedisException e) {
                isBroken = true;
                LogContext.instance().warn(logger_failure, "failed:" + methodName, key, list.size(), e);
            } catch (Exception e) {
                isBroken = true;
                LogContext.instance().warn(logger_failure, "failed:" + methodName, key, list.size(), e);
            } finally {
                release(jedis, isBroken);
            }
        }
    }

    protected void addToSetJedis(String key, String[] value, String methodName) {
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = this.getJedis();
            jedis.select(getDBIndex());
            jedis.sadd(key,value);
            LogContext.instance().debug(logger_default, "succeed:" + methodName, key, value);
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:" + methodName, key, value, e);
        } finally {
            release(jedis, isBroken);
        }
    }

    protected void removeSetJedis(String key,String value, String methodName) {
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = this.getJedis();
            jedis.select(getDBIndex());
            jedis.srem(key,value);
            LogContext.instance().debug(logger_default, "succeed:" + methodName, key, value);
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:" + methodName, key, value, e);
        } finally {
            release(jedis, isBroken);
        }
    }

    protected void pushDataToListJedis(String key, String data, int cacheSeconds, String methodName) {
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = this.getJedis();
            jedis.select(getDBIndex());
            jedis.rpush(key, data);
            if(cacheSeconds!=0){
                jedis.expire(key,cacheSeconds);
            }
            LogContext.instance().debug(logger_default, "succeed:" + methodName, key, data);
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:" + methodName, key, data, e);
        } finally {
            release(jedis, isBroken);
        }
    }
    protected void pushDataToListJedis(String key,List<String> batchData, int cacheSeconds, String methodName) {
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = this.getJedis();
            jedis.select(getDBIndex());
            jedis.del(key);
            jedis.lpush(key,batchData.toArray(new String[batchData.size()]));
            if(cacheSeconds!=0)
                jedis.expire(key,cacheSeconds);
            LogContext.instance().debug(logger_default, "succeed:" + methodName,batchData!=null?batchData.size():0);
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:" + methodName, batchData!=null?batchData.size():0, e);
        } finally {
            release(jedis, isBroken);
        }
    }

    /**
     * 删除list中的元素
     * @param key
     * @param values
     * @param methodName
     */
    protected void deleteDataFromListJedis(String key,List<String> values, String methodName) {
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = this.getJedis();
            jedis.select(getDBIndex());
            Pipeline pipeline = jedis.pipelined();
            if(values!=null && !values.isEmpty()){
                for (String val:values){
                    pipeline.lrem(key,0,val);
                }
            }
            pipeline.sync();
            LogContext.instance().debug(logger_default, "succeed:" + methodName,values!=null?values.size():0);
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:" + methodName, values!=null?values.size():0, e);
        } finally {
            release(jedis, isBroken);
        }
    }

    protected void addHashMapToJedis(String key, Map<String, String> map, int cacheSeconds, boolean isModified, String methodName) {
        boolean isBroken = false;
        Jedis jedis = null;
        if (map != null && map.size() > 0) {
            try {
                jedis = this.getJedis();
                jedis.select(getDBIndex());
                jedis.hmset(key, map);
                if (cacheSeconds >= 0)
                    jedis.expire(key, cacheSeconds);
                LogContext.instance().debug(logger_default, "succeed:" + methodName, key, map.size());
            } catch (Exception e) {
                isBroken = true;
                LogContext.instance().warn(logger_failure, "failed:" + methodName, key, map.size(), e);
            } finally {
                release(jedis, isBroken);
            }
        }
    }

    protected void addHashMapToJedis(String key, String field, String value, int cacheSeconds, String methodName) {
        boolean isBroken = false;
        Jedis jedis = null;
        try {
            jedis = this.getJedis();
            if (jedis != null) {
                jedis.select(getDBIndex());
                jedis.hset(key, field, value);
                jedis.expire(key, cacheSeconds);
                LogContext.instance().debug(logger_default, "succeed:" + methodName, key, field, value);
            }
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:" + methodName, key, field, value, e);
        }finally {
            release(jedis, isBroken);
        }
    }

    protected void updateHashMapToJedis(String key, String incrementField, long incrementValue, String dateField, String dateValue, String methodName) {
        boolean isBroken = false;
        Jedis jedis = null;
        try {
            jedis = this.getJedis();
            jedis.select(getDBIndex());
            jedis.hincrBy(key, incrementField, incrementValue);
            jedis.hset(key, dateField, dateValue);
            LogContext.instance().debug(logger_default, "succeed:" + methodName, key, incrementField, incrementValue);
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:" + methodName, key, incrementField, incrementValue, e);
        }finally {
            release(jedis, isBroken);
        }
    }

    public String getStringFromJedis(String key, String methodName) {
        String value = null;
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = this.getJedis();
            jedis.select(getDBIndex());
            if (jedis.exists(key)) {
                value = jedis.get(key);
                value = StringUtils.isNotBlank(value) && !"nil".equalsIgnoreCase(value)?value:null;
                LogContext.instance().debug(logger_default, "succeed:" + methodName, key, value);
            }
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:" + methodName, key, value, e);
        } finally {
            release(jedis, isBroken);
        }
        return value;
    }

    public List<String> getStringFromJedis(String[] keys, String methodName) {
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = this.getJedis();
            jedis.select(getDBIndex());
            return jedis.mget(keys);
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:" + methodName, Arrays.toString(keys), e);
        } finally {
            release(jedis, isBroken);
        }
        return null;
    }

    protected List<String> getListFromJedis(String key, String methodName) throws JMSCacheException {
        List<String> list = null;
        boolean isBroken = false;
        Jedis jedis = null;
        try {
            jedis = this.getJedis();
            jedis.select(getDBIndex());
            if (jedis.exists(key)) {
                list = jedis.lrange(key, 0, -1);
                LogContext.instance().debug(logger_default, "succeed:" + methodName, key, list != null ? list.size() : 0);
            }
        } catch (JedisException e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:" + methodName, key, list != null ? list.size() : 0, e);
        } finally {
            release(jedis, isBroken);
        }
        return list;
    }

    protected Set<String> getSetFromJedis(String key, String methodName) throws JMSCacheException {
        Set<String> list = null;
        boolean isBroken = false;
        Jedis jedis = null;
        try {
            jedis = this.getJedis();
            jedis.select(getDBIndex());
            if (jedis.exists(key)) {
                list = jedis.smembers(key);
                LogContext.instance().debug(logger_default, "succeed:" + methodName, key, list != null ? list.size() : 0);
            }
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:" + methodName, key, list != null ? list.size() : 0, e);
        } finally {
            release(jedis, isBroken);
        }
        return list;
    }

    protected Map<String, String> getHashMapFromJedis(String key, String methodName) {
        Map<String, String> hashMap = null;
        boolean isBroken = false;
        Jedis jedis = null;
        try {
            jedis = this.getJedis();
            jedis.select(getDBIndex());
            hashMap = jedis.hgetAll(key);
            LogContext.instance().debug(logger_default, "succeed:" + methodName, key, hashMap != null ? hashMap.size() : 0);
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:" + methodName, key, hashMap != null ? hashMap.size() : 0, e);
        } finally {
            release(jedis, isBroken);
        }
        return hashMap;
    }

    protected String getHashMapValueFromJedis(String key, String field, String methodName) {
        String value = null;
        boolean isBroken = false;
        Jedis jedis = null;
        try {
            jedis = this.getJedis();
            if (jedis != null) {
                jedis.select(getDBIndex());
                if (jedis.exists(key)) {
                    value = jedis.hget(key, field);
                    LogContext.instance().debug(logger_default, "succeed:" + methodName, key, field, value);
                }
            }
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:" + methodName, key, field, value, e);
        } finally {
            release(jedis, isBroken);
        }
        return value;
    }

    public Long getIdentifyId(String identifyName ,String methodName) {
        boolean isBroken = false;
        Jedis jedis = null;
        Long identify=null;
        try {
            jedis = this.getJedis();
            if (jedis != null) {
                jedis.select(getDBIndex());
                identify = jedis.incr(identifyName);
                if(identify==0){
                    return jedis.incr(identifyName);
                }else {
                    return identify;
                }
            }
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:" + methodName, identifyName, "", identify, e);
        } finally {
            release(jedis, isBroken);
        }
        return null;
    }


    /**
     * 删除某db的某个key值
     * @param key
     * @return
     */
    public Long delKeyFromJedis(String key) {
        boolean isBroken = false;
        Jedis jedis = null;
        long result = 0;
        try {
            jedis = this.getJedis();
            jedis.select(getDBIndex());
            LogContext.instance().debug(logger_default, "succeed:delKeyFromJedis");
            return jedis.del(key);
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:delKeyFromJedis", e);
        } finally {
            release(jedis, isBroken);
        }
        return result;
    }

    /**
     * 根据dbIndex flushDB每个shard
     *
     * @param dbIndex
     */
    public void flushDBFromJedis(int dbIndex) {
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = this.getJedis();
            jedis.select(dbIndex);
            jedis.flushDB();
            LogContext.instance().debug(logger_default, "succeed:flushDBFromJedis");
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:flushDBFromJedis", e);
        } finally {
            release(jedis, isBroken);
        }
    }

    public boolean existKey(String key, String methodName) {
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = this.getJedis();
            jedis.select(getDBIndex());
            LogContext.instance().debug(logger_default, "succeed:"+methodName);
            return jedis.exists(key);
        } catch (Exception e) {
            isBroken = true;
            LogContext.instance().warn(logger_failure, "failed:"+methodName, e);
        } finally {
            release(jedis, isBroken);
        }
        return false;
    }

}