SpringBoot配置redis多数据库以及设置session存储到redis

点我直达转载这里

创建一个springboot项目
application.yml文件这样配置

server:
port: 8888
spring:
data:
redis:
database: 0 #session存储默认数据库
database-db: #多数据库配置
db0: 0
db1: 1
db7: 7
host: 127.0.0.1
port: 6379
password: 123456
jedis:
pool:
#最大连接数
max-active: 8
#最大阻塞等待时间(负数表示没限制)
max-wait: -1
#最大空闲
max-idle: 8
#最小空闲
min-idle: 0
#连接超时时间
timeout: 10000
创建class 项目名称.config.session.SessionConfig 该配置使得session存储到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;
}
}
创建class 文件.config.redis.StringRedisCaCheConfig是的可以自定义redis数据库
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 //–启用去掉注释
public class StringRedisCaCheConfig {

//redis数据库配置信息
@Value("${spring.data.redis.database-db.db0}")
private int db0;//数据0
@Value("${spring.data.redis.database-db.db1}")
private int db1;//数据1
@Value("${spring.data.redis.database-db.db7}")
private int db7;//数据7

//基本配置信息
@Value("${spring.data.redis.host}")
private String host;//连接地址
@Value("${spring.data.redis.port}")
private int port;//连接端口
@Value("${spring.data.redis.password}")
private String password;//连接密码
@Value("${spring.data.redis.timeout}")
private long timeout;//超时时间
//==============
@Value("${spring.data.redis.jedis.pool.max-active}")
private int maxActive;//最大连接数
@Value("${spring.data.redis.jedis.pool.max-wait}")
private int maxWait;//最大阻塞等待时间
@Value("${spring.data.redis.jedis.pool.max-idle}")
private int maxIdle;//最大空闲时间
@Value("${spring.data.redis.jedis.pool.min-idle}")
private int minIdle;//最小空闲时间

@Bean(name = "redisTemplate0")//数据库配置0
public StringRedisTemplate getRedisTemplate0(){
    return getStringRedisTemplate(db0);
}
@Bean(name = "redisTemplate1")//数据库配置1
public StringRedisTemplate getRedisTemplate1(){
    return getStringRedisTemplate(db1);
}
@Bean(name = "redisTemplate7")//数据库配置7
public StringRedisTemplate getRedisTemplate7(){
    return getStringRedisTemplate(db7);
}

// 配置redis连接池
@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) {
    // 构建工厂对象
    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);
    // 设置使用的redis数据库
    factory.setDatabase(database);
    // 重新初始化工厂
    factory.afterPropertiesSet();
    return new StringRedisTemplate(factory);
}

}
下面我们使用db7数据库创建class 项目.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<String,String> 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()的意思是判断一个Boolean对象是否与Boolean.TRUE相等。
    // 如果对象的值是true，则返回true，否则返回false。这是一种比较布尔值的常见方式。
    if(exists(key)){ // 键存在才执行删除
        redisTemplate.delete(key);
    }
}

}
然后就可以使用RedisCacheDB7在其他项目里面了

需要的maven包

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