springboot项目中连接2个redis实例

阳光穿透心脏的1/2处 2023-10-11 12:04 7阅读 0赞

*  基于JDK1.8 
 *  Maven

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
                <version>2.1.5.RELEASE</version>
    </dependency>

<dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.1.0-m4</version>
    </dependency>

配置文件application.properties

############### Redis配置 start###############
    #业务数据redis配置
    spring.redis.jedis.pool.max-active=50
    spring.redis.jedis.pool.max-wait=15
    spring.redis.jedis.pool.max-idle=50
    spring.redis.jedis.pool.min-idle=0
    spring.redis.timeout=15
    spring.redis.database=1
    #spring.redis.host=192.169.1.71
    #spring.redis.port=6379
    spring.redis.password=123456
    #如果是集群，不需要配置host和port,请配置cluster
    spring.redis.cluster.nodes=192.169.1.71:7001,192.169.1.71:7002,192.169.1.71:7003,192.169.1.71:7004,192.169.1.71:7005,192.169.1.71:7006
    spring.redis.cluster.max-redirects=3
    #缓存数据redis配置
    spring.redis2.jedis.pool.max-active=50
    spring.redis2.jedis.pool.max-wait=5
    spring.redis2.jedis.pool.max-idle=50
    spring.redis2.jedis.pool.min-idle=0
    spring.redis2.timeout=5
    spring.redis2.database=1
    spring.redis2.host=192.169.1.71
    spring.redis2.port=6379
    spring.redis2.password=123456
    #如果是集群，不需要配置host和port,请配置cluster
    #spring.redis2.cluster.nodes=192.169.1.71:7001,192.169.1.71:7002,192.169.1.71:7003,192.169.1.71:7004,192.169.1.71:7005,192.169.1.71:7006
    #spring.redis2.cluster.max-redirects=3
    ################ Redis配置 end###############

可以看到上面有两个redis。 一个是存业务数据的redis称之为redis1，一个是存缓存数据的redis称之为redis2

要连接两个redis实例需要重写两个RedisConnectionFactory

**redis1**

RedisConfig.java （配置类，自定义工厂RedisConnectionFactory，创建RedisTemplate）

package com.montnets.email.middleware.redis;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.montnets.email.specmailgate.util.StrUtil;
    import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.env.MapPropertySource;
    import org.springframework.data.redis.connection.RedisClusterConfiguration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    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 org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
    import org.springframework.stereotype.Component;
    
    import java.time.Duration;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * redis 配置类
     * @author  Void
     * @date 2019/5/25 11:34
     * @description：RedisConnectionFactory、RedisTemplate会自动装配
     * @version v2.0.0
     * @see {
         @link org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration}
     */
    @Configuration
    @EnableCaching
    @Component
    public class RedisConfig {
    
        //最大活跃数
        @Value("${spring.redis.jedis.pool.max-active:8}")
        private int maxActive;
    
        //最大等待数
        @Value("${spring.redis.jedis.pool.max-wait:-1}")
        private int maxWait;
    
        //最大核心线程数
        @Value("${spring.redis.jedis.pool.max-idle:8}")
        private int maxIdle;
    
        //最小核心线程数
        @Value("${spring.redis.jedis.pool.min-idle:0}")
        private int minIdle;
    
        //redis连接的超时时长
        @Value("${spring.redis.timeout:5}")
        private int timeOut;
    
        //redis连接的库
        @Value("${spring.redis.database:0}")
        private int database;
        //节点配置
        @Value("${spring.redis.cluster.nodes:#{null}}")
        private String nodes;
    
        //最大连接转移数
        @Value("${spring.redis.cluster.max-redirects:3}")
        private int maxRedirects;
    
        //单节点情况下redis的ip
        @Value("${spring.redis.host:#{null}}")
        private String host;
    
        //单节点情况下redis的端口
        @Value("${spring.redis.port:#{null}}")
        private Integer port;
    
        //redis的连接密码
        @Value("${spring.redis.password:#{null}}")
        private String password;
    
        /**
         * 创建redisTemplate
         * 所有序列化k/v都会默认使用{
         @link org.springframework.data.redis.serializer.JdkSerializationRedisSerializer}
         * 默认的序列化类用使用byte数组进行存储， 在使用redis可视化客户端看到都是乱码不直观
         * 使用StringRedisSerializer序列化Key，  Jackson2JsonRedisSerializer序列化值， 可以观察到对象结构层次
         * 
         * 
         * @return
         */
        @Bean
        @Qualifier("redisTemplate")
        public RedisTemplate<String, Object> redisTemplate() {
            Jackson2JsonRedisSerializer<Object> valueSerializer = jackson2JsonRedisSerializer();
            StringRedisSerializer keySerializer = new StringRedisSerializer();
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(connectionFactory());
            redisTemplate.setKeySerializer(keySerializer);
            redisTemplate.setValueSerializer(valueSerializer);
            redisTemplate.setHashKeySerializer(keySerializer);
            redisTemplate.setHashValueSerializer(valueSerializer);
            return redisTemplate;
        }
    
        /**
         * 定义序列化类
         *
         * @return
         */
        public Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer() {
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
            ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().build();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
            return jackson2JsonRedisSerializer;
        }
    
        /**
         * 连接配置
         * @return
         */
        @Bean
        public RedisConnectionFactory connectionFactory() {
            Map<String, Object> source = new HashMap<String, Object>();
            RedisClusterConfiguration redisClusterConfiguration;
            RedisStandaloneConfiguration redisStandaloneConfiguration;
            //连接池配置
            GenericObjectPoolConfig genericObjectPoolConfig =
                    new GenericObjectPoolConfig();
            genericObjectPoolConfig.setMaxTotal(maxActive);
            genericObjectPoolConfig.setMaxWaitMillis(maxWait);
            genericObjectPoolConfig.setMaxIdle(maxIdle);
            genericObjectPoolConfig.setMinIdle(minIdle);
    
            //redis客户端配置
            LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder
                    builder =  LettucePoolingClientConfiguration.builder().
                    commandTimeout(Duration.ofSeconds(timeOut));
            builder.poolConfig(genericObjectPoolConfig);
            LettuceClientConfiguration lettuceClientConfiguration = builder.build();
    
            //集群模式
            if(nodes !=null){
                source.put("spring.redis.cluster.nodes", nodes);
                source.put("spring.redis.cluster.max-redirects", maxRedirects);
                redisClusterConfiguration = new RedisClusterConfiguration(new MapPropertySource("RedisClusterConfiguration", source));
                if(!StrUtil.isEmpty(password)){
                    redisClusterConfiguration.setPassword(password);
                }
                //根据配置和客户端配置创建连接
                LettuceConnectionFactory lettuceConnectionFactory = new
                        LettuceConnectionFactory(redisClusterConfiguration,lettuceClientConfiguration);
    //            lettuceConnectionFactory .afterPropertiesSet();
                return lettuceConnectionFactory;
            }else{
                //单机模式
                redisStandaloneConfiguration = new RedisStandaloneConfiguration(host,port);
                redisStandaloneConfiguration.setDatabase(database);
                if(!StrUtil.isEmpty(password)){
                    redisStandaloneConfiguration.setPassword(password);
                }
                //根据配置和客户端配置创建连接工厂
                LettuceConnectionFactory lettuceConnectionFactory = new
                        LettuceConnectionFactory(redisStandaloneConfiguration,lettuceClientConfiguration);
    //            lettuceConnectionFactory .afterPropertiesSet();
                return lettuceConnectionFactory;
    
            }
        }
    }

RedisService.java (redis服务类，提供操作redis的方法，装配redis1的redistemplate)

package com.montnets.email.middleware.redis;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.data.redis.connection.RedisConnection;
    import org.springframework.data.redis.core.*;import org.springframework.stereotype.Component;/**
     * redis缓存调用的Java方法
     * @author chenlinyan
     * @date 2019/5/25 11:34
     * @description：RedisTemplate会自动装配
     * @version v2.0.0
     * @see {
         @link org.springframework.boot.autoconfigure.data.redis}
     */
    @Slf4j
    @Component
    public class RedisService {
    
        @Autowired
        @Qualifier("redisTemplate")
        private RedisTemplate redisTemplate;
    
       /**
         * 写入redis缓存
         * @param key 键
         * @param value value
         * @return
         */
        public boolean set(final String key, Object value) {
            boolean result = false;
            try {
                ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
                operations.set(key, value);
                result = true;
            } catch (Exception e) {
                log.error("set key value error", e);
            }
            return result;
        }
    
    　　/**
         * 删除指定key
         * @param key
         * @return
         */
        public boolean delete(String key){
            return redisTemplate.delete(key);
        }
    
    }

**redis2**

Redis2Config.java （配置类，自定义工厂RedisConnectionFactory，创建RedisTemplate）

package com.montnets.email.middleware.redis;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.montnets.email.specmailgate.util.StrUtil;
    import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Primary;
    import org.springframework.core.env.MapPropertySource;
    import org.springframework.data.redis.connection.RedisClusterConfiguration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    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 org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
    import org.springframework.stereotype.Component;
    
    import java.time.Duration;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @author ：Void
     * @date ：2019-09-17 09:21
     * @description：另一个redis的配置
     * @version: v1.0.0.23
     */
    
    @Component
    @Configuration
    @EnableCaching
    public class Redis2Config {
    
        //最大活跃数
        @Value("${spring.redis2.jedis.pool.max-active:8}")
        private int maxActive;
    
        //最大等待数
        @Value("${spring.redis2.jedis.pool.max-wait:-1}")
        private int maxWait;
    
        //最大核心线程数
        @Value("${spring.redis2.jedis.pool.max-idle:8}")
        private int maxIdle;
    
        //最小核心线程数
        @Value("${spring.redis2.jedis.pool.min-idle:0}")
        private int minIdle;
    
        //redis连接的超时时长
        @Value("${spring.redis2.timeout:5}")
        private int timeOut;
    
        //redis连接的库
        @Value("${spring.redis2.database:0}")
        private int database;
        //节点配置
        @Value("${spring.redis2.cluster.nodes:#{null}}")
        private String nodes;
    
        //最大连接转移数
        @Value("${spring.redis2.cluster.max-redirects:3}")
        private int maxRedirects;
    
        //单节点情况下redis的ip
        @Value("${spring.redis2.host:#{null}}")
        private String host;
    
        //单节点情况下redis的端口
        @Value("${spring.redis2.port:#{null}}")
        private Integer port;
    
        //redis的连接密码
        @Value("${spring.redis2.password:#{null}}")
        private String password;
    
        /**
         * 创建redisTemplate连接模板
         *
         * @return
         */ @Primary
        @Bean
        @Qualifier("redisTemplate2")
        public RedisTemplate<String, Object> redisTemplate2() {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(connectionFactory2());
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setValueSerializer(this.jackson2JsonRedisSerializer2());
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashValueSerializer(this.jackson2JsonRedisSerializer2());
            return redisTemplate;
        }
    
        /**
         * k-v的序列化
         *
         * @return
         */
        @Bean
        public Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer2() {
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
            ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().build();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
            return jackson2JsonRedisSerializer;
        }
    
        /**
         * 连接配置
         *
         * @return
         */ @Primary
        @Bean
        public RedisConnectionFactory connectionFactory2() {
            Map<String, Object> source = new HashMap<String, Object>();
            RedisClusterConfiguration redisClusterConfiguration;
            RedisStandaloneConfiguration redisStandaloneConfiguration;
            //连接池配置
            GenericObjectPoolConfig genericObjectPoolConfig =
                    new GenericObjectPoolConfig();
            genericObjectPoolConfig.setMaxTotal(maxActive);
            genericObjectPoolConfig.setMaxWaitMillis(maxWait);
            genericObjectPoolConfig.setMaxIdle(maxIdle);
            genericObjectPoolConfig.setMinIdle(minIdle);
    
            //redis客户端配置
            LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder
                    builder =  LettucePoolingClientConfiguration.builder().
                    commandTimeout(Duration.ofSeconds(timeOut));
            builder.poolConfig(genericObjectPoolConfig);
            LettuceClientConfiguration lettuceClientConfiguration = builder.build();
    
            //集群模式
            if(nodes !=null){
                source.put("spring.redis.cluster.nodes", nodes);
                source.put("spring.redis.cluster.max-redirects", maxRedirects);
                redisClusterConfiguration = new RedisClusterConfiguration(new MapPropertySource("RedisClusterConfiguration", source));
                if(!StrUtil.isEmpty(password)){
                    redisClusterConfiguration.setPassword(password);
                }
                //根据配置和客户端配置创建连接工厂
                LettuceConnectionFactory lettuceConnectionFactory = new
                        LettuceConnectionFactory(redisClusterConfiguration,lettuceClientConfiguration);
    //            lettuceConnectionFactory .afterPropertiesSet();
                return lettuceConnectionFactory;
            }else{
                //单机模式
                redisStandaloneConfiguration = new RedisStandaloneConfiguration(host,port);
                redisStandaloneConfiguration.setDatabase(database);
                if(!StrUtil.isEmpty(password)){
                    redisStandaloneConfiguration.setPassword(password);
                }
                //根据配置和客户端配置创建连接
                LettuceConnectionFactory lettuceConnectionFactory = new
                        LettuceConnectionFactory(redisStandaloneConfiguration,lettuceClientConfiguration);
    //            lettuceConnectionFactory .afterPropertiesSet();
                return lettuceConnectionFactory;
    
            }
        }
    
    }

Redis2Service.java (redis服务类，提供操作redis的方法，装配redis1的redistemplate)

package com.montnets.email.middleware.redis;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.data.redis.connection.RedisConnection;
    import org.springframework.data.redis.core.*;
    import org.springframework.stereotype.Component;
    
    /**
     * redis缓存调用的Java方法
     * @author chenlinyan
     * @date 2019/5/25 11:34
     * @description：RedisTemplate会自动装配
     * @version v2.0.0
     * @see {
         @link org.springframework.boot.autoconfigure.data.redis}
     */
    @Slf4j
    @Component
    public class Redis2Service {
    
        @Autowired
        @Qualifier("redisTemplate2")
        private RedisTemplate redisTemplate;
    
    
        /**
         * 写入redis缓存
         * @param key 键
         * @param value value
         * @return
         */
        public boolean set(final String key, Object value) {
            boolean result = false;
            try {
                ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
                operations.set(key, value);
                result = true;
            } catch (Exception e) {
                log.error("set key value error", e);
            }
            return result;
        }
        /**
         * 删除指定key
         * @param key
         * @return
         */
        public boolean delete(String key){
            return redisTemplate.delete(key);
        }
    
    }

**测试类**

package com.montnets.test;
    
    import com.montnets.email.MailgateApplication;
    import com.montnets.email.middleware.redis.Redis2Service;
    import com.montnets.email.middleware.redis.RedisService;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import javax.annotation.Resource;
    
    /**
     * @author chenlinyan
     * @date 2019/6/17 10:35
     * @version v2.0.0
     */
    @RunWith(SpringRunner.class)
    @SpringBootTest(classes = MailgateApplication.class)
    public class AppTest {
    
    
        @Resource
        private RedisService redisService;
    
        @Resource
        private Redis2Service redis2Service;
    
        @Test
        public void testSave() {
             //存数据到redis1中
             redisService.set("redis1","1111");
            //存数据到redis2中
            redis2Service.set("redis2","2222");
        }
    
    }

参考地址

LettuceConnectionFactory多配置，及配置原理详解 [https://blog.csdn.net/qq\_42394457/article/details/94493027][https_blog.csdn.net_qq_42394457_article_details_94493027]

Spring boot配置多个Redis数据源操作实例 [https://www.jianshu.com/p/c79b65b253fa][https_www.jianshu.com_p_c79b65b253fa]

转载于:https://www.cnblogs.com/kiko2014551511/p/11544729.html

[https_blog.csdn.net_qq_42394457_article_details_94493027]: https://blog.csdn.net/qq_42394457/article/details/94493027
[https_www.jianshu.com_p_c79b65b253fa]: https://www.jianshu.com/p/c79b65b253fa