tencent cloud

tencent.redis.host=XX.XX.XX.XX
tencent.redis.port=6379
tencent.redis.database=0
tencent.redis.password=XXXX
tencent.redis.connect.timeout=3000
tencent.redis.read.timeout=2000
tencent.redis.pool.minSize=50
tencent.redis.pool.maxSize=200

tencent:
  redis:
    host: XX.XX.XX.XX
    port: 6379
    database: 0
    password: XXXX
    connect:
      timeout: 3000
    read:
      timeout: 2000
    pool:
      minSize: 50
      maxSize: 200

<!-- Introduce the spring-data-redis component. -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <!--After Spring Boot 2.0, the default client is Lettuce. When using Jedis, it is necessary to exclude the package.-->
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!-- Introduce the Jedis dependency package. -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>5.1.2</version>
</dependency>

import java.time.Duration;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;

import redis.clients.jedis.JedisPoolConfig;

@Configuration
public class JedisConfig {

    @Value("${tencent.redis.host}")
    private String redisHost;

    @Value("${tencent.redis.port:6379}")
    private Integer redisPort = 6379;

    @Value("${tencent.redis.database:0}")
    private Integer redisDatabase = 0;

    @Value("${tencent.redis.password:}")
    private String redisPassword;

    @Value("${tencent.redis.connect.timeout:3000}")
    private Integer redisConnectTimeout = 3000;

    @Value("${tencent.redis.read.timeout:2000}")
    private Integer redisReadTimeout = 2000;

    @Value("${tencent.redis.pool.minSize:50}")
    private Integer redisPoolMinSize = 50;

    @Value("${tencent.redis.pool.maxSize:200}")
    private Integer redisPoolMaxSize = 200;

    @Bean
    public RedisConnectionFactory redisConnectionFactory(JedisClientConfiguration clientConfiguration) {

        RedisStandaloneConfiguration standaloneConfiguration = new RedisStandaloneConfiguration();
        standaloneConfiguration.setHostName(redisHost);
        standaloneConfiguration.setPort(redisPort);
        standaloneConfiguration.setDatabase(redisDatabase);
        standaloneConfiguration.setPassword(redisPassword);

        return new JedisConnectionFactory(standaloneConfiguration, clientConfiguration);
    }

    @Bean
    public JedisClientConfiguration clientConfiguration() {

        JedisClientConfiguration clientConfiguration = JedisClientConfiguration.builder()
                .connectTimeout(Duration.ofMillis(redisConnectTimeout))
                .readTimeout(Duration.ofMillis(redisReadTimeout))
                .usePooling().poolConfig(redisPoolConfig())
                .build();

        return clientConfiguration;
    }

    private JedisPoolConfig redisPoolConfig() {

        JedisPoolConfig poolConfig = new JedisPoolConfig();
        //The minimum number of connections in the connection pool.
        poolConfig.setMinIdle(redisPoolMinSize);
        //The maximum number of idle connections in the connection pool.
        poolConfig.setMaxIdle(redisPoolMaxSize);
        //The maximum number of connections in the connection pool.
        poolConfig.setMaxTotal(redisPoolMaxSize);
        //Validate effectiveness (ping) when creating a connection. The default value is false.
        poolConfig.setTestOnCreate(false);
        //Validate effectiveness (ping) when obtaining a connection. The default value is false. It is recommended to set it to false during high business volume to reduce overhead.
        poolConfig.setTestOnBorrow(true);
        //Validate effectiveness (ping) when returning a connection. The default value is false. It is recommended to set it to false during high business volume to reduce overhead.
        poolConfig.setTestOnReturn(false);
        //Disable LIFO, and change the LIFO configuration to FIFO to ensure a fair connection establishment order.
        poolConfig.setLifo(false);
        return poolConfig;
    }
}