springboot+redis 含 多个redis数据源切换实现

1、直接创建ide项目的话

maven依赖:

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>

　　

pom.yml

# 应用名称
spring:
  application:
    name: redis

#redis配置
  redis:
    host: localhost
    port: 6379
    database: 0



# 应用服务 WEB 访问端口
server:
  port: 8080

RedisConfig  配置文件

package com.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.net.UnknownHostException;

@Configuration
public class RedisConfig {
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        // 自定义 String Object
        RedisTemplate<String, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);

        // Json 序列化配置
        Jackson2JsonRedisSerializer<Object> objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        // ObjectMapper 转译
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        objectJackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key 采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash 的key也采用 String 的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value 序列化方式采用 jackson
        template.setValueSerializer(objectJackson2JsonRedisSerializer);
        // hash 的 value 采用 jackson
        template.setHashValueSerializer(objectJackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

调用使用

package com;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.HashMap;


@SpringBootTest
class RedisApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextloads(){
////        删除key
//        redisTemplate.delete("foo222");
        HashMap<String, String> Sites = new HashMap<String, String>();
// 添加键值对
        Sites.put("1", "Google");
        Sites.put("2", "Runoob");
        Sites.put("3", "Taobao");
//        Sites.put(4, "Zhihu");
        System.out.println(Sites);

        redisTemplate.opsForHash().putAll("kkk2", Sites);

    }

redisTemplate API调用方法

https://nuptkwz.github.io/blog/2019/04/10/Redis-RedisTemplate%E5%B8%B8%E7%94%A8%E6%96%B9%E6%B3%95#redis%E5%B8%B8%E7%94%A8%E7%9A%84%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B

 

一般开发时会自己写个工具类

工具类参考博客：

https://www.cnblogs.com/zeng1994/p/03303c805731afc9aa9c60dbbd32a323.html

https://www.cnblogs.com/zhzhlong/p/11434284.html

狂神的笔记

https://blog.csdn.net/DDDDeng_/article/details/108118544

 

模糊匹配key且删除

Set<String> keys = redisTemplate.keys("noteUserListenedPoi:" + "*");
            redisTemplate.delete(keys);
            LOGGER.info("{}, redis中用户收听历史被清空"

多个redis数据源实现

添加maven依赖

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-pool2</artifactId>
</dependency>

pom.yml

#  redis配置
  redis:
    database: 0
    host: 192.168.1.1
    port: 6379
    password: asdasdadphq1L
    timeout: 0  # 连接超时时间（毫秒）
    lettuce:
      pool:
        max-active: -1 # 连接池最大连接数（使用负值表示没有限制）
        max-wait: -1  # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 8  # 连接池中的最大空闲连接
        min-idle: 0  # 连接池中的最小空闲连接

#本地redis
  redis2:
    database: 0   # Redis数据库索引（默认为0）
    host: localhost # Redis服务器地址
    port: 6379  # Redis服务器连接端口
    password:    # Redis服务器连接密码（默认为空）
    timeout: 0  # 连接超时时间（毫秒）
    lettuce:
      pool:
        max-active: -1 # 连接池最大连接数（使用负值表示没有限制）
        max-wait: -1  # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 8  # 连接池中的最大空闲连接
        min-idle: 0  # 连接池中的最小空闲连接

修改配置文件RedisConfig 

package com.config.Redis;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
import org.springframework.beans.factory.annotation.Value;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
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.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.util.ObjectUtils;
import java.net.UnknownHostException;
import java.time.Duration;

@Configuration
public class RedisConfig {
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        // 自定义 String Object
        RedisTemplate<String, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);

        // Json 序列化配置
        Jackson2JsonRedisSerializer<Object> objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        // ObjectMapper 转译
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        objectJackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key 采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash 的key也采用 String 的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value 序列化方式采用 jackson
        template.setValueSerializer(objectJackson2JsonRedisSerializer);
        // hash 的 value 采用 jackson
        template.setHashValueSerializer(objectJackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;

    }

        public RedisTemplate getRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            RedisSerializer<String> stringSerializer = new StringRedisSerializer();
            redisTemplate.setKeySerializer(stringSerializer);
            redisTemplate.setHashKeySerializer(stringSerializer);
            //设置序列化接口
            ObjectMapper mapper = new ObjectMapper();
            mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
            mapper.setVisibility(PropertyAccessor.GETTER, JsonAutoDetect.Visibility.NONE);
            mapper.setVisibility(PropertyAccessor.IS_GETTER, JsonAutoDetect.Visibility.NONE);
            SimpleFilterProvider filterProvider = new SimpleFilterProvider();
            filterProvider.setDefaultFilter(SimpleBeanPropertyFilter.serializeAll());
            mapper.setFilterProvider(filterProvider);
            GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer(mapper);
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
            redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
            redisTemplate.setDefaultSerializer(jackson2JsonRedisSerializer);
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }


        @Bean("redisTemplate2")
        public RedisTemplate<String, Object> redisTemplate2(
                @Value("${spring.redis2.database}") int database,
        @Value("${spring.redis2.timeout}") long timeout,
        @Value("${spring.redis2.lettuce.pool.max-active}") int maxActive,
        @Value("${spring.redis2.lettuce.pool.max-wait}") int maxWait,
        @Value("${spring.redis2.lettuce.pool.max-idle}") int maxIdle,
        @Value("${spring.redis2.lettuce.pool.min-idle}") int minIdle,
        @Value("${spring.redis2.host}") String hostName,
        @Value("${spring.redis2.port}") int port,
        @Value("${spring.redis2.password}") String password) {
            RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
            configuration.setHostName(hostName);
            configuration.setPort(port);
            configuration.setDatabase(database);
            if (!ObjectUtils.isEmpty(password)) {
                RedisPassword redisPassword = RedisPassword.of(password);
                configuration.setPassword(redisPassword);
            }
            GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
            genericObjectPoolConfig.setMaxTotal(maxActive);
            genericObjectPoolConfig.setMinIdle(minIdle);
            genericObjectPoolConfig.setMaxIdle(maxIdle);
            genericObjectPoolConfig.setMaxWaitMillis(maxWait);
            LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder builder = LettucePoolingClientConfiguration.builder();
            builder.poolConfig(genericObjectPoolConfig);
            builder.commandTimeout(Duration.ofSeconds(timeout));
            LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(configuration, builder.build());
            connectionFactory.afterPropertiesSet();
            return getRedisTemplate(connectionFactory);
        }
    }

调用例子

@Autowired
private RedisTemplate redisTemplate;

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


@GetMapping("/get")
public Object get_User() {
    Object aa=redisTemplate.opsForValue().get("主redis");
    System.out.println(aa);
    return "{code:200,msg:操作成功}";
}

@GetMapping("/get2")
public Object get_User2() {
    Object aa=redisTemplate2.opsForValue().get("副redis");
    System.out.println(aa);
    return "{code:200,msg:操作成功}";
}

参考: https://blog.csdn.net/gao_liang0420/article/details/108603520