SpringBoot实战之16 整合redis哨兵

迈不过友情╰ 2022-05-18 04:15 266阅读 0赞

# 前言 #

对springboot整合redis感兴趣的可以参考此篇博客 [SpringBoot实战之13 整合redis][SpringBoot_13 _redis]

对spring整合redis感兴趣的参考这里 [spring实战3 spring整合单例redis][spring_3 spring_redis]

spring整合哨兵参考这里 [spring实战4 spring整合redis哨兵][spring_4 spring_redis]

本篇介绍springboot整合哨兵模式

# 开始 #

## 建项目 ##

新建springboot-redis-sentinel项目

## 添加maven依赖 ##

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>
    <dependency>
        <groupId>com.hsy.java</groupId>
        <artifactId>java-util</artifactId>
    </dependency>

## 配置文件 ##

新建redis.properties redis配置文件

#Matser的ip地址
    redis.host=172.16.191.102
    #端口号
    redis.port=6379
    #如果有密码
    redis.password=123456
    # 数据库索引
    redis.database=0
    #客户端超时时间单位是毫秒 默认是2000
    redis.timeout=10000  
    
    #最大空闲数
    redis.pool.maxIdle=300  
    #连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用redis.maxTotal
    #redis.pool.maxActive=600
    #控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性
    redis.pool.maxTotal=1000  
    #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
    redis.pool.maxWaitMillis=1000  
    #连接的最小空闲时间 默认1800000毫秒(30分钟)
    redis.pool.minEvictableIdleTimeMillis=300000  
    #每次释放连接的最大数目,默认3
    redis.pool.numTestsPerEvictionRun=1024  
    #逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
    redis.pool.timeBetweenEvictionRunsMillis=30000  
    #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
    redis.pool.testOnBorrow=true  
    #在空闲时检查有效性, 默认false
    redis.pool.testWhileIdle=true  
    
    #redis集群配置
    # spring.redis.spool.cluster.nodes=192.168.177.128:7001,192.168.177.128:7002,192.168.177.128:7003,192.168.177.128:7004,192.168.177.128:7005,192.168.177.128:7006
    # spring.redis.pool.cluster.max-redirects=3
    
    #哨兵模式
    redis.sentinel.master.name=mymaster
    redis.sentinel.host1=172.16.191.102
    redis.sentinel.port1=26379
    redis.sentinel.host2=172.16.191.102
    redis.sentinel.port2=26380
    redis.sentinel.host3=172.16.191.102
    redis.sentinel.port3=26381

新建application.yml

spring:
      redis:
        sentinel:
          master: mymaster
          nodes: 172.16.191.102:26379,172.16.191.102:26380,172.16.191.102:26381
    server:
      port: 10003

## redis配置及序列化方式 ##

@Configuration
    @PropertySource("classpath:config/redis.properties")
    public class RedisConfig2 { 
        @Value("${redis.host}")
        private String host;
        @Value("${redis.port}")
        private Integer port;
        @Value("${redis.password}")
        private String password;
        @Value("${redis.database}")
        private Integer database;
        @Value("${redis.timeout}")
        private Integer timeout;
    
        @Value("${redis.pool.maxIdle}")
        private Integer maxIdle;
    
        @Value("${redis.pool.maxTotal}")
        private Integer maxTotal;
    
        @Value("${redis.pool.maxWaitMillis}")
        private Integer maxWaitMillis;
    
        @Value("${redis.pool.minEvictableIdleTimeMillis}")
        private Integer minEvictableIdleTimeMillis;
    
        @Value("${redis.pool.numTestsPerEvictionRun}")
        private Integer numTestsPerEvictionRun;
    
        @Value("${redis.pool.timeBetweenEvictionRunsMillis}")
        private long timeBetweenEvictionRunsMillis;
    
        @Value("${redis.pool.testOnBorrow}")
        private boolean testOnBorrow;
    
        @Value("${redis.pool.testWhileIdle}")
        private boolean testWhileIdle;
    
        /** * JedisPoolConfig 连接池 * @return */
        @Bean
        public JedisPoolConfig jedisPoolConfig() {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            // 最大空闲数
            jedisPoolConfig.setMaxIdle(maxIdle);
            // 连接池的最大数据库连接数
            jedisPoolConfig.setMaxTotal(maxTotal);
            // 最大建立连接等待时间
            jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
            // 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
            jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
            // 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
            jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
            // 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
            jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
            // 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
            jedisPoolConfig.setTestOnBorrow(testOnBorrow);
            // 在空闲时检查有效性, 默认false
            jedisPoolConfig.setTestWhileIdle(testWhileIdle);
            return jedisPoolConfig;
        }
        /** * 单机版配置 * @Title: JedisConnectionFactory * @param @param jedisPoolConfig * @param @return * @return JedisConnectionFactory * @autor lpl * @date 2018年2月24日 * @throws */
        @Bean
        public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig jedisPoolConfig){
            JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig);
            jedisConnectionFactory.setUsePool(true);
            //连接池
            jedisConnectionFactory.setPoolConfig(jedisPoolConfig);
            //IP地址
            jedisConnectionFactory.setHostName(host);
            //端口号
            jedisConnectionFactory.setPort(port);
            //如果Redis设置有密码
            jedisConnectionFactory.setPassword(password);
            // 设置数据库索引号
            jedisConnectionFactory.setDatabase(database);
            //客户端超时时间单位是毫秒
            jedisConnectionFactory.setTimeout(timeout);
            return jedisConnectionFactory;
        }
    
        /** * 实例化 RedisTemplate 对象 * * @return */
        @Bean
        public RedisTemplate<String, Object> functionDomainRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
            return redisTemplate;
        }
        /** * 设置数据存入 redis 的序列化方式,并开启事务 * * @param redisTemplate * @param factory */
        private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
            //如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    
            // GenericJackson2JsonRedisSerializer序列化方式
            //redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
            //redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    
            // Jackson2JsonRedisSerializer序列化方式
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    
            jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
            //set value serializer
            redisTemplate.setDefaultSerializer(jackson2JsonRedisSerializer);
            // 开启事务
            redisTemplate.setEnableTransactionSupport(true);
            redisTemplate.setConnectionFactory(factory);
            redisTemplate.afterPropertiesSet();
        }
    }

## 增删改查 ##

编写crud文件，由于我封装了redis得增删改查，此处仅需要简单的继承即可

@Repository(value = "redisRepository")
    public class RedisRepository extends AbstractSpringRedisCacheEnhance { 
    
        @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
        @Autowired
        RedisTemplate<String, Object> redisTemplate;
    
        @Override
        public StringRedisTemplate getStringRedisTemplate() {
            return null;
        }
    
        @Override
        public RedisTemplate<String, Object> getRedisTemplate() {
            return redisTemplate;
        }
    }

至此，springboot集成redis哨兵模式已经完成。

# 总结 #

springboot集成redis哨兵，我也没有找到更全面的资料，上述整合方式也是我摸索而出，

反正效果已经有了，至于其理论仍需要后续研究更新此博客。

# 源码 #

[springboot-redis-sentinel][]

[SpringBoot_13 _redis]: https://blog.csdn.net/u012806787/article/details/81223535
[spring_3 spring_redis]: https://blog.csdn.net/u012806787/article/details/81207779
[spring_4 spring_redis]: https://blog.csdn.net/u012806787/article/details/81236982
[springboot-redis-sentinel]: https://github.com/shiyuan2he/springboot/tree/master/springboot-redis-sentinel