spring实战4 spring整合redis哨兵

太过爱你忘了你带给我的痛 2022-05-18 00:55 259阅读 0赞

前言

  1. 对spring整合redis单例感兴趣的朋友，请移步此处 spring实战3 spring整合单例redis
  2. 对springboot整合单例redis感兴趣的朋友，请移步此处 SpringBoot实战之13 整合redis

开始

建项目

新建spring-redis-sentinel web项目

导包

  1. <dependency>
  2.     <groupId>org.springframework</groupId>
  3.     <artifactId>spring-test</artifactId>
  4. </dependency>
  5. <dependency>
  6.     <groupId>org.springframework.data</groupId>
  7.     <artifactId>spring-data-redis</artifactId>
  8. </dependency>
  9. <dependency>
  10.     <groupId>redis.clients</groupId>
  11.     <artifactId>jedis</artifactId>
  12. </dependency>
  13. <dependency>
  14.     <groupId>com.fasterxml.jackson.core</groupId>
  15.     <artifactId>jackson-databind</artifactId>
  16. </dependency>
  17. <!--自己封装的增删改查包-->
  18. <dependency>
  19.     <groupId>com.hsy.java</groupId>
  20.     <artifactId>java-util</artifactId>
  21. </dependency>

配置文件

新建redis.properties

  1. #访问地址 redis中心
  2. redis.host=172.16.191.102
  3. # redis.host=192.168.1.106
  4. #访问端口
  5. redis.port=6379
  6. #授权密码，有没有这一项取决于要连接的redis服务是否设置了此项
  7. redis.auth=123456
  8. redis.dbIndex=0
  9. redis.timeout=100000
  11. # redis哨兵信息
  12. redis.sentinel.node1.host=172.16.191.102
  13. redis.sentinel.node1.port=26379
  14. redis.sentinel.node2.host=172.16.191.102
  15. redis.sentinel.node2.port=26380
  16. redis.sentinel.node3.host=172.16.191.102
  17. redis.sentinel.node3.port=26381
  19. redis.pool.maxTotal=200
  20. #连接池的最大数据库连接数。设为0表示无限制
  21. redis.pool.maxIdle=1024
  22. redis.pool.minIdle=8
  23. #在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
  24. redis.pool.testOnCreate=true
  25. redis.pool.testOnBorrow=true
  26. redis.pool.testOnReturn=true
  27. #Idle时进行连接扫描
  28. redis.pool.testWhileIdle=true
  30. redis.pool.maxWaitMillis=100000
  31. #表示idle object evitor两次扫描之间要sleep的毫秒数
  32. redis.pool.timeBetweenEvictionRunsMillis=30000
  33. #表示idle object evitor每次扫描的最多的对象数
  34. redis.pool.numTestsPerEvictionRun=10
  35. #表示一个对象至少停留在idle状态的最短时间，然后才能被idle object evitor扫描并驱逐；
  36. # 这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义
  37. redis.pool.minEvictableIdleTimeMillis=60000

新建spring配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd ">
  3.     <context:property-placeholder location="classpath:config/redis.properties" ignore-resource-not-found="true"/>
  4.     <!--<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>classpath:properties/redis.properties</value> </list> </property> </bean>-->
  6.     <!-- redis config start -->
  7.     <!-- 配置JedisPoolConfig实例 -->
  8.     <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
  9.         <property name="maxTotal" value="${redis.pool.maxTotal}"/>
  10.         <property name="maxIdle" value="${redis.pool.maxIdle}"/>
  11.         <property name="minIdle" value="${redis.pool.minIdle}"/>
  12.         <property name="testOnCreate" value="${redis.pool.testOnCreate}"/>
  13.         <property name="testOnBorrow" value="${redis.pool.testOnBorrow}"/>
  14.         <property name="testOnReturn" value="${redis.pool.testOnReturn}"/>
  15.         <property name="testWhileIdle" value="${redis.pool.testWhileIdle}"/>
  16.         <property name="maxWaitMillis" value="${redis.pool.maxWaitMillis}"/>
  17.         <property name="timeBetweenEvictionRunsMillis" value="${redis.pool.timeBetweenEvictionRunsMillis}"/>
  18.         <property name="numTestsPerEvictionRun" value="${redis.pool.numTestsPerEvictionRun}"/>
  19.         <property name="minEvictableIdleTimeMillis" value="${redis.pool.minEvictableIdleTimeMillis}"/>
  20.     </bean>
  22.     <!-- 配置JedisConnectionFactory -->
  23.     <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
  24.         <property name="hostName" value="${redis.host}"/>
  25.         <property name="port" value="${redis.port}"/>
  26.         <property name="password" value="${redis.auth}"/>
  27.         <property name="database" value="${redis.dbIndex}"/>
  28.         <property name="timeout" value="${redis.timeout}"/>
  29.         <property name="poolConfig" ref="poolConfig"/>
  30.     </bean>
  32.     <bean id="redisSentinelConfiguration" class="org.springframework.data.redis.connection.RedisSentinelConfiguration">
  33.         <property name="sentinels">
  34.             <set>
  35.                 <bean name="sentinelNode1" class="org.springframework.data.redis.connection.RedisNode">
  36.                     <constructor-arg name="host" value="${redis.sentinel.node1.host}"/>
  37.                     <constructor-arg name="port" value="${redis.sentinel.node1.port}"/>
  38.                 </bean>
  39.                 <bean name="sentinelNode2" class="org.springframework.data.redis.connection.RedisNode">
  40.                     <constructor-arg name="host" value="${redis.sentinel.node2.host}"/>
  41.                     <constructor-arg name="port" value="${redis.sentinel.node2.port}"/>
  42.                 </bean>
  43.                 <bean name="sentinelNode3" class="org.springframework.data.redis.connection.RedisNode">
  44.                     <constructor-arg name="host" value="${redis.sentinel.node3.host}"/>
  45.                     <constructor-arg name="port" value="${redis.sentinel.node3.port}"/>
  46.                 </bean>
  47.             </set>
  48.         </property>
  49.         <property name="master">
  50.             <bean name="masterNode" class="org.springframework.data.redis.connection.RedisNode">
  51.                 <!--必须指定主节点名称-->
  52.                 <property name="name" value="mymaster"/>
  53.                 <!-- <constructor-arg name="host" value="${redis.host}"/> <constructor-arg name="port" value="6379"/> -->
  54.             </bean>
  55.         </property>
  56.     </bean>
  58.     <!--哨兵配置方式二-->
  59.     <!-- <bean id="redisSentinelConfiguration" class="org.springframework.data.redis.connection.RedisSentinelConfiguration"> <constructor-arg name="propertySource" ref="propertySource"/> </bean> <bean name="propertySource" class="org.springframework.core.io.support.ResourcePropertySource"> <constructor-arg name="location" value="classpath:spring-redis-sentinel.properties" /> </bean> -->
  62.     <!-- 使用JDK提供的序列化功能。 优点是反序列化时不需要提供类型信息(class)，但缺点是序列化后的结果非常庞大，是JSON格式的5倍左右，这样就会消耗redis服务器的大量内存。 -->
  63.     <bean id="stringKeySerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
  64.     <!-- JdkSerializationRedisSerializer，这个序列化方法是Idk提供的， 要求要被序列化的类继承自Serializeable接口，然后通过Jdk对象序列化的方法保存， 这个序列化保存的对象，即使是个String类型的，在redis控制台，也是看不出来的， 因为它保存了一些对象的类型什么的额外信息。 -->
  65.     <bean id="jdkSerializationRedisSerializer" class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
  66.     <bean id="genericJackson2JsonRedisSerializer" class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
  67.     <!-- 使用Jackson库将对象序列化为JSON字符串。优点是速度快，序列化后的字符串短小精悍。 但缺点也非常致命，那就是此类的构造函数中有一个类型参数，必须提供要序列化对象的类型信息(.class对象)。 通过查看源代码，发现其只在反序列化过程中用到了类型信息。 -->
  68.     <!--<bean id="jackson2JsonRedisSerializer" class="org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer"> <constructor-arg type="java.lang.Object" ></constructor-arg> </bean>-->
  69.     <!-- 配置RedisTemplate -->
  70.     <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
  71.         <property name="connectionFactory" ref="jedisConnectionFactory"/>
  72.         <!-- 如果不配置Serializer，那么存储的时候只能使用String，如果用对象类型存储，那么会提示错误 can't cast to String！！！-->
  73.         <property name="keySerializer" ref="stringKeySerializer"/>
  74.         <property name="hashKeySerializer" ref="stringKeySerializer"/>
  75.         <property name="valueSerializer" ref="genericJackson2JsonRedisSerializer"/>
  76.         <property name="hashValueSerializer" ref="genericJackson2JsonRedisSerializer"/>
  77.     </bean>
  78.     <!-- 配置StringRedisTemplate 下面的各种key都是stringKeySerializer序列化方式-->
  79.     <bean id="stringRedisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
  80.         <property name="connectionFactory" ref="jedisConnectionFactory"/>
  81.     </bean>
  82.     <!-- redis config end -->
  83. </beans>

crud

新建dao层crud方法，此处引用的是个人封装好的增删改查方法，在不粘贴。

  1. @Repository(value = "redisRepository")
  2. public class RedisRepository extends AbstractSpringRedisCacheEnhance { 
  4.     @Autowired
  5.     RedisTemplate<String, Object> redisTemplate;
  7.     @Override
  8.     public StringRedisTemplate getStringRedisTemplate() {
  9.         return null;
  10.     }
  12.     @Override
  13.     public RedisTemplate<String, Object> getRedisTemplate() {
  14.         return redisTemplate;
  15.     }
  16. }

测试

新建测试类

  1. package com.hsy.spring.redis.dao;
  3. import com.hsy.spring.redis.sentinel.dao.RedisRepository;
  4. import org.junit.Test;
  5. import org.junit.runner.RunWith;
  6. import org.slf4j.Logger;
  7. import org.slf4j.LoggerFactory;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.test.context.ContextConfiguration;
  10. import org.springframework.test.context.junit4.SpringRunner;
  12. import java.util.ArrayList;
  13. import java.util.HashMap;
  14. import java.util.List;
  15. import java.util.Map;
  16. import java.util.concurrent.TimeUnit;
  18. /** * @author heshiyuan * @description <p></p> * @path spring/com.hsy.spring.redis.dao * @date 2018/7/23 18:42 * @github http://github.com/shiyuan2he * @email shiyuan4work@sina.com * Copyright (c) 2018 shiyuan4work@sina.com All rights reserved. * @price ¥5 微信：hewei1109 */
  19. @SuppressWarnings("Duplicates")
  20. @RunWith(SpringRunner.class)
  21. @ContextConfiguration({
  22.    "classpath*:/spring/applicationContext.xml"})
  23. public class RedisRepositoryTest { 
  25.     private Logger logger = LoggerFactory.getLogger(getClass());
  26.     @Autowired private RedisRepository redisRepository;
  28.     public Map<String, Object> generateMap(){
  29.         Map<String, Object> returnMap = new HashMap<>();
  30.         returnMap.put("aa", "aa");
  31.         Map<String, Object> innerMap = new HashMap<>();
  32.         innerMap.put("ss", 3);
  33.         innerMap.put("rr",false);
  34.         innerMap.put("tt","中文");
  35.         returnMap.put("bb", innerMap);
  36.         returnMap.put("cc", 1.000);
  37.         returnMap.put("dd", true);
  38.         returnMap.put("ee", 1);
  39.         return returnMap;
  40.     }
  41.     public List<Map<String, Object>> generateList(){
  42.         List<Map<String, Object>> list = new ArrayList<>();
  43.         for (int i = 0; i < 10; i++) {
  44.             list.add(generateMap());
  45.         }
  46.         return list;
  47.     }
  48.     @Test
  49.     public void clear(){
  50.         redisRepository.clear();
  51.     }
  52.     @Test
  53.     public void testSet(){
  54.         redisRepository.valueSet("name", "robot");
  55.         redisRepository.valueSet("name2", "robot", 1600, TimeUnit.SECONDS);
  56.         redisRepository.valueSet("set:map", generateMap());
  57.         redisRepository.valueSet("set:map", generateMap(), 1600, TimeUnit.SECONDS);
  58.         redisRepository.valueSet("set:list", generateList());
  59.         redisRepository.valueSet("set:list", generateList(), 1600, TimeUnit.SECONDS);
  60.     }
  62.     @Test
  63.     public void testDelete(){
  64.         //redisRepository.delete("name2", true);
  65.         redisRepository.delete("name", false);
  66.     }
  68.     @Test
  69.     public void testGet(){
  70.         logger.info("{}", redisRepository.valueGet("name", false));
  71.         logger.info("{}", redisRepository.valueGet("name2", true));
  72.         logger.info("{}", redisRepository.valueGet("set:map", false));
  73.         logger.info("{}", redisRepository.valueGet("set:map", true));
  74.         logger.info("{}", redisRepository.valueGet("set:list", false));
  75.         logger.info("{}", redisRepository.valueGet("set:list", true));
  76.         //logger.info("{}", redisRepository.getAndSet("name", "new value",false));
  77.         //logger.info("{}", redisRepository.getAndSet("name", "new value",true));
  78.     }
  80.     @Test
  81.     public void testIncrement(){
  82.         for (int i = 0; i < 10; i++) {
  83.             logger.info("{}", redisRepository.valueIncrement("mobile:15911111111", 1l, 60, TimeUnit.MINUTES));
  84.             logger.info("{}", redisRepository.valueIncrement("tel:15911111111", 1.0, 70, TimeUnit.MINUTES));
  85.         }
  86.     }
  87.     @Test
  88.     public void testSetArray(){
  89.         for (int i = 0; i < 10; i++) {
  90.             logger.info("{}", redisRepository.setAdd("set:array1",i));
  91.         }
  92.         for (int i = 5; i < 20; i++) {
  93.             logger.info("{}", redisRepository.setAdd("set:array1",i));
  94.             logger.info("{}", redisRepository.setAdd("set:array2",i));
  95.         }
  96.         //logger.info("{}", redisRepository.setPop("set:array"));
  97.         logger.info("{}", redisRepository.setDifference("set:array1","set:array2"));
  98.         logger.info("{}", redisRepository.setDifferenceAndStore("set:array1","set:array2", "set:array3"));
  100.         logger.info("{}", redisRepository.setAdd("set:add:map",generateMap()));
  101.         logger.info("{}", redisRepository.setAdd("set:add:list",generateList()));
  102.         logger.info("{}", redisRepository.setPop("set:add:map"));
  103.         logger.info("{}", redisRepository.setPop("set:add:list"));
  104.     }
  105.     @Test
  106.     public void testList(){
  107.         for (int i = 0; i < 10; i++) {
  108.             logger.info("{}", redisRepository.listLeftPush("list:lilo:list", generateList()));
  109.             logger.info("{}", redisRepository.listLeftPush("list:liro:list", generateList()));
  110.             logger.info("{}", redisRepository.listRightPush("list:rilo:list", generateList()));
  111.             logger.info("{}", redisRepository.listRightPush("list:riro:list", generateList()));
  112.         }
  114.         for (int i = 0; i < 5; i++) {
  115.             logger.info("{}", redisRepository.listLeftPop("list:lilo:list"));
  116.             logger.info("{}", redisRepository.listRightPop("list:liro:list"));
  117.             logger.info("{}", redisRepository.listLeftPop("list:rilo:list"));
  118.             logger.info("{}", redisRepository.listRightPop("list:riro:list"));
  119.         }
  120.         for (int i = 0; i < 10; i++) {
  121.             logger.info("{}", redisRepository.listLeftPush("list:lilo:map", generateMap()));
  122.             logger.info("{}", redisRepository.listLeftPush("list:liro:map", generateMap()));
  123.             logger.info("{}", redisRepository.listRightPush("list:rilo:map", generateMap()));
  124.             logger.info("{}", redisRepository.listRightPush("list:riro:map", generateMap()));
  125.         }
  127.         for (int i = 0; i < 5; i++) {
  128.             logger.info("{}", redisRepository.listLeftPop("list:lilo:map"));
  129.             logger.info("{}", redisRepository.listRightPop("list:liro:map"));
  130.             logger.info("{}", redisRepository.listLeftPop("list:rilo:map"));
  131.             logger.info("{}", redisRepository.listRightPop("list:riro:map"));
  132.         }
  133.     }
  134.     @Test
  135.     public void testZSet(){
  136.         for (int i = 0; i < 10; i++) {
  137.             logger.info("{}", redisRepository.zSetAdd("zset:map", generateMap(), i));
  138.         }
  139.         redisRepository.zSetIncrementScore("zset:Map", "4", 30);
  140.     }
  141.     @Test
  142.     public void testHash(){
  143.         for (int i = 0; i < 10; i++) {
  144.             redisRepository.hashPut("hash:map", String.valueOf(i), generateMap());
  145.             logger.info("{}", redisRepository.hashGet("hash:map", String.valueOf(i)));
  146.         }
  147.         for (int i = 0; i < 10; i++) {
  148.             redisRepository.hashPut("hash:list", String.valueOf(i), generateList());
  149.             logger.info("{}", redisRepository.hashGet("hash:list", String.valueOf(i)));
  150.         }
  151.     }
  152. }

总结

按照以上操作即可完成spring集成redis哨兵模式，简单而简洁。哨兵模式对于服务器防灾上有很好的可用性，保证服务

健壮可用，方式因服务器故障导致网站缓存穿透而致网站运行不畅。是单例redis基础之上的一个升级方案。

源码

spring-redis-sentinel

发表评论

表情：
评论列表 （有 0 条评论，259人围观）

还没有评论，来说两句吧...

相关阅读