Springboot2.x整合Redis以及连接哨兵模式/集群模式

野性酷女 2022-02-22 17:44 354阅读 0赞

依赖：

  1. <!--spirngboot版本为2.x-->
  2. <!-- 加载spring boot redis包,springboot2.0中直接使用jedis或者lettuce配置连接池，默认为lettuce连接池，这里使用jedis连接池 -->
  3. <!-- 加载spring boot redis包 -->
  4. <dependency>
  5.     <groupId>org.springframework.boot</groupId>
  6.     <artifactId>spring-boot-starter-data-redis</artifactId>
  7.     <!-- 排除lettuce包，使用jedis代替-->
  8.     <exclusions>
  9.         <exclusion>
  10.             <groupId>io.lettuce</groupId>
  11.             <artifactId>lettuce-core</artifactId>
  12.         </exclusion>
  13.     </exclusions>
  14. </dependency>
  15. <dependency>
  16.     <groupId>redis.clients</groupId>
  17.     <artifactId>jedis</artifactId>
  18.     <version>2.9.0</version>
  19. </dependency>

application.properties配置

  1. ##配置redis的连接信息
  2. #spring.redis.host=192.168.184.135
  3. #spring.redis.port=6379
  4. #spring.redis.password=123456
  5. #连接超时时间
  6. #spring.redis.timeout=6000ms
  7. ##Redis数据库索引（默认为0）
  8. #spring.redis.database=0
  9. ## 连接池配置，springboot2.0中直接使用jedis或者lettuce配置连接池，默认为lettuce连接池
  10. ##连接池最大连接数（使用负值表示没有限制）
  11. #spring.redis.jedis.pool.max-active=8
  12. ##连接池最大阻塞等待时间（使用负值表示没有限制）
  13. #spring.redis.jedis.pool.max-wait=-1s
  14. ##连接池中的最大空闲连接
  15. #spring.redis.jedis.pool.max-idle=8
  16. ##接池中的最小空闲连接
  17. #spring.redis.jedis.pool.min-idle=0
  19. ##################################
  21. #哨兵模式redis集群配置，就是为了通过redis找主节点，做到无感切换
  22. #spring.redis.password=123456
  23. #spring.redis.sentinel.master=mymaster
  24. #spring.redis.sentinel.nodes=192.168.184.133:26379,192.168.184.135:26379,192.168.184.136:26379
  25. ##连接超时时间
  26. #spring.redis.timeout=6000ms
  27. ##Redis数据库索引（默认为0）
  28. #spring.redis.database=0
  29. ## 连接池配置，springboot2.0中直接使用jedis或者lettuce配置连接池，默认为lettuce连接池
  30. ##连接池最大连接数（使用负值表示没有限制）
  31. #spring.redis.jedis.pool.max-active=8
  32. ##连接池最大阻塞等待时间（使用负值表示没有限制）
  33. #spring.redis.jedis.pool.max-wait=-1s
  34. ##连接池中的最大空闲连接
  35. #spring.redis.jedis.pool.max-idle=8
  36. ##接池中的最小空闲连接
  37. #spring.redis.jedis.pool.min-idle=0
  40. #############################
  42. #连接超时时间
  43. spring.redis.cluster.nodes=192.168.184.133:7000,192.168.184.133:7001,192.168.184.133:7002,192.168.184.133:7003,192.168.184.133:7004,192.168.184.133:7005
  44. spring.redis.password=123456
  45. spring.redis.timeout=6000ms
  46. #Redis数据库索引（默认为0）
  47. spring.redis.database=0
  48. # 连接池配置，springboot2.0中直接使用jedis或者lettuce配置连接池，默认为lettuce连接池
  49. #连接池最大连接数（使用负值表示没有限制）
  50. spring.redis.jedis.pool.max-active=8
  51. #连接池最大阻塞等待时间（使用负值表示没有限制）
  52. spring.redis.jedis.pool.max-wait=-1s
  53. #连接池中的最大空闲连接
  54. spring.redis.jedis.pool.max-idle=8
  55. #接池中的最小空闲连接
  56. spring.redis.jedis.pool.min-idle=0

　说明：Jedis和Lettuce的比较：

　　　　　Jedis ：

　　　　　　直连模式，在多个线程间共享一个 Jedis 实例时是线程不安全的，如果想要在多线程环境下使用 Jedis，需要使用连接池，

　　　　　　每个线程都去拿自己的 Jedis 实例，当连接数量增多时，物理连接成本较高。

　　　　　Lettuce：

　　　　　　连接是基于Netty的，连接实例可以在多个线程间共享，

　　　　　　所以，一个多线程的应用可以使用同一个连接实例，而不用担心并发线程的数量。当然这个也是可伸缩的设计，一个连接实例不够的情况也可以按需增加连接实例。

　　　　　　通过异步的方式可以让我们更好的利用系统资源，而不用浪费线程等待网络或磁盘I/O。

/哨兵相关内容//

一、客户端访问哨兵系统

哨兵系统的作用: 监控、自动故障转移、配置提供者、通知。

一、代码示例

在介绍客户端的原理之前，先以Java客户端Jedis为例，演示一下使用方法：下面代码可以连接我们刚刚搭建的哨兵系统，并进行各种读写操作：

  1. public static void testSentinel() throws Exception   {
  3.          String   masterName = "mymaster";
  5.          Set<String>   sentinels = new HashSet<>();
  7.          sentinels.add("192.168.92.128:26379");
  9.          sentinels.add("192.168.92.128:26380");
  11.          sentinels.add("192.168.92.128:26381");
  15.          JedisSentinelPool   pool = new JedisSentinelPool(masterName, sentinels); 
  17.          Jedis   jedis = pool.getResource();
  19.          jedis.set("key1", "value1");
  21.          pool.close();
  23. }

（注：代码中只演示如何连接哨兵，异常处理、资源关闭等未考虑）

二、客户端原理

Jedis客户端对哨兵提供了很好的支持。如上述代码所示，我们只需要向Jedis提供哨兵节点集合和masterName，构造Jedis SentinelPool对象；然后便可以像使用普通Redis连接池一样来使用了：通过pool.getResource()获取连接，执行具体的命令。

在整个过程中，我们的代码不需要显式的指定主节点的地址，就可以连接到主节点；代码中对故障转移没有任何体现，就可以在哨兵完成故障转移后自动的切换主节点。之所以可以做到这一点，是因为在JedisSentinelPool的构造器中，进行了相关的工作，主要包括以下两点：

遍历哨兵节点，获取主节点信息：遍历哨兵节点，通过其中一个哨兵节点+masterName获得主节点的信息；该功能是通过调用哨兵节点的sentinel get-master-addr-by-name命令实现，该命令示例如下：

20190410141755404.png

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjY5MDU4_size_16_color_FFFFFF_t_70

可以看到192.168.184.135的确是master

一旦获得主节点信息，停止遍历（因此一般来说遍历到第一个哨兵节点，循环就停止了）。

增加对哨兵的监听：这样当发生故障转移时，客户端便可以收到哨兵的通知，从而完成主节点的切换。具体做法是：利用Redis提供的发布订阅功能，为每一个哨兵节点开启一个单独的线程，订阅哨兵节点的+switch-master频道，当收到消息时，重新初始化连接池。

三、总结

通过客户端原理的介绍，可以加深对哨兵功能的理解，如下：

配置提供者：客户端可以通过哨兵节点+masterName获取主节点信息，在这里哨兵起到的作用就是配置提供者。

需要注意的是，哨兵只是配置提供者，而不是代理。二者的区别在于：

1、如果是配置提供者，客户端在通过哨兵获得主节点信息后，会直接建立到主节点的连接，后续的请求（如set/get）会直接发向主节点；

2、如果是代理，客户端的每一次请求都会发向哨兵，哨兵再通过主节点处理请求。

举一个例子可以很好的理解哨兵的作用是配置提供者，而不是代理。在前面部署的哨兵系统中，将哨兵节点的配置文件进行如下修改： 

  1. sentinel monitor   mymaster 192.168.92.128 6379 2
  3. 改为
  5. sentinel monitor mymaster 127.0.0.1 6379 2

然后，将前述客户端代码在局域网的另外一台机器上运行，会发现客户端无法连接主节点；这是因为哨兵作为配置提供者，客户端通过它查询到主节点的地址为127.0.0.1:6379，客户端会向127.0.0.1:6379建立Redis连接，自然无法连接。如果哨兵是代理，这个问题就不会出现了。

通知：哨兵节点在故障转移完成后，会将新的主节点信息发送给客户端，以便客户端及时切换主节点。

二、基本原理

一、哨兵节点支持的命令

哨兵节点作为运行在特殊模式下的Redis节点，其支持的命令与普通的Redis节点不同。在运维中，我们可以通过这些命令查询或修改哨兵系统；不过更重要的是，哨兵系统要实现故障发现、故障转移等各种功能，离不开哨兵节点之间的通信，而通信的很大一部分是通过哨兵节点支持的命令来实现的。下面介绍哨兵节点支持的主要命令：

基础查询：

通过这些命令，可以查询哨兵系统的拓扑结构、节点信息、配置信息等。

1、info sentinel：获取监控的所有主节点的基本信息。

2、sentinel masters：获取监控的所有主节点的详细信息。

3、sentinel master mymaster：获取监控的主节点mymaster的详细信息。

4、sentinel slaves mymaster：获取监控的主节点mymaster的从节点的详细信息。

5、sentinel sentinels mymaster：获取监控的主节点mymaster的哨兵节点的详细信息。

6、sentinel get - master - addr - by- name mymaster：获取监控的主节点mymaster的地址信息，前文已有介绍。

7、sentinel is-master-down-by-addr：哨兵节点之间可以通过该命令询问主节点是否下线，从而对是否客观下线做出判断。

增加/移除对主节点的监控：

sentinel monitor mymaster2 192.168.92.128 16379 2：与部署哨兵节点时配置文件中的sentinel monitor功能完全一样，不再详述。

sentinel remove mymaster2：取消当前哨兵节点对主节点mymaster2的监控。

强制故障转移：

sentinel failover mymaster：该命令可以强制对mymaster执行故障转移，即便当前的主节点运行完好；例如，如果当前主节点所在机器即将报废，便可以提前通过failover命令进行故障转移。

二、基本原理

关于哨兵的原理，关键是了解以下几个概念：

定时任务：每个哨兵节点维护了3个定时任务。定时任务的功能分别如下：通过向主从节点发送info命令获取最新的主从结构；通过发布订阅功能获取其他哨兵节点的信息；通过向其他节点发送ping命令进行心跳检测，判断是否下线。

主观下线：在心跳检测的定时任务中，如果其他节点超过一定时间没有回复，哨兵节点就会将其进行主观下线。顾名思义，主观下线的意思是一个哨兵节点“主观地”判断下线；与主观下线相对应的是客观下线。

客观下线：哨兵节点在对主节点进行主观下线后，会通过sentinel is-master-down-by-addr命令询问其他哨兵节点该主节点的状态；如果判断主节点下线的哨兵数量达到一定数值，则对该主节点进行客观下线。

需要特别注意的是，客观下线是主节点才有的概念；如果从节点和哨兵节点发生故障，被哨兵主观下线后，不会再有后续的客观下线和故障转移操作。

选举领导者哨兵节点：当主节点被判断客观下线以后，各个哨兵节点会进行协商，选举出一个领导者哨兵节点，并由该领导者节点对其进行故障转移操作。

监视该主节点的所有哨兵都有可能被选为领导者，选举使用的算法是Raft算法；Raft算法的基本思路是先到先得：即在一轮选举中，哨兵A向B发送成为领导者的申请，如果B没有同意过其他哨兵，则会同意A成为领导者。选举的具体过程这里不做详细描述，一般来说，哨兵选择的过程很快，谁先完成客观下线，一般就能成为领导者。

故障转移：选举出的领导者哨兵，开始进行故障转移操作，该操作大体可以分为3个步骤：

1、在从节点中选择新的主节点：选择的原则是，首先过滤掉不健康的从节点；然后选择优先级最高的从节点（由slave-priority指定）；如果优先级无法区分，则选择复制偏移量最大的从节点；如果仍无法区分，则选择runid最小的从节点。

2、更新主从状态：通过slaveof no one命令，让选出来的从节点成为主节点；并通过slaveof命令让其他节点成为其从节点。

3、将已经下线的主节点（即6379）设置为新的主节点的从节点，当6379重新上线后，它会成为新的主节点的从节点。

通过上述几个关键概念，可以基本了解哨兵的工作原理。为了更形象的说明，下图展示了领导者哨兵节点的日志，包括从节点启动到完成故障转移。

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjY5MDU4_size_16_color_FFFFFF_t_70 1

三、配置与实践建议

一、配置

下面介绍与哨兵相关的几个配置。

配置1：sentinel monitor {masterName} {masterIp} {masterPort} {quorum}

sentinel monitor是哨兵最核心的配置，在前文讲述部署哨兵节点时已说明，其中：masterName指定了主节点名称，masterIp和masterPort指定了主节点地址，quorum是判断主节点客观下线的哨兵数量阈值：当判定主节点下线的哨兵数量达到quorum时，对主节点进行客观下线。建议取值为哨兵数量的一半加1。

配置2：sentinel down-after-milliseconds {masterName} {time}

sentinel down-after-milliseconds与主观下线的判断有关：哨兵使用ping命令对其他节点进行心跳检测，如果其他节点超过down-after-milliseconds配置的时间没有回复，哨兵就会将其进行主观下线。该配置对主节点、从节点和哨兵节点的主观下线判定都有效。

down-after-milliseconds的默认值是30000，即30s；可以根据不同的网络环境和应用要求来调整：值越大，对主观下线的判定会越宽松，好处是误判的可能性小，坏处是故障发现和故障转移的时间变长，客户端等待的时间也会变长。例如，如果应用对可用性要求较高，则可以将值适当调小，当故障发生时尽快完成转移；如果网络环境相对较差，可以适当提高该阈值，避免频繁误判。

配置3：sentinel parallel - syncs {masterName} {number}

sentinel parallel-syncs与故障转移之后从节点的复制有关：它规定了每次向新的主节点发起复制操作的从节点个数。例如，假设主节点切换完成之后，有3个从节点要向新的主节点发起复制；如果parallel-syncs=1，则从节点会一个一个开始复制；如果parallel-syncs=3，则3个从节点会一起开始复制。

parallel-syncs取值越大，从节点完成复制的时间越快，但是对主节点的网络负载、硬盘负载造成的压力也越大；应根据实际情况设置。例如，如果主节点的负载较低，而从节点对服务可用的要求较高，可以适量增加parallel-syncs取值。parallel-syncs的默认值是1。

配置4：sentinel failover - timeout {masterName} {time}

sentinel failover-timeout与故障转移超时的判断有关，但是该参数不是用来判断整个故障转移阶段的超时，而是其几个子阶段的超时，例如如果主节点晋升从节点时间超过timeout，或从节点向新的主节点发起复制操作的时间（不包括复制数据的时间）超过timeout，都会导致故障转移超时失败。

failover-timeout的默认值是180000，即180s；如果超时，则下一次该值会变为原来的2倍。

配置5：除上述几个参数外，还有一些其他参数，如安全验证相关的参数，这里不做介绍。

二、实践建议

1、哨兵节点的数量应不止一个。一方面增加哨兵节点的冗余，避免哨兵本身成为高可用的瓶颈；另一方面减少对下线的误判。此外，这些不同的哨兵节点应部署在不同的物理机上。

2、哨兵节点的数量应该是奇数，便于哨兵通过投票做出“决策”：领导者选举的决策、客观下线的决策等。

3、各个哨兵节点的配置应一致，包括硬件、参数等；此外，所有节点都应该使用ntp或类似服务，保证时间准确、一致。

4、哨兵的配置提供者和通知客户端功能，需要客户端的支持才能实现，如前文所说的Jedis；如果开发者使用的库未提供相应支持，则可能需要开发者自己实现。

5、当哨兵系统中的节点在Docker（或其他可能进行端口映射的软件）中部署时，应特别注意端口映射可能会导致哨兵系统无法正常工作，因为哨兵的工作基于与其他节点的通信，而Docker的端口映射可能导致哨兵无法连接到其他节点。例如，哨兵之间互相发现，依赖于它们对外宣称的IP和port，如果某个哨兵A部署在做了端口映射的Docker中，那么其他哨兵使用A宣称的port无法连接到A。

三、总结

在主从复制的基础上，哨兵引入了主节点的自动故障转移，进一步提高了Redis的高可用性；但是哨兵的缺陷同样很明显：哨兵无法对从节点进行自动故障转移，在读写分离场景下，从节点故障会导致读服务不可用，需要我们对从节点做额外的监控、切换操作。

此外，哨兵仍然没有解决写操作无法负载均衡、及存储能力受到单机限制的问题；这些问题的解决需要使用集群。

///

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjY5MDU4_size_16_color_FFFFFF_t_70 2

  1. RedisAutoConfiguration源码

通过源码可以看出，SpringBoot自动帮我们在容器中生成了一个RedisTemplate和一个StringRedisTemplate。但是，这个RedisTemplate的泛型是，写代码不方便，需要写好多类型转换的代码；我们需要一个泛型为形式的RedisTemplate。并且，这个RedisTemplate没有设置数据存在Redis时，key及value的序列化方式。

  1.     看到这个**@ConditionalOnMissingBean**注解后，就知道**如果Spring容器中有了RedisTemplate对象了，这个自动配置的RedisTemplate不会实例化**。因此我们可以直接自己写个配置类，配置RedisTemplate。

/

既然自动配置不好用，就重新配置一个RedisTemplate。

  1. package com.bootredis.bootredis.config;
  3. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  4. import com.fasterxml.jackson.annotation.PropertyAccessor;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.data.redis.connection.RedisConnectionFactory;
  9. import org.springframework.data.redis.core.RedisTemplate;
  10. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  11. import org.springframework.data.redis.serializer.StringRedisSerializer;
  13. //RedisAutoConfiguration类中的默认的RedisTemplate不好用，直接重写一个
  14. @Configuration
  15. public class RedisConfig {
  17.     @Bean
  18.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
  19.         RedisTemplate<String, Object> template = new RedisTemplate<>();
  20.         template.setConnectionFactory(factory);
  22.         // 使用Jackson2JsonRedisSerialize 替换默认的jdkSerializeable序列化
  23.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  24.         ObjectMapper om = new ObjectMapper();
  25.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  26.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  27.         jackson2JsonRedisSerializer.setObjectMapper(om);
  29.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  31.         // key采用String的序列化方式
  32.         template.setKeySerializer(stringRedisSerializer);
  33.         // hash的key也采用String的序列化方式
  34.         template.setHashKeySerializer(stringRedisSerializer);
  35.         // value序列化方式采用jackson
  36.         template.setValueSerializer(jackson2JsonRedisSerializer);
  37.         // hash的value序列化方式采用jackson
  38.         template.setHashValueSerializer(jackson2JsonRedisSerializer);
  39.         template.afterPropertiesSet();
  40.         return template;
  42.     }
  43. }

/

如果不重新注入到spring容器中一个RedisTemplate对象，在程序中使用泛型必须为、，因为默认就这两种。。。。

  1. //spring boot帮我们注入的redisTemplate类，泛型里面只能写 <String, String>、<Object, Object>
  2.  @Autowired
  3.  private RedisTemplate<Object, Object> redisTemplate;

/

一般使用封装简单的工具类

  1. package com.bootredis.bootredis.util;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.data.redis.core.RedisTemplate;
  6. import org.springframework.stereotype.Component;
  7. import org.springframework.util.CollectionUtils;
  9. import java.util.List;
  10. import java.util.Map;
  11. import java.util.Set;
  12. import java.util.concurrent.TimeUnit;
  14. @Component
  15. public class RedisCacheManager {
  16.     @Autowired
  17.     private RedisTemplate<String, Object> redisTemplate;
  18.     /**
  19.      * 指定缓存失效时间
  20.      *
  21.      * @param key
  22.      *            键
  23.      * @param time
  24.      *            时间(秒)
  25.      * @return
  26.      */
  27.     public boolean expire(String key, long time) {
  28.         try {
  29.             if (time > 0) {
  30.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  31.             }
  32.             return true;
  33.         } catch (Exception e) {
  34.             e.printStackTrace();
  35.             return false;
  36.         }
  37.     }
  39.     /**
  40.      * 根据key 获取过期时间
  41.      *
  42.      * @param key
  43.      *            键 不能为null
  44.      * @return 时间(秒) 返回0代表为永久有效
  45.      */
  46.     public long getExpire(String key) {
  47.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  48.     }
  50.     /**
  51.      * 判断key是否存在
  52.      *
  53.      * @param key
  54.      *            键
  55.      * @return true 存在 false不存在
  56.      */
  57.     public boolean hasKey(String key) {
  58.         try {
  59.             return redisTemplate.hasKey(key);
  60.         } catch (Exception e) {
  61.             e.printStackTrace();
  62.             return false;
  63.         }
  64.     }
  66.     /**
  67.      * 删除缓存
  68.      *
  69.      * @param key
  70.      *            可以传一个值 或多个
  71.      */
  72.     @SuppressWarnings("unchecked")
  73.     public void del(String... key) {
  74.         if (key != null && key.length > 0) {
  75.             if (key.length == 1) {
  76.                 redisTemplate.delete(key[0]);
  77.             } else {
  78.                 redisTemplate.delete(CollectionUtils.arrayToList(key));
  79.             }
  80.         }
  81.     }
  83.     // ============================String=============================
  84.     /**
  85.      * 普通缓存获取
  86.      *
  87.      * @param key
  88.      *            键
  89.      * @return 值
  90.      */
  91.     public Object get(String key) {
  92.         return key == null ? null : redisTemplate.opsForValue().get(key);
  93.     }
  95.     /**
  96.      * 普通缓存放入
  97.      *
  98.      * @param key
  99.      *            键
  100.      * @param value
  101.      *            值
  102.      * @return true成功 false失败
  103.      */
  104.     public boolean set(String key, Object value) {
  105.         try {
  106.             redisTemplate.opsForValue().set(key, value);
  107.             return true;
  108.         } catch (Exception e) {
  109.             e.printStackTrace();
  110.             return false;
  111.         }
  113.     }
  115.     /**
  116.      * 普通缓存放入并设置时间
  117.      *
  118.      * @param key
  119.      *            键
  120.      * @param value
  121.      *            值
  122.      * @param time
  123.      *            时间(秒) time要大于0 如果time小于等于0 将设置无限期
  124.      * @return true成功 false 失败
  125.      */
  126.     public boolean set(String key, Object value, long time) {
  127.         try {
  128.             if (time > 0) {
  129.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  130.             } else {
  131.                 set(key, value);
  132.             }
  133.             return true;
  134.         } catch (Exception e) {
  135.             e.printStackTrace();
  136.             return false;
  137.         }
  138.     }
  140.     /**
  141.      * 递增
  142.      *
  143.      * @param key
  144.      *            键
  145.      * @param delta
  146.      *            要增加几(大于0)
  147.      * @return
  148.      */
  149.     public long incr(String key, long delta) {
  150.         if (delta < 0) {
  151.             throw new RuntimeException("递增因子必须大于0");
  152.         }
  153.         return redisTemplate.opsForValue().increment(key, delta);
  154.     }
  156.     /**
  157.      * 递减
  158.      *
  159.      * @param key
  160.      *            键
  161.      * @param delta
  162.      *            要减少几(小于0)
  163.      * @return
  164.      */
  165.     public long decr(String key, long delta) {
  166.         if (delta < 0) {
  167.             throw new RuntimeException("递减因子必须大于0");
  168.         }
  169.         return redisTemplate.opsForValue().increment(key, -delta);
  170.     }
  172.     // ================================Map=================================
  173.     /**
  174.      * HashGet
  175.      *
  176.      * @param key
  177.      *            键 不能为null
  178.      * @param item
  179.      *            项 不能为null
  180.      * @return 值
  181.      */
  182.     public Object hget(String key, String item) {
  183.         return redisTemplate.opsForHash().get(key, item);
  184.     }
  186.     /**
  187.      * 获取hashKey对应的所有键值
  188.      *
  189.      * @param key
  190.      *            键
  191.      * @return 对应的多个键值
  192.      */
  193.     public Map<Object, Object> hmget(String key) {
  194.         return redisTemplate.opsForHash().entries(key);
  195.     }
  197.     /**
  198.      * HashSet
  199.      *
  200.      * @param key
  201.      *            键
  202.      * @param map
  203.      *            对应多个键值
  204.      * @return true 成功 false 失败
  205.      */
  206.     public boolean hmset(String key, Map<String, Object> map) {
  207.         try {
  208.             redisTemplate.opsForHash().putAll(key, map);
  209.             return true;
  210.         } catch (Exception e) {
  211.             e.printStackTrace();
  212.             return false;
  213.         }
  214.     }
  216.     /**
  217.      * HashSet 并设置时间
  218.      *
  219.      * @param key
  220.      *            键
  221.      * @param map
  222.      *            对应多个键值
  223.      * @param time
  224.      *            时间(秒)
  225.      * @return true成功 false失败
  226.      */
  227.     public boolean hmset(String key, Map<String, Object> map, long time) {
  228.         try {
  229.             redisTemplate.opsForHash().putAll(key, map);
  230.             if (time > 0) {
  231.                 expire(key, time);
  232.             }
  233.             return true;
  234.         } catch (Exception e) {
  235.             e.printStackTrace();
  236.             return false;
  237.         }
  238.     }
  240.     /**
  241.      * 向一张hash表中放入数据,如果不存在将创建
  242.      *
  243.      * @param key
  244.      *            键
  245.      * @param item
  246.      *            项
  247.      * @param value
  248.      *            值
  249.      * @return true 成功 false失败
  250.      */
  251.     public boolean hset(String key, String item, Object value) {
  252.         try {
  253.             redisTemplate.opsForHash().put(key, item, value);
  254.             return true;
  255.         } catch (Exception e) {
  256.             e.printStackTrace();
  257.             return false;
  258.         }
  259.     }
  261.     /**
  262.      * 向一张hash表中放入数据,如果不存在将创建
  263.      *
  264.      * @param key
  265.      *            键
  266.      * @param item
  267.      *            项
  268.      * @param value
  269.      *            值
  270.      * @param time
  271.      *            时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
  272.      * @return true 成功 false失败
  273.      */
  274.     public boolean hset(String key, String item, Object value, long time) {
  275.         try {
  276.             redisTemplate.opsForHash().put(key, item, value);
  277.             if (time > 0) {
  278.                 expire(key, time);
  279.             }
  280.             return true;
  281.         } catch (Exception e) {
  282.             e.printStackTrace();
  283.             return false;
  284.         }
  285.     }
  287.     /**
  288.      * 删除hash表中的值
  289.      *
  290.      * @param key
  291.      *            键 不能为null
  292.      * @param item
  293.      *            项 可以使多个 不能为null
  294.      */
  295.     public void hdel(String key, Object... item) {
  296.         redisTemplate.opsForHash().delete(key, item);
  297.     }
  299.     /**
  300.      * 判断hash表中是否有该项的值
  301.      *
  302.      * @param key
  303.      *            键 不能为null
  304.      * @param item
  305.      *            项 不能为null
  306.      * @return true 存在 false不存在
  307.      */
  308.     public boolean hHasKey(String key, String item) {
  309.         return redisTemplate.opsForHash().hasKey(key, item);
  310.     }
  312.     /**
  313.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
  314.      *
  315.      * @param key
  316.      *            键
  317.      * @param item
  318.      *            项
  319.      * @param by
  320.      *            要增加几(大于0)
  321.      * @return
  322.      */
  323.     public double hincr(String key, String item, double by) {
  324.         return redisTemplate.opsForHash().increment(key, item, by);
  325.     }
  327.     /**
  328.      * hash递减
  329.      *
  330.      * @param key
  331.      *            键
  332.      * @param item
  333.      *            项
  334.      * @param by
  335.      *            要减少记(小于0)
  336.      * @return
  337.      */
  338.     public double hdecr(String key, String item, double by) {
  339.         return redisTemplate.opsForHash().increment(key, item, -by);
  340.     }
  342.     // ============================set=============================
  343.     /**
  344.      * 根据key获取Set中的所有值
  345.      *
  346.      * @param key
  347.      *            键
  348.      * @return
  349.      */
  350.     public Set<Object> sGet(String key) {
  351.         try {
  352.             return redisTemplate.opsForSet().members(key);
  353.         } catch (Exception e) {
  354.             e.printStackTrace();
  355.             return null;
  356.         }
  357.     }
  359.     /**
  360.      * 根据value从一个set中查询,是否存在
  361.      *
  362.      * @param key
  363.      *            键
  364.      * @param value
  365.      *            值
  366.      * @return true 存在 false不存在
  367.      */
  368.     public boolean sHasKey(String key, Object value) {
  369.         try {
  370.             return redisTemplate.opsForSet().isMember(key, value);
  371.         } catch (Exception e) {
  372.             e.printStackTrace();
  373.             return false;
  374.         }
  375.     }
  377.     /**
  378.      * 将数据放入set缓存
  379.      *
  380.      * @param key
  381.      *            键
  382.      * @param values
  383.      *            值 可以是多个
  384.      * @return 成功个数
  385.      */
  386.     public long sSet(String key, Object... values) {
  387.         try {
  388.             return redisTemplate.opsForSet().add(key, values);
  389.         } catch (Exception e) {
  390.             e.printStackTrace();
  391.             return 0;
  392.         }
  393.     }
  395.     /**
  396.      * 将set数据放入缓存
  397.      *
  398.      * @param key
  399.      *            键
  400.      * @param time
  401.      *            时间(秒)
  402.      * @param values
  403.      *            值 可以是多个
  404.      * @return 成功个数
  405.      */
  406.     public long sSetAndTime(String key, long time, Object... values) {
  407.         try {
  408.             Long count = redisTemplate.opsForSet().add(key, values);
  409.             if (time > 0)
  410.                 expire(key, time);
  411.             return count;
  412.         } catch (Exception e) {
  413.             e.printStackTrace();
  414.             return 0;
  415.         }
  416.     }
  418.     /**
  419.      * 获取set缓存的长度
  420.      *
  421.      * @param key
  422.      *            键
  423.      * @return
  424.      */
  425.     public long sGetSetSize(String key) {
  426.         try {
  427.             return redisTemplate.opsForSet().size(key);
  428.         } catch (Exception e) {
  429.             e.printStackTrace();
  430.             return 0;
  431.         }
  432.     }
  434.     /**
  435.      * 移除值为value的
  436.      *
  437.      * @param key
  438.      *            键
  439.      * @param values
  440.      *            值 可以是多个
  441.      * @return 移除的个数
  442.      */
  443.     public long setRemove(String key, Object... values) {
  444.         try {
  445.             Long count = redisTemplate.opsForSet().remove(key, values);
  446.             return count;
  447.         } catch (Exception e) {
  448.             e.printStackTrace();
  449.             return 0;
  450.         }
  451.     }
  452.     // ===============================list=================================
  454.     /**
  455.      * 获取list缓存的内容
  456.      *
  457.      * @param key
  458.      *            键
  459.      * @param start
  460.      *            开始
  461.      * @param end
  462.      *            结束 0 到 -1代表所有值
  463.      * @return
  464.      */
  465.     public List<Object> lGet(String key, long start, long end) {
  466.         try {
  467.             return redisTemplate.opsForList().range(key, start, end);
  468.         } catch (Exception e) {
  469.             e.printStackTrace();
  470.             return null;
  471.         }
  472.     }
  474.     /**
  475.      * 获取list缓存的长度
  476.      *
  477.      * @param key
  478.      *            键
  479.      * @return
  480.      */
  481.     public long lGetListSize(String key) {
  482.         try {
  483.             return redisTemplate.opsForList().size(key);
  484.         } catch (Exception e) {
  485.             e.printStackTrace();
  486.             return 0;
  487.         }
  488.     }
  490.     /**
  491.      * 通过索引 获取list中的值
  492.      *
  493.      * @param key
  494.      *            键
  495.      * @param index
  496.      *            索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  497.      * @return
  498.      */
  499.     public Object lGetIndex(String key, long index) {
  500.         try {
  501.             return redisTemplate.opsForList().index(key, index);
  502.         } catch (Exception e) {
  503.             e.printStackTrace();
  504.             return null;
  505.         }
  506.     }
  508.     /**
  509.      * 将list放入缓存
  510.      *
  511.      * @param key
  512.      *            键
  513.      * @param value
  514.      *            值
  515.      * @return
  516.      */
  517.     public boolean lSet(String key, Object value) {
  518.         try {
  519.             redisTemplate.opsForList().rightPush(key, value);
  520.             return true;
  521.         } catch (Exception e) {
  522.             e.printStackTrace();
  523.             return false;
  524.         }
  525.     }
  527.     /**
  528.      * 将list放入缓存
  529.      *
  530.      * @param key
  531.      *            键
  532.      * @param value
  533.      *            值
  534.      * @param time
  535.      *            时间(秒)
  536.      * @return
  537.      */
  538.     public boolean lSet(String key, Object value, long time) {
  539.         try {
  540.             redisTemplate.opsForList().rightPush(key, value);
  541.             if (time > 0)
  542.                 expire(key, time);
  543.             return true;
  544.         } catch (Exception e) {
  545.             e.printStackTrace();
  546.             return false;
  547.         }
  548.     }
  550.     /**
  551.      * 将list放入缓存
  552.      *
  553.      * @param key
  554.      *            键
  555.      * @param value
  556.      *            值
  557.      * @return
  558.      */
  559.     public boolean lSet(String key, List<Object> value) {
  560.         try {
  561.             redisTemplate.opsForList().rightPushAll(key, value);
  562.             return true;
  563.         } catch (Exception e) {
  564.             e.printStackTrace();
  565.             return false;
  566.         }
  567.     }
  569.     /**
  570.      * 将list放入缓存
  571.      *
  572.      * @param key
  573.      *            键
  574.      * @param value
  575.      *            值
  576.      * @param time
  577.      *            时间(秒)
  578.      * @return
  579.      */
  580.     public boolean lSet(String key, List<Object> value, long time) {
  581.         try {
  582.             redisTemplate.opsForList().rightPushAll(key, value);
  583.             if (time > 0)
  584.                 expire(key, time);
  585.             return true;
  586.         } catch (Exception e) {
  587.             e.printStackTrace();
  588.             return false;
  589.         }
  590.     }
  592.     /**
  593.      * 根据索引修改list中的某条数据
  594.      *
  595.      * @param key
  596.      *            键
  597.      * @param index
  598.      *            索引
  599.      * @param value
  600.      *            值
  601.      * @return
  602.      */
  603.     public boolean lUpdateIndex(String key, long index, Object value) {
  604.         try {
  605.             redisTemplate.opsForList().set(key, index, value);
  606.             return true;
  607.         } catch (Exception e) {
  608.             e.printStackTrace();
  609.             return false;
  610.         }
  611.     }
  613.     /**
  614.      * 移除N个值为value
  615.      *
  616.      * @param key
  617.      *            键
  618.      * @param count
  619.      *            移除多少个
  620.      * @param value
  621.      *            值
  622.      * @return 移除的个数
  623.      */
  624.     public long lRemove(String key, long count, Object value) {
  625.         try {
  626.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  627.             return remove;
  628.         } catch (Exception e) {
  629.             e.printStackTrace();
  630.             return 0;
  631.         }
  632.     }
  635. }

参考：

Redis和springboot 整合redisUtil类

实现故障恢复自动化：详解Redis哨兵技术

Spring整合Redis(spring-data-redis)

Springboot2.0整合Redis(注解开发)

易百Redis教程

发表评论

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

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

相关阅读