java redis 连接池配置_Jedis连接池配置

1.使用MAVEN引入使用的包。

redis.clients

jedis

2.1.0

provided

org.springframework

spring-core

3.1.0.RELEASE

provided

org.springframework

spring-context

3.1.0.RELEASE

provided

org.springframework

spring-context-support

3.1.0.RELEASE

provided

org.springframework

spring-beans

3.1.0.RELEASE

provided

org.springframework

org.springframework.context

3.1.0.RELEASE

provided

org.springframework

spring-test

3.1.0.RELEASE

test

commons-io

commons-io

1.3.2

commons-lang

commons-lang

2.3

provided

junit

junit

4.10

test

org.aspectj

aspectjweaver

1.6.12

provided

net.sourceforge.cglib

com.springsource.net.sf.cglib

2.2.0

provided

log4j

log4j

1.2.8

2.Jedis的连接池配置需要用到org.apache.commons.pool.impl.GenericObjectPool.Config.class，此类是GenericObjectPool的一个内部类，使用spring xml配置时需要转换成以下自定义类。

package com.antilost.redis.util;

import org.apache.commons.pool.impl.GenericObjectPool;

/**

* User: ***

* Date: 13-8-27

* Time: 下午3:49

*/

public class GenericObjectPoolConfigWrapper {

private final GenericObjectPool.Config config;

public GenericObjectPoolConfigWrapper() {

this.config = new GenericObjectPool.Config();

}

public GenericObjectPool.Config getConfig() {

return config;

}

public int getMaxIdle() {

return this.config.maxIdle;

}

public void setMaxIdle(int maxIdle) {

this.config.maxIdle = maxIdle;

}

public int getMinIdle() {

return this.config.minIdle;

}

public void setMinIdle(int minIdle) {

this.config.minIdle = minIdle;

}

public int getMaxActive() {

return this.config.maxActive;

}

public void setMaxActive(int maxActive) {

this.config.maxActive = maxActive;

}

public long getMaxWait() {

return this.config.maxWait;

}

public void setMaxWait(long maxWait) {

this.config.maxWait = maxWait;

}

public byte getWhenExhaustedAction() {

return this.config.whenExhaustedAction;

}

public void setWhenExhaustedAction(byte whenExhaustedAction) {

this.config.whenExhaustedAction = whenExhaustedAction;

}

public boolean isTestOnBorrow() {

return this.config.testOnBorrow;

}

public void setTestOnBorrow(boolean testOnBorrow) {

this.config.testOnBorrow = testOnBorrow;

}

public boolean isTestOnReturn() {

return this.config.testOnReturn;

}

public void setTestOnReturn(boolean testOnReturn) {

this.config.testOnReturn = testOnReturn;

}

public boolean isTestWhileIdle() {

return this.config.testWhileIdle;

}

public void setTestWhileIdle(boolean testWhileIdle) {

this.config.testWhileIdle = testWhileIdle;

}

public long getTimeBetweenEvictionRunsMillis() {

return this.config.timeBetweenEvictionRunsMillis;

}

public void setTimeBetweenEvictionRunsMillis( long timeBetweenEvictionRunsMillis) {

this.config.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;

}

public int getNumTestsPerEvictionRun() {

return this.config.numTestsPerEvictionRun;

}

public void setNumTestsPerEvictionRun(int numTestsPerEvictionRun) {

this.config.numTestsPerEvictionRun = numTestsPerEvictionRun;

}

public long getMinEvictableIdleTimeMillis() {

return this.config.minEvictableIdleTimeMillis;

}

public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis) {

this.config.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;

}

public long getSoftMinEvictableIdleTimeMillis() {

return this.config.softMinEvictableIdleTimeMillis;

}

public void setSoftMinEvictableIdleTimeMillis( long softMinEvictableIdleTimeMillis) {

this.config.softMinEvictableIdleTimeMillis = softMinEvictableIdleTimeMillis;

}

public boolean isLifo() {

return this.config.lifo;

}

public void setLifo(boolean lifo) {

this.config.lifo = lifo;

}

}

3.在Spring配置文件中注入GenericObjectPoolConfigWrapper.java类

4.Redis的连接配置文件jedis.properties中，定义了各个环境的连接参数，具体配置如下

redis.pool.maxActive=redis.pool.maxActive.${ServerType}

redis.pool.maxIdle=redis.pool.maxIdle.${ServerType}

redis.pool.maxWait=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.*.*

redis.port.REL=6379

redis.password.REL=***

#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.*.*

redis.port.VRF=6379

redis.password.VRF=*** 根据系统环境变量JVM中ServerType的值，取不同的配置，实现多环境(测试环境、生产环境)集成。

5.Redis连接池配置

6.Redis 工具类

public 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 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 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 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 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 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 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 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 getListFromJedis(String key, String methodName) throws JMSCacheException {

List 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 getSetFromJedis(String key, String methodName) throws JMSCacheException {

Set 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 getHashMapFromJedis(String key, String methodName) {

Map 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;

}

}