spring boot redis多数据源设置

直奔主题 在其他博主的案例下改写的多数据源的设置
1、在pom.xml中添加依赖

  <dependencies>
        <!--redis 相关的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--简化java代码-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--服务注册中心的使用-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.3.0.RELEASE</version>
        </dependency>
        <!--spring boot 监控使用-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>

2、创建redis配置文件封装类

@Data
public class MultRedisProperties {
    /**
     * redis节点的配置 多个节点中介以逗号隔开  如果配置默认为单节点模式
     */
    private String nodes="127.0.0.1:6379";
    /**
     * 配置redis集群节点的名称 默认为mymaster  当enable=true时有效
     */
    private String master="mymaster";
    /**
     * true 代表使用集群模式   false  代表单节点模式
     */
    private boolean enabled= false;

}

3、redis多数据源源Configuration的编写

@Configuration
public class RedisConfiguration {

    /**
     * 解析多数源一的配置文件
     *
     * @return
     */
    @Bean(name = "db1")
    @ConfigurationProperties(prefix = "spring.redis.db1")
    public MultRedisProperties getsSoure1() {
        return new MultRedisProperties();
    }

    /**
     * 解析多数据源二的配置文件
     *
     * @return
     */
    @Bean(name = "db2")
    @ConfigurationProperties(prefix = "spring.redis.db2")
    public MultRedisProperties getsSoure2() {
        return new MultRedisProperties();
    }

    /**
     * 创建数据源1的连接池
     *
     * @param multRedisProperties
     * @return
     */
    @Bean("jedis1")
    @Primary  //设置为默认方式的连接池
    public JedisConnectionFactory connectionFactory1(@Qualifier("db1") MultRedisProperties multRedisProperties) {
        return createJedisConnectionFactory(multRedisProperties);
    }

    /**
     * 创建数据源1的连接池
     *
     * @param multRedisProperties
     * @return
     */
    @Bean("jedis2")
    public JedisConnectionFactory connectionFactory2(@Qualifier("db2") MultRedisProperties multRedisProperties) {
        return createJedisConnectionFactory(multRedisProperties);
    }

    @Bean("redisTemplate1")
    @Primary
    public RedisTemplate createRedisTemplate1(@Qualifier ("jedis1") JedisConnectionFactory jedisConnectionFactory){
        return createRedisTempalte(jedisConnectionFactory);
    }

    @Bean("redisTemplate2")
    public RedisTemplate createRedisTemplate2(@Qualifier ("jedis2") JedisConnectionFactory jedisConnectionFactory){
        return createRedisTempalte(jedisConnectionFactory);
    }

    /**
     * 创建连接池
     *
     * @param multRedisProperties
     * @return
     */
    private JedisConnectionFactory createJedisConnectionFactory(MultRedisProperties multRedisProperties) {
        Set<RedisNode> redisNodes1 = splitRedisNode(multRedisProperties.getNodes());
        if (multRedisProperties.isEnabled()) {
            //创建集群的连接池  (集群为哨兵模式的连接池)
            return createSentinelFactory(redisNodes1, multRedisProperties.getMaster());
        } else {
            return createClusterFactory(redisNodes1);
        }
    }


    /**
     * 创建集群方式的redis连接 提供给健康检查使用
     *
     * @return
     */
    private JedisConnectionFactory createSentinelFactory(Set<RedisNode> sentinelStr, String master) {
        RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration();
        redisSentinelConfiguration.setMaster(master);
        redisSentinelConfiguration.setSentinels(sentinelStr);
        return new JedisConnectionFactory(redisSentinelConfiguration, new JedisPoolConfig());
    }

    /**
     * 解析redis节点的字符串
     *
     * @param redisNodes
     * @return
     */
    private Set<RedisNode> splitRedisNode(String redisNodes) {
        Assert.notNull(redisNodes, "传进来的redis节点不能为空");
        String[] serverArray = redisNodes.split(",");
        Set<RedisNode> nodes = new HashSet<>();
        for (String ipPort : serverArray) {
            String[] ipAndPort = ipPort.split(":");
            nodes.add(new RedisNode(ipAndPort[0].trim(), Integer.valueOf(ipAndPort[1])));
        }
        return nodes;
    }

    /**
     * 创建单节点的redis连接池   提供给健康检查使用
     *
     * @param sentinelStr
     * @return
     */
    private JedisConnectionFactory createClusterFactory(Set<RedisNode> sentinelStr) {
        Iterator<RedisNode> iterator = sentinelStr.iterator();
        //单节点默认取第一个
        RedisNode next = iterator.next();
        //单节点模式
        JedisConnectionFactory factory = new JedisConnectionFactory();
        factory.setHostName(next.getHost());
        factory.setPort(next.getPort());
        return factory;
    }


    /**
     * 创建redistemplate连接池
     *
     * @param factory
     * @return
     */
    public RedisTemplate createRedisTempalte(JedisConnectionFactory factory) {
        factory.setUsePool(true);
        factory.afterPropertiesSet();
        //实例化redistemplate
        RedisTemplate redisTemplate = new RedisTemplate<>();
        //实行key和value序列化
        //SpringCache方式不需要进行String的序列化
        //Redistemplate需要进行String的序列化
        RedisSerializer<String> stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer);
        redisTemplate.setValueSerializer(stringSerializer);
        redisTemplate.setConnectionFactory(factory);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

注意：
@Primary的添加 不添加的话就会报类似如下的错误

Description:

Parameter 0 of method redisTemplate in org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration$RedisConfiguration required a single bean, but 2 were found:
	- jedis1: defined by method 'connectionFactory1' in class path resource [com/wsl/redis/config/RedisConfiguration.class]
	- jedis2: defined by method 'connectionFactory2' in class path resource [com/wsl/redis/config/RedisConfiguration.class]


Action:

Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed

4、编写配置文件

#redis多数据源配置1
spring.redis.db1.nodes=127.0.0.1:6379
#redis多数据源配置2
spring.redis.db2.nodes=127.0.0.1:6380
#服务注册中心的地址
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/
server.port=8080
spring.application.name=redisapplication
#开启健康检查
management.health.redis.enabled=true
#关闭安全认证
management.security.enabled=false

5、如何使用多数据源

@Component
public class RedisService {
    @Qualifier("redisTemplate1")
    @Autowired
    private RedisTemplate redisTemplateDb1;

    @Qualifier("redisTemplate2")
    @Autowired
    private RedisTemplate redisTemplateDb2;
    /**
     * 向redis中添加数据
     * @param key
     * @param value
     */
    public void set(Object key,Object value){
        //向redis的数据源1中添加数据
        redisTemplateDb1.opsForValue().set(key,value);
        //向redis的数据源2中添加数据
        redisTemplateDb2.opsForValue().set(key, value);
    }
}

6、编写单元测试类
右击需要测试的类 选择 Go To 在选择Test 即可创建单元测试类

在测试类上面添加注解@RunWith和@SpringBootTest 编写完成单元测试类

7、执行完成单元测试后查看结果
数据源1：

数据源2：

编写完成谢谢！
转载自
https://www.cnblogs.com/wulm/p/8446432.html