解决使用redisTemplate高并发下连接池满的问题

用JMeter进行高并发测试的时候，发现报错：

org.springframework.data.redis.RedisConnectionFailureException: Cannot get Jedis connection;

nested exception is redis.clients.jedis.exceptions.JedisException: Could not get a resource from the pool

连不上redis，是因为连接池不够用了

我用的是redisTemplate来操作redis，而redisTemplate并不会自动释放连接

有一个方法，就是加大最大连接数，但是治标不治本，加到redis.maxIdle=1000了，看似够大了，但连接数一直在增加，迟早会崩

找了很久，最后发现 这个方法可用

在使用redisTemplate的部分用try-catch-finally包起来

在catch-finally中加上，手动断开连接，现在就不会报错了

RedisConnectionUtils.unbindConnection(redisTemplate.getConnectionFactory());

现在设置最大连接数redis.maxIdle=100也没事了

在redis-cli中输入 info clients 现在的连接数大概在二三十左右

补充知识：Redis 配置连接池，redisTemplate 操作多个db数据库，切换多个db，解决JedisConnectionFactory的设置连接方法过时问题。

环境

1、springmvc

2、jdk1.8

3、maven

redis.properties配置文件

#redis setting 
redis.host=localhost
redis.port=6379
redis.password=
redis.maxIdle=200
redis.minIdle=0
redis.maxActive=50
redis.maxWait=10000
redis.testOnBorrow=true
redis.timeout=100000

#定义需要使用的db
//#sessionCode DB
sessionCodeDb = 0
//#车辆基本信息 DB
bicycleInfoDb = 15
//#当前位置信息 DB
currentLocationDb = 14
//#锁车/解锁 DB
lockDb = 13
//#根据车牌获取电子车牌 DB
ebikeNoDb = 12
//#根据电子车牌获取车牌 DB
bikeNoDb = 11

pom.xml依赖

 
 UTF-8
 5.1.2.RELEASE
 
 
 
 org.springframework
 spring-context
 ${spring.version}
 
 
 org.springframework
 spring-context-support
 ${spring.version}
 
 
 org.springframework
 spring-core
 ${spring.version}
 
 
 org.springframework
 spring-web
 ${spring.version}
 
 
 org.springframework
 spring-webmvc
 ${spring.version}
 
 

 
 redis.clients
 jedis
 2.9.3
 
 
 
 org.springframework.data
 spring-data-redis
 2.0.14.RELEASE
 
 
 
 com.alibaba
 fastjson
 1.2.11
 
 
 
 
 net.sf.json-lib
 json-lib
 2.4
 jdk15
 

RedisConfig.java 配置类 初始化redis连接池

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import redis.clients.jedis.JedisPoolConfig;

import javax.annotation.PostConstruct;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Component
@Slf4j
public class RedisConfig {

 @Value("${redis.host}")
 private String hostName;
 @Value("${redis.port}")
 private int port;
 @Value("${redis.password}")
 private String passWord;
 @Value("${redis.maxIdle}")
 private int maxIdl;
 @Value("${redis.minIdle}")
 private int minIdl;
 @Value("${redis.timeout}")
 private int timeout;

 @Value("${sessionCodeDb}")
 private int sessionCodeDb;
 @Value("${bicycleInfoDb}")
 private int bicycleInfoDb;
 @Value("${currentLocationDb}")
 private int currentLocationDb;
 @Value("${lockDb}")
 private int lockDb;
 @Value("${ebikeNoDb}")
 private int ebikeNoDb;
 @Value("${bikeNoDb}")
 private int bikeNoDb;

 public static Map> redisTemplateMap = new HashMap<>();

 @PostConstruct
 public void initRedisTemp() throws Exception{
  log.info("###### START 初始化 Redis 连接池 START ######");
  redisTemplateMap.put(sessionCodeDb,redisTemplateObject(sessionCodeDb));
  redisTemplateMap.put(bicycleInfoDb,redisTemplateObject(bicycleInfoDb));
  redisTemplateMap.put(currentLocationDb,redisTemplateObject(currentLocationDb));
  redisTemplateMap.put(lockDb,redisTemplateObject(lockDb));
  redisTemplateMap.put(ebikeNoDb,redisTemplateObject(ebikeNoDb));
  redisTemplateMap.put(bikeNoDb,redisTemplateObject(bikeNoDb));
  log.info("###### END 初始化 Redis 连接池 END ######");
 }

 public RedisTemplate redisTemplateObject(Integer dbIndex) throws Exception {
  RedisTemplate redisTemplateObject = new RedisTemplate();
  redisTemplateObject.setConnectionFactory(redisConnectionFactory(jedisPoolConfig(),dbIndex));
  setSerializer(redisTemplateObject);
  redisTemplateObject.afterPropertiesSet();
  return redisTemplateObject;
 }

 /**
  * 连接池配置信息
  * @return
  */
 public JedisPoolConfig jedisPoolConfig() {
  JedisPoolConfig poolConfig=new JedisPoolConfig();
  //最大连接数
  poolConfig.setMaxIdle(maxIdl);
  //最小空闲连接数
  poolConfig.setMinIdle(minIdl);
  poolConfig.setTestOnBorrow(true);
  poolConfig.setTestOnReturn(true);
  poolConfig.setTestWhileIdle(true);
  poolConfig.setNumTestsPerEvictionRun(10);
  poolConfig.setTimeBetweenEvictionRunsMillis(60000);
  //当池内没有可用的连接时，最大等待时间
  poolConfig.setMaxWaitMillis(10000);
  //------其他属性根据需要自行添加-------------
  return poolConfig;
 }
 /**
  * jedis连接工厂
  * @param jedisPoolConfig
  * @return
  */
 public RedisConnectionFactory redisConnectionFactory(JedisPoolConfig jedisPoolConfig,int db) {
  //单机版jedis
  RedisStandaloneConfiguration redisStandaloneConfiguration =
    new RedisStandaloneConfiguration();
  //设置redis服务器的host或者ip地址
  redisStandaloneConfiguration.setHostName(hostName);
  //设置默认使用的数据库
  redisStandaloneConfiguration.setDatabase(db);
  //设置密码
  redisStandaloneConfiguration.setPassword(RedisPassword.of(passWord));
  //设置redis的服务的端口号
  redisStandaloneConfiguration.setPort(port);
  //获得默认的连接池构造器(怎么设计的，为什么不抽象出单独类，供用户使用呢)
  JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jpcb =
    (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder)JedisClientConfiguration.builder();
  //指定jedisPoolConifig来修改默认的连接池构造器（真麻烦，滥用设计模式！）
  jpcb.poolConfig(jedisPoolConfig);
  //通过构造器来构造jedis客户端配置
  JedisClientConfiguration jedisClientConfiguration = jpcb.build();
  //单机配置 + 客户端配置 = jedis连接工厂
  return new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration);
 }

 private void setSerializer(RedisTemplate template) {
  Jackson2JsonRedisSerializer