SpringBoot configures redis multiple databases and sets session storage to redis

Click here to reprint directly

Create a springboot project
The application.yml file is configured like this

server:
port: 8888
spring:
data:
redis:
database: 0 #session stores the default database
database-db: #Multiple database configuration
db0: 0
db1: 1
db7: 7
host: 127.0.0.1
port: 6379
password: 123456
jedis:
pool:
#Maximum number of connections
max-active: 8
#Maximum blocking waiting time (negative number means no limit)
max-wait: -1
#MaxIdle
max-idle: 8
#Minimum idle
min-idle: 0
#Connection timeout
timeout: 10000
Create class project name.config.session.SessionConfig. This configuration enables the session to be stored in redis
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.session.data.redis.config.ConfigureRedisAction;
import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;

@Configuration
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 7200, redisNamespace = “data-session”)
public class SessionConfig {
@Bean
public static ConfigureRedisAction configureRedisAction(){
return ConfigureRedisAction.NO_OP;
}
}
Create the class file .config.redis.StringRedisCaCheConfig. Yes, you can customize the redis database.
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.StringRedisTemplate;

import java.time.Duration;

@Configuration //–enable removing comments
public class StringRedisCaCheConfig {

//redis database configuration information
@Value("${spring.data.redis.database-db.db0}")
private int db0;//data 0
@Value("${spring.data.redis.database-db.db1}")
private int db1;//data 1
@Value("${spring.data.redis.database-db.db7}")
private int db7;//data 7

//Basic configuration information
@Value("${spring.data.redis.host}")
private String host; //Connection address
@Value("${spring.data.redis.port}")
private int port;//connection port
@Value("${spring.data.redis.password}")
private String password; //Connection password
@Value("${spring.data.redis.timeout}")
private long timeout;//timeout time
//==============
@Value("${spring.data.redis.jedis.pool.max-active}")
private int maxActive;//Maximum number of connections
@Value("${spring.data.redis.jedis.pool.max-wait}")
private int maxWait;//Maximum blocking waiting time
@Value("${spring.data.redis.jedis.pool.max-idle}")
private int maxIdle;//Maximum idle time
@Value("${spring.data.redis.jedis.pool.min-idle}")
private int minIdle;//Minimum idle time

@Bean(name = "redisTemplate0")//Database configuration 0
public StringRedisTemplate getRedisTemplate0(){
    return getStringRedisTemplate(db0);
}
@Bean(name = "redisTemplate1")//Database configuration 1
public StringRedisTemplate getRedisTemplate1(){
    return getStringRedisTemplate(db1);
}
@Bean(name = "redisTemplate7")//Database configuration 7
public StringRedisTemplate getRedisTemplate7(){
    return getStringRedisTemplate(db7);
}

//Configure redis connection pool
@Bean
@Primary
public GenericObjectPoolConfig<Object> getPoolConfig(){
    GenericObjectPoolConfig<Object> config = new GenericObjectPoolConfig<>();
    config.setMaxTotal(maxActive);
    config.setMaxWait(Duration.ofDays(maxWait));
    config.setMaxIdle(maxIdle);
    config.setMinIdle(minIdle);
    return config;
}

private StringRedisTemplate getStringRedisTemplate(int database) {
    //Construct factory object
    RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
    config.setHostName(host);
    config.setPort(port);
    config.setPassword(RedisPassword.of(password));
    LettucePoolingClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
            .commandTimeout(Duration.ofSeconds(timeout))
            .poolConfig(getPoolConfig())
            .build();
    LettuceConnectionFactory factory = new LettuceConnectionFactory(config, clientConfig);
    //Set the redis database used
    factory.setDatabase(database);
    // Reinitialize the factory
    factory.afterPropertiesSet();
    return new StringRedisTemplate(factory);
}

}
Next we use the db7 database to create the class project .config.redis.RedisCacheDB7
import jakarta.annotation.Resource;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;

@Component
public class RedisCacheDB7 {
@Resource(name = “redisTemplate7”)
RedisTemplate redisTemplate;

public void setCache(String key,String value,long time){
    redisTemplate.opsForValue().set(key,value,time, TimeUnit.SECONDS);
}

public void setCache(String key,String value){
    setCache(key,value,7200L);
}

public String getCache(String key){
    return redisTemplate.opsForValue().get(key);
}

public boolean exists(String key) {
    return Boolean.TRUE.equals(redisTemplate.hasKey(key));
}

public void delCache(String key){
    //Boolean.TRUE.equals() means to determine whether a Boolean object is equal to Boolean.TRUE.
    // If the value of the object is true, return true, otherwise return false. This is a common way of comparing boolean values.
    if(exists(key)){ //Delete only if the key exists
        redisTemplate.delete(key);
    }
}

}
Then you can use RedisCacheDB7 in other projects

Required maven packages

 <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
        <version>3.1.1</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-pool2 -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>2.11.1</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework.session/spring-session-data-redis -->
    <dependency>
        <groupId>org.springframework.session</groupId>
        <artifactId>spring-session-data-redis</artifactId>
        <version>3.1.1</version>
    </dependency>