快捷導(dǎo)航

解決使用redisTemplate高并發(fā)下連接池滿的問題

更新時間：2020年12月03日 10:47:28 作者：yulio1234

這篇文章主要介紹了解決使用redisTemplate高并發(fā)下連接池滿的問題，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧

用JMeter進(jìn)行高并發(fā)測試的時候，發(fā)現(xiàn)報(bào)錯：

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，是因?yàn)檫B接池不夠用了

我用的是redisTemplate來操作redis，而redisTemplate并不會自動釋放連接

有一個方法，就是加大最大連接數(shù)，但是治標(biāo)不治本，加到redis.maxIdle=1000了，看似夠大了，但連接數(shù)一直在增加，遲早會崩

找了很久，最后發(fā)現(xiàn) 這個方法可用

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

在catch-finally中加上，手動斷開連接，現(xiàn)在就不會報(bào)錯了

RedisConnectionUtils.unbindConnection(redisTemplate.getConnectionFactory());

現(xiàn)在設(shè)置最大連接數(shù)redis.maxIdle=100也沒事了

在redis-cli中輸入 info clients 現(xiàn)在的連接數(shù)大概在二三十左右

補(bǔ)充知識：Redis 配置連接池，redisTemplate 操作多個db數(shù)據(jù)庫，切換多個db，解決JedisConnectionFactory的設(shè)置連接方法過時問題。

環(huán)境

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
//#當(dāng)前位置信息 DB
currentLocationDb = 14
//#鎖車/解鎖 DB
lockDb = 13
//#根據(jù)車牌獲取電子車牌 DB
ebikeNoDb = 12
//#根據(jù)電子車牌獲取車牌 DB
bikeNoDb = 11

pom.xml依賴

 <properties>
 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 <spring.version>5.1.2.RELEASE</spring.version>
 </properties>
 <!-- spring4 start -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context-support</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-core</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-web</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-webmvc</artifactId>
 <version>${spring.version}</version>
 </dependency>
 
<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
 <dependency>
 <groupId>redis.clients</groupId>
 <artifactId>jedis</artifactId>
 <version>2.9.3</version>
 </dependency>
 <!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-redis -->
 <dependency>
 <groupId>org.springframework.data</groupId>
 <artifactId>spring-data-redis</artifactId>
 <version>2.0.14.RELEASE</version>
 </dependency>
 <!-- fastjson -->
 <dependency>
 <groupId>com.alibaba</groupId>
 <artifactId>fastjson</artifactId>
 <version>1.2.11</version>
 </dependency>
 <!-- json-lib -->
 <!-- <dependency> <groupId>net.sf.json-lib</groupId> <artifactId>json-lib</artifactId> <version>2.4</version> <classifier>jdk15</classifier> 
 </dependency> -->
 <dependency>
 <groupId>net.sf.json-lib</groupId>
 <artifactId>json-lib</artifactId>
 <version>2.4</version>
 <classifier>jdk15</classifier>
 </dependency>

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<Integer,RedisTemplate<Serializable, Object>> 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<Serializable, Object> redisTemplateObject(Integer dbIndex) throws Exception {
  RedisTemplate<Serializable, Object> redisTemplateObject = new RedisTemplate<Serializable, Object>();
  redisTemplateObject.setConnectionFactory(redisConnectionFactory(jedisPoolConfig(),dbIndex));
  setSerializer(redisTemplateObject);
  redisTemplateObject.afterPropertiesSet();
  return redisTemplateObject;
 }

 /**
  * 連接池配置信息
  * @return
  */
 public JedisPoolConfig jedisPoolConfig() {
  JedisPoolConfig poolConfig=new JedisPoolConfig();
  //最大連接數(shù)
  poolConfig.setMaxIdle(maxIdl);
  //最小空閑連接數(shù)
  poolConfig.setMinIdle(minIdl);
  poolConfig.setTestOnBorrow(true);
  poolConfig.setTestOnReturn(true);
  poolConfig.setTestWhileIdle(true);
  poolConfig.setNumTestsPerEvictionRun(10);
  poolConfig.setTimeBetweenEvictionRunsMillis(60000);
  //當(dāng)池內(nèi)沒有可用的連接時，最大等待時間
  poolConfig.setMaxWaitMillis(10000);
  //------其他屬性根據(jù)需要自行添加-------------
  return poolConfig;
 }
 /**
  * jedis連接工廠
  * @param jedisPoolConfig
  * @return
  */
 public RedisConnectionFactory redisConnectionFactory(JedisPoolConfig jedisPoolConfig,int db) {
  //單機(jī)版jedis
  RedisStandaloneConfiguration redisStandaloneConfiguration =
    new RedisStandaloneConfiguration();
  //設(shè)置redis服務(wù)器的host或者ip地址
  redisStandaloneConfiguration.setHostName(hostName);
  //設(shè)置默認(rèn)使用的數(shù)據(jù)庫
  redisStandaloneConfiguration.setDatabase(db);
  //設(shè)置密碼
  redisStandaloneConfiguration.setPassword(RedisPassword.of(passWord));
  //設(shè)置redis的服務(wù)的端口號
  redisStandaloneConfiguration.setPort(port);
  //獲得默認(rèn)的連接池構(gòu)造器(怎么設(shè)計(jì)的，為什么不抽象出單獨(dú)類，供用戶使用呢)
  JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jpcb =
    (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder)JedisClientConfiguration.builder();
  //指定jedisPoolConifig來修改默認(rèn)的連接池構(gòu)造器（真麻煩，濫用設(shè)計(jì)模式?。?
  jpcb.poolConfig(jedisPoolConfig);
  //通過構(gòu)造器來構(gòu)造jedis客戶端配置
  JedisClientConfiguration jedisClientConfiguration = jpcb.build();
  //單機(jī)配置 + 客戶端配置 = jedis連接工廠
  return new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration);
 }

 private void setSerializer(RedisTemplate<Serializable, Object> template) {
  Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(
    Object.class);
  ObjectMapper om = new ObjectMapper();
  om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  jackson2JsonRedisSerializer.setObjectMapper(om);
  template.setKeySerializer(template.getStringSerializer());
  template.setValueSerializer(jackson2JsonRedisSerializer);
  template.setHashValueSerializer(jackson2JsonRedisSerializer);
  //在使用String的數(shù)據(jù)結(jié)構(gòu)的時候使用這個來更改序列化方式
  RedisSerializer<String> stringSerializer = new StringRedisSerializer();
  template.setKeySerializer(stringSerializer );
  template.setValueSerializer(stringSerializer );
  template.setHashKeySerializer(stringSerializer );
  template.setHashValueSerializer(stringSerializer );
 }

 /**
  * 刪除對應(yīng)的value
  * @param key
  */
 public void remove(final String key,int db) {
  RedisTemplate<Serializable, Object> redisTemplate = getRedisTemplateByDb(db);
  if (exists(key,redisTemplate)) {
   redisTemplate.delete(key);
  }
 }

 /**
  * 判斷緩存中是否有對應(yīng)的value
  * @param key
  * @return
  */
 public boolean exists(final String key,RedisTemplate<Serializable, Object> redisTemplate) {
  return redisTemplate.hasKey(key);
 }

 /**
  * 讀取緩存
  * @param key
  * @return
  */
 public Object get(final String key,int db) {
  RedisTemplate<Serializable, Object> redisTemplate = getRedisTemplateByDb(db);
  Object result = null;
  ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  result = operations.get(key);
  return result;
 }

 /**
  * 寫入緩存
  * @param key
  * @param value
  * @return
  */
 public boolean set(final String key, Object value,int db) {
  RedisTemplate<Serializable, Object> redisTemplate = getRedisTemplateByDb(db);
  boolean result = false;
  try {
   ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
   operations.set(key, value);
   result = true;
  } catch (Exception e) {
   log.error("set cache error", e);
  }
  return result;
 }

 /**
  * 根據(jù)key 獲取過期時間
  * @param key 鍵 不能為null
  * @return 返回0代表為永久有效
  */
 public long getExpire(String key,TimeUnit unit,int db) {
  RedisTemplate<Serializable, Object> redisTemplate = getRedisTemplateByDb(db);
  return redisTemplate.getExpire(key, unit);
 }
 
/**
  * 根據(jù)db 獲取對應(yīng)的redisTemplate實(shí)例
  * @param db
  * @return
  */
 public RedisTemplate<Serializable, Object> getRedisTemplateByDb(int db){
  return redisTemplateMap.get(db);
 }
}

在其他類中的使用

 @Autowired
 private RedisConfig redisUtil;
 
 //#獲取db0 數(shù)據(jù)庫的數(shù)據(jù)
 public static Integer sessionCodeDb = 0;
/**
 * 根據(jù)sessionCode獲取userId
 * @param sessionCode
 * @return
 */
 public String getUserIdBySessionCode(String sessionCode){
 try {
 Object obj = redisUtil.get(sessionCode,sessionCodeDb);
 if(obj!=null) {
 return obj.toString();
 }else{
 return null;
 }
 }catch (Exception e){
 e.printStackTrace();
 return null;
 }
 }

以上這篇解決使用redisTemplate高并發(fā)下連接池滿的問題就是小編分享給大家的全部內(nèi)容了，希望能給大家一個參考，也希望大家多多支持腳本之家。

您可能感興趣的文章: