springboot 一个redis数据源 操作多个库

 pom引入包

        <!-- redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.9.0</version>
        </dependency>

配置数据源

redis:
    database: 21
    database2: 22
    host: 111.113.6.6
    port: 6379
    password: 1111111
    timeout: 3000 #连接超时
    lettuce:
      pool:
        max-wait: 30000 #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-active: 100 #连接池最大连接数（使用负值表示没有限制）
        max-idle: 20 #连接池中的最大空闲连接
        min-idle: 0 #连接池中的最小空闲连接

配置文件

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
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.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

/**
 * redis配置类
 * @Author: www
 */
@Configuration
public class RedisConfig{

    @Value("${spring.redis.database}")
    private int database;

    @Value("${spring.redis.database2}")
    private int database2;

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

    @Value("${spring.redis.password}")
    private String password;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.timeout}")
    private long timeout;

    @Value("${spring.redis.lettuce.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.lettuce.pool.min-idle}")
    private int minIdle;

    @Value("${spring.redis.lettuce.pool.max-active}")
    private int maxActive;

    @Value("${spring.redis.lettuce.pool.max-wait}")
    private long maxWait;

    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);

    public GenericObjectPoolConfig getGenericObjectPoolConfig(){
        GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
        genericObjectPoolConfig.setMaxIdle(maxIdle);
        genericObjectPoolConfig.setMinIdle(minIdle);
        genericObjectPoolConfig.setMaxTotal(maxActive);
        genericObjectPoolConfig.setMaxWaitMillis(maxWait);
        genericObjectPoolConfig.setTimeBetweenEvictionRunsMillis(1000);
        return genericObjectPoolConfig;
    }
//------------------------数据库1
    public RedisStandaloneConfiguration productEvn(){
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setDatabase(database);
        redisStandaloneConfiguration.setHostName(host);
        redisStandaloneConfiguration.setPort(port);
        redisStandaloneConfiguration.setPassword(RedisPassword.of(password));

        return redisStandaloneConfiguration;
    }
//------------------------数据库2
    public RedisStandaloneConfiguration previewEvn(){
        RedisStandaloneConfiguration redisStandaloneConfiguration2 = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration2.setDatabase(database2);
        redisStandaloneConfiguration2.setHostName(host);
        redisStandaloneConfiguration2.setPort(port);
        redisStandaloneConfiguration2.setPassword(RedisPassword.of(password));

        return redisStandaloneConfiguration2;
    }


    public LettuceConnectionFactory createFactory(RedisStandaloneConfiguration redisStandaloneConfiguration) {

        LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                .commandTimeout(Duration.ofMillis(timeout))
                .poolConfig(getGenericObjectPoolConfig())
                .build();

        LettuceConnectionFactory factory = new LettuceConnectionFactory(redisStandaloneConfiguration, clientConfig);
        factory.afterPropertiesSet();
        return factory;
    }

    public RedisTemplate<String, Object> createRedisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        //使用Jackson2JsonRedisSerializer替换默认的JdkSerializationRedisSerializer来序列化和反序列化redis的value值
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        jackson2JsonRedisSerializer.setObjectMapper(mapper);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;

    }


    @Bean("redisTemplateProduct")
    public RedisTemplate<String, Object> redisTemplateProduct() {

        return createRedisTemplate(createFactory(productEvn()));
    }
    @Bean("redisTemplatePreview")
    public RedisTemplate<String, Object> redisTemplatePreview() {
        return createRedisTemplate(createFactory(previewEvn()));
    }
}

应该时引入tempale

@Component
public class RedisConstant {

    @Autowired
    @Qualifier("redisTemplateProduct")
    private RedisTemplate redisTemplateProduct;

    @Autowired
    @Qualifier("redisTemplatePreview")
    private RedisTemplate redisTemplatePreview;
   

    //    删除key[库1]
    public BaseRes delete(String key){
        Boolean flag =  redisTemplateProduct.delete(key);

        if(flag == true){
            return  success();
        }else {
            return  error("500","redis key值"+key +"删除失败");
        }
    }

    //    删除key[库2]
    public BaseRes deleteReview(String key){
        Boolean flag =  redisTemplatePreview.delete(key);

        if(flag == true){
            return success();
        }else {
            return error("500","redis key值"+key +"删除失败");
        }
    }
}