devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Springboot项目技术集成_springboot 集成

作者：很楠不爱3 | 2024-06-11 16:10:30

赞

踩

springboot 集成

一、建新模块

得到程序能正常的跑起来

当前使用的连接池

希望些、安全一些，从连接池、语句的改变这几点开始修改，下面就是操作

二、集成Druid

C3P0 ：是一个开放源代码的 JDBC 连接池，它在 lib 目录中与 Hibernate 一起发布，包括了实现 jdbc3 和 jdbc2扩展规范说明的 Connection 和 Statement 池的 DataSources 对象。
Proxool ：是一个 Java SQL Driver 驱动程序，提供了对选择的其它类型的驱动程序的连接池封装。可以 非常简单的移植到现存的代码中，完全可配置，快速、成熟、健壮。可以透明地为现存的JDBC 驱动程序 增加连接池功能。
Jakarta DBCP ： DBCP 是一个依赖 Jakartacommons-pool 对象池机制的数据库连接池。 DBCP 可以直接的 在应用程序中使用。
BoneCP ：是一个快速、开源的数据库连接池。帮用户管理数据连接，让应用程序能更快速地访问数据 库。比C3P0/DBCP 连接池速度快 25 倍。
Druid ： Druid 不仅是一个数据库连接池，还包含一个 ProxyDriver （代理程序）、一系列内置的 JDBC 组 件库、一个SQL
Parser 。支持所有 JDBC 兼容的数据库，包括 Oracle 、 MySql 、 Derby 、 Postgresql 、 SQL Server 、 H2 等

1、导入pom依赖

<dependency>
<groupId> com.alibaba </groupId>
<artifactId> druid-spring-boot-starter </artifactId>
<version> 1.2.8 </version>
</dependency>

2、修改application.yml

server:
  port: 8080
spring:
  datasource:
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/SpringBoot?useSSL=false&serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&allowPublicKeyRetrieval=true
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      initial-size: 5                                       # 初始化大小
      min-idle: 10                                          # 最小连接数
      max-active: 20                                        # 最大连接数
      max-wait: 60000                                       # 获取连接时的最大等待时间
      min-evictable-idle-time-millis: 300000                # 一个连接在池中最小生存的时间，单位是毫秒
      time-between-eviction-runs-millis: 60000              # 多久才进行一次检测需要关闭的空闲连接，单位是毫秒
      filters: stat                                         # 配置扩展插件：stat-监控统计，log4j-日志，wall-防火墙（防止SQL注入），去掉后，监控界面的sql无法统计   ,wall
      validation-query: SELECT 1                            # 检测连接是否有效的 SQL语句，为空时以下三个配置均无效
      test-on-borrow: true                                  # 申请连接时执行validationQuery检测连接是否有效，默认true，开启后会降低性能
      test-on-return: true                                  # 归还连接时执行validationQuery检测连接是否有效，默认false，开启后会降低性能
      test-while-idle: true                                 # 申请连接时如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效，默认false，建议开启，不影响性能
      stat-view-servlet:
        enabled: true                                       # 是否开启 StatViewServlet
        allow: 127.0.0.1                                    # 访问监控页面 白名单，默认127.0.0.1
        deny: 192.168.56.1                                  # 访问监控页面 黑名单
        login-username: admin                               # 访问监控页面 登陆账号
        login-password: 123                                 # 访问监控页面 登陆密码
      filter:
        stat:
          enabled: true                                     # 是否开启 FilterStat，默认true
          log-slow-sql: true                                # 是否开启 慢SQL 记录，默认false
          slow-sql-millis: 5000                             # 慢 SQL 的标准，默认 3000,单位：毫秒
          merge-sql: false                                  # 合并多个连接池的监控数据，默认false
  redis:
    database: 0         #数据库索引
    host: 127.0.0.1     #主机位置
    port: 6379          #端口
    password: 123         #密码
    jedis:
      pool:
        max-active: 8   #最大连接数
        max-wait: -1    #最大阻塞等待时间(负数表示没限制)
        max-idle: 8     #最大空闲
        min-idle: 0     #最小空闲
    timeout: 10000      #连接超时时间
logging:
  level:
    com.mwy.code.mapper: debug

3、增加controller软件包，编写StudentController类

package com.mwy.code.controller;
import com.mwy.code.service.StudentService;
import com.mwy.code.util.PageBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
@RestController
@RequestMapping("/stu")
public class StudentController {
    @Autowired
    StudentService service;

    @GetMapping("/index")
    public Object index(HttpServletRequest request){
        PageBean pageBean=new PageBean();
        pageBean.setRequest(request);
        return service.findPager(pageBean);
    }
}

 启动测试得到结果

4、 Druid ：连接池提供了监控界面

可以看到程序到底执行了那些语句，登录账号密码在yml中写着

 如果某一天发现应用程序非常的卡，那么就去查看监控界面，到底是哪一段语句执行最长，知道后就能根据语句进行改进，对数据进行整理

5、分页插件yml

pagehelper : # https://pagehelper.github.io/docs/howtouse
# 是否启用分页合理化。如果启用 , 当 page<1 时 , 会自动查询第一页的数据
# 当 page>maxPages 时 , 自动查询最后一页数据
# 不启用的 , 以上两种情况都会返回空数据
reasonable : true
# 分页插件会从查询方法的参数值中 , 自动根据上面 params 配置的字段中取值 , 查找到合适的值时就会
自动分页
supportMethodsArguments : true
# 默认值为 false, 当该参数设置为 true 时 , 如果 pageSize=0 或者 RowBounds.limit = 0 就
会查询出全部的结果
page-size-zero : true
# 指定数据库 , 不指定的话会默认自动检测数据库类型
helper-dialect : mysql

三、集成Redis

提高运行速度，将以下语句（查询数据库的语句）去除，因此将它放到缓存中去，所以集成（Redis）缓存

 1、yml配置

redis:
  database: 0         #数据库索引
  host: 127.0.0.1     #主机位置
  port: 6379          #端口
  password: 123         #密码
  jedis:
    pool:
      max-active: 8   #最大连接数
      max-wait: -1    #最大阻塞等待时间(负数表示没限制)
      max-idle: 8     #最大空闲
      min-idle: 0     #最小空闲
  timeout: 10000      #连接超时时间

2、增加config软件包

@Configuration：变成配置类，被spring管理

①、CrossConfiguration类

  1. package com.mwy.code.conf;
  2. import org.springframework.context.annotation.Configuration;
  3. import org.springframework.web.servlet.config.annotation.CorsRegistry;
  4. import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
  5.  
  6. @Configuration
  7. public class CrossConfiguration extends WebMvcConfigurerAdapter {
  8.  
  9.     @Override
  10.     public void addCorsMappings(CorsRegistry registry) {
  11.         registry
  12.                 /*可以跨域的路径*/
  13.                 .addMapping("/**")
  14.                 /*可以跨域的ip*/
  15.                 .allowedOrigins("*")
  16.                 /*可以跨域的方法*/
  17.                 .allowedMethods("*")
  18.                 /*设置预检请求多就失效*/
  19.                 .maxAge(6000)
  20.                 /*允许携带的头部*/
  21.                 .allowedHeaders("*");
  22.     }
  23. }

②、RedisConfiguration类

增加pom依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
@EnableCaching：开启缓存
  1. package com.mwy.code.conf;
  2. import org.springframework.cache.CacheManager;
  3. import org.springframework.cache.annotation.CachingConfigurerSupport;
  4. import org.springframework.cache.annotation.EnableCaching;
  5. import org.springframework.cache.interceptor.KeyGenerator;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.context.annotation.Primary;
  9. import org.springframework.data.redis.cache.RedisCacheConfiguration;
  10. import org.springframework.data.redis.cache.RedisCacheManager;
  11. import org.springframework.data.redis.connection.RedisConnectionFactory;
  12. import org.springframework.data.redis.core.RedisTemplate;
  13. import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
  14. import org.springframework.data.redis.serializer.RedisSerializationContext;
  15. import org.springframework.data.redis.serializer.RedisSerializer;
  16. import org.springframework.data.redis.serializer.StringRedisSerializer;
  17. import org.springframework.util.ClassUtils;
  18. import java.lang.reflect.Array;
  19. import java.lang.reflect.Method;
  20. import java.time.Duration;
  21. @Configuration
  22. @EnableCaching
  23. public class RedisConfiguration extends CachingConfigurerSupport {
  24.  
  25.  
  26. //    @Bean 相当于 @component 成为spring的bean列项（组件容器的意思）
  27. //    @Primar 相同类的情况下加它会被优先注入
  28.  
  29.     @Bean
  30.     @Primary
  31.     CacheManager cacheManager(RedisConnectionFactory factory) {
  32.         RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
  33.                 .computePrefixWith(cacheName -> cacheName + ":-cache-:")
  34.                 /*设置缓存过期时间*/
  35.                 .entryTtl(Duration.ofHours(1))
  36.                 /*禁用缓存空值,不缓存null校验*/
  37.                 .disableCachingNullValues()
  38.                 /*设置CacheManager的值序列化方式为json序列化,可使用加入@Class属性*/
  39.                 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(
  40.                         new GenericJackson2JsonRedisSerializer()
  41.                 ));
  42.         /*使用RedisCacheConfiguration创建RedisCacheManager*/
  43.         RedisCacheManager manager = RedisCacheManager.builder(factory)
  44.                 .cacheDefaults(cacheConfiguration)
  45.                 .build();
  46.         return manager;
  47.     }
  48.  
  49.     @Bean
  50.     @Primary
  51.     public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
  52.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
  53.         redisTemplate.setConnectionFactory(factory);
  54.         RedisSerializer stringSerializer = new StringRedisSerializer();
  55.         /* key序列化 */
  56.         redisTemplate.setKeySerializer(stringSerializer);
  57.         /* value序列化 */
  58.         redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
  59.         /* Hash key序列化 */
  60.         redisTemplate.setHashKeySerializer(stringSerializer);
  61.         /* Hash value序列化 */
  62.         redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
  63.         redisTemplate.afterPropertiesSet();
  64.         return redisTemplate;
  65.     }
  66.  
  67.     @Bean
  68.     @Primary
  69.     @Override
  70.     public KeyGenerator keyGenerator() {
  71.         return (Object target, Method method, Object... params) -> {
  72.             final int NO_PARAM_KEY = 0;
  73.             final int NULL_PARAM_KEY = 53;
  74.             StringBuilder key = new StringBuilder();
  75.             /* Class.Method: */
  76.             key.append(target.getClass().getSimpleName())
  77.                     .append(".")
  78.                     .append(method.getName())
  79.                     .append(":");
  80.             if (params.length == 0) {
  81.                 return key.append(NO_PARAM_KEY).toString();
  82.             }
  83.             int count = 0;
  84.             for (Object param : params) {
  85.                 /* 参数之间用,进行分隔 */
  86.                 if (0 != count) {
  87.                     key.append(',');
  88.                 }
  89.                 if (param == null) {
  90.                     key.append(NULL_PARAM_KEY);
  91.                 } else if (ClassUtils.isPrimitiveArray(param.getClass())) {
  92.                     int length = Array.getLength(param);
  93.                     for (int i = 0; i < length; i++) {
  94.                         key.append(Array.get(param, i));
  95.                         key.append(',');
  96.                     }
  97.                 } else if (ClassUtils.isPrimitiveOrWrapper(param.getClass()) || param instanceof String) {
  98.                     key.append(param);
  99.                 } else {
  100.                     /*JavaBean一定要重写hashCode和equals*/
  101.                     key.append(param.hashCode());
  102.                 }
  103.                 count++;
  104.             }
  105.             return key.toString();
  106.         };
  107.     }
  108. }

四、注解的使用

@Configuration： 用于定义配置类，可替换 xml 配置文件，被注解的类内部包含有一个或多个被 @Bean 注解的方法
@Bean： 用于定义加载类型
@CacheConfig：  一个类级别的注解，允许共享缓存的 cacheNames 、 KeyGenerator 、 CacheManager 和 CacheResolver. Cacheable 用来声明方法是可缓存的。将结果存储到缓存中以便后续使用相同参数调用时不需执行实际的方 法。直接从缓存中取值
@CachePut：  标注的方法在执行前不会去检查缓存中是否存在之前执行过的结果，而是每次都会执行该方法， 并将执行结果以键值对的形式存入指定的缓存中。
@CacheEvict ： 的作用 主要针对方法配置，能够根据一定的条件对缓存进行清空

1、增加注解

StudentServiceImpl：

类中使用@cacheable注解开启缓存

package com.mwy.code.service;
import com.mwy.code.mapper.StudentMapper;
import com.mwy.code.pojo.Student;
import com.mwy.code.util.PageBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class StudentServiceImpl implements StudentService {
    @Autowired
    private StudentMapper mapper;

    @Override
//    @Cacheable：会根据里面的内容生成一个组件 ,设置缓存名称为mm,cacheManager把缓存给缓存管理员，
    @Cacheable(cacheNames = "mm",cacheManager = "cacheManager")
    public List<Student> findPager(PageBean pageBean) {
        return mapper.selectAll();
    }
}

  这是第二次测试的结果，已经没有SQL语句了，在缓存中存在了

 查看缓存

2、查看缓存中是学生的

①、修改一下名字

在每一个结果前面加一个student关键字

cacheNames是缓存的名字用来做分类的，查看缓存时方便，可以在类上进行注解，表示所有的方法的缓存名字都为指定名字

package com.mwy.code.service;
import com.mwy.code.mapper.StudentMapper;
import com.mwy.code.pojo.Student;
import com.mwy.code.util.PageBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
@CacheConfig(cacheNames = "student")
public class StudentServiceImpl implements StudentService {
    @Autowired
    private StudentMapper mapper;

    @Override
//    @Cacheable：会根据里面的内容生成一个组件 ,设置缓存名称为mm,cacheManager把缓存给缓存管理员，
    @Cacheable(cacheManager = "cacheManager")
    public List<Student> findPager(PageBean pageBean) {
        return mapper.selectAll();
    }
}

②、测试

3、cacheManager：是缓存管理器

第一次运行会出现sql语句，然后数据会进入redis缓存中

①、修改cacheManager 

②、修改StudentServiceImpl

③、测试结果

4、keyGenerator方法用来生成缓存的主键 

①、RedisConfiguration中增加：

@Bean
@Primary
public KeyGenerator m1() {
    return (Object target, Method method, Object... params) -> {
        return LocalDate.now()+"";
    };
}

②、StudentServiceImpl：

key用来标识方法的结果，由键去找值，找不到进数据库，要去缓存用户信息，我们一般把用户的id作为键

spel表达式使用 # 取值

（1）cachePut用来更新缓存，用来做修改

（2）cacheEvict用来删除缓存，通过键key

 五、Template的使用

1、Template的使用

2、增加帮助类

  1. package com.mwy.code.util;
  2.  
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  4. import lombok.SneakyThrows;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.beans.BeansException;
  7. import org.springframework.context.ApplicationContext;
  8. import org.springframework.context.ApplicationContextAware;
  9. import org.springframework.data.redis.RedisSystemException;
  10. import org.springframework.data.redis.connection.DataType;
  11. import org.springframework.data.redis.connection.RedisConnection;
  12. import org.springframework.data.redis.connection.RedisStringCommands;
  13. import org.springframework.data.redis.connection.ReturnType;
  14. import org.springframework.data.redis.connection.jedis.JedisConnection;
  15. import org.springframework.data.redis.connection.lettuce.LettuceConnection;
  16. import org.springframework.data.redis.core.Cursor;
  17. import org.springframework.data.redis.core.RedisOperations;
  18. import org.springframework.data.redis.core.ScanOptions;
  19. import org.springframework.data.redis.core.StringRedisTemplate;
  20. import org.springframework.data.redis.core.ZSetOperations.TypedTuple;
  21. import org.springframework.data.redis.core.types.Expiration;
  22. import org.springframework.stereotype.Component;
  23.  
  24. import java.nio.charset.StandardCharsets;
  25. import java.time.Instant;
  26. import java.util.*;
  27. import java.util.Map.Entry;
  28. import java.util.concurrent.TimeUnit;
  29.  
  30. /**
  31.  * Redis工具类
  32.  * <p>
  33.  * 声明: 此工具只简单包装了redisTemplate的大部分常用的api,没有包装redisTemplate所有的api
  34.  * 如果对此工具类中的功能不太满意,或对StringRedisTemplate提供的api不太满意,
  35.  * 那么可自行实现相应的{@link StringRedisTemplate}类中的对应execute方法,以达
  36.  * 到自己想要的效果; 至于如何实现,则可参考源码或{@link LockOps}中的方法
  37.  * <p>
  38.  * 注: 此工具类依赖spring-boot-starter-data-redis类库
  39.  * 注: 更多javadoc细节,可详见{@link RedisOperations}
  40.  * <p>
  41.  * 统一说明一: 方法中的key、 value都不能为null
  42.  * 统一说明二: 不能跨数据类型进行操作,否者会操作失败/操作报错
  43.  * 如: 向一个String类型的做Hash操作,会失败/报错......等等
  44.  */
  45. @Slf4j
  46. @Component
  47. @SuppressWarnings("unused")
  48. public class RedisUtil implements ApplicationContextAware {
  49.  
  50.     /**
  51.      * 使用StringRedisTemplate(,其是RedisTemplate的定制化升级)
  52.      */
  53.     private static StringRedisTemplate redisTemplate;
  54.  
  55.     private static final ObjectMapper mapper = new ObjectMapper();
  56.  
  57.     @Override
  58.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  59.         RedisUtil.redisTemplate = applicationContext.getBean(StringRedisTemplate.class);
  60.     }
  61.  
  62.     /**
  63.      * key相关操作
  64.      */
  65.     public static class KeyOps {
  66.  
  67.         /**
  68.          * 根据key,删除redis中的对应key-value
  69.          * <p>
  70.          * 注: 若删除失败,则返回false
  71.          * <p>
  72.          * 若redis中,不存在该key,那么返回的也是false
  73.          * 所以,不能因为返回了false,就认为redis中一定还存
  74.          * 在该key对应的key-value
  75.          *
  76.          * @param key 要删除的key
  77.          * @return 删除是否成功
  78.          */
  79.         public static Boolean delete(String key) {
  80.             log.info("delete(...) => key -> {}", key);
  81.             // 返回值只可能为true/false,不可能为null
  82.             Boolean result = redisTemplate.delete(key);
  83.             log.info("delete(...) => result -> {}", result);
  84.             if (result == null) {
  85.                 throw new RedisOpsResultIsNullException();
  86.             }
  87.             return result;
  88.         }
  89.  
  90.         /**
  91.          * 根据keys,批量删除key-value
  92.          * <p>
  93.          * 注: 若redis中,不存在对应的key,那么计数不会加1,即:
  94.          * redis中存在的key-value里,有名为a1、a2的key,
  95.          * 删除时,传的集合是a1、a2、a3,那么返回结果为2
  96.          *
  97.          * @param keys 要删除的key集合
  98.          * @return 删除了的key-value个数
  99.          */
  100.         public static long delete(Collection<String> keys) {
  101.             log.info("delete(...) => keys -> {}", keys);
  102.             Long count = redisTemplate.delete(keys);
  103.             log.info("delete(...) => count -> {}", count);
  104.             if (count == null) {
  105.                 throw new RedisOpsResultIsNullException();
  106.             }
  107.             return count;
  108.         }
  109.  
  110.         /**
  111.          * 将key对应的value值进行序列化,并返回序列化后的value值
  112.          * <p>
  113.          * 注: 若不存在对应的key,则返回null
  114.          * 注: dump时,并不会删除redis中的对应key-value
  115.          * 注: dump功能与restore相反
  116.          *
  117.          * @param key 要序列化的value的key
  118.          * @return 序列化后的value值
  119.          */
  120.         public static byte[] dump(String key) {
  121.             log.info("dump(...) =>key -> {}", key);
  122.             byte[] result = redisTemplate.dump(key);
  123.             log.info("dump(...) => result -> {}", result);
  124.             return result;
  125.         }
  126.  
  127.         /**
  128.          * 将给定的value值,反序列化到redis中,形成新的key-value
  129.          *
  130.          * @param key        value对应的key
  131.          * @param value      要反序列的value值
  132.          *                   注: 这个值可以由{@link this#dump(String)}获得
  133.          * @param timeToLive 反序列化后的key-value的存活时长
  134.          * @param unit       timeToLive的单位
  135.          * @throws RedisSystemException 如果redis中已存在同样的key时,抛出此异常
  136.          */
  137.         public static void restore(String key, byte[] value, long timeToLive, TimeUnit unit) {
  138.             restore(key, value, timeToLive, unit, false);
  139.         }
  140.  
  141.         /**
  142.          * 将给定的value值,反序列化到redis中,形成新的key-value
  143.          *
  144.          * @param key     value对应的key
  145.          * @param value   要反序列的value值
  146.          *                注: 这个值可以由{@link this#dump(String)}获得
  147.          * @param timeout 反序列化后的key-value的存活时长
  148.          * @param unit    timeout的单位
  149.          * @param replace 若redis中已经存在了相同的key,是否替代原来的key-value
  150.          * @throws RedisSystemException 如果redis中已存在同样的key,且replace为false时,抛出此异常
  151.          */
  152.         public static void restore(String key, byte[] value, long timeout, TimeUnit unit, boolean replace) {
  153.             log.info("restore(...) => key -> {},value -> {},timeout -> {},unit -> {},replace -> {}",
  154.                     key, value, timeout, unit, replace);
  155.             redisTemplate.restore(key, value, timeout, unit, replace);
  156.         }
  157.  
  158.         /**
  159.          * redis中是否存在,指定key的key-value
  160.          *
  161.          * @param key 指定的key
  162.          * @return 是否存在对应的key-value
  163.          */
  164.         public static boolean hasKey(String key) {
  165.             log.info("hasKey(...) => key -> {}", key);
  166.             Boolean result = redisTemplate.hasKey(key);
  167.             log.info("hasKey(...) => result -> {}", result);
  168.             if (result == null) {
  169.                 throw new RedisOpsResultIsNullException();
  170.             }
  171.             return result;
  172.         }
  173.  
  174.         /**
  175.          * 给指定的key对应的key-value设置: 多久过时
  176.          * <p>
  177.          * 注:过时后,redis会自动删除对应的key-value
  178.          * 注:若key不存在,那么也会返回false
  179.          *
  180.          * @param key     指定的key
  181.          * @param timeout 过时时间
  182.          * @param unit    timeout的单位
  183.          * @return 操作是否成功
  184.          */
  185.         public static boolean expire(String key, long timeout, TimeUnit unit) {
  186.             log.info("expire(...) => key -> {},timeout -> {},unit -> {}", key, timeout, unit);
  187.             Boolean result = redisTemplate.expire(key, timeout, unit);
  188.             log.info("expire(...) => result is -> {}", result);
  189.             if (result == null) {
  190.                 throw new RedisOpsResultIsNullException();
  191.             }
  192.             return result;
  193.         }
  194.  
  195.         /**
  196.          * 给指定的key对应的key-value设置: 什么时候过时
  197.          * <p>
  198.          * 注:过时后,redis会自动删除对应的key-value
  199.          * 注:若key不存在,那么也会返回false
  200.          *
  201.          * @param key  指定的key
  202.          * @param date 啥时候过时
  203.          * @return 操作是否成功
  204.          */
  205.         public static boolean expireAt(String key, Date date) {
  206.             log.info("expireAt(...) => key -> {},date -> {}", key, date);
  207.             Boolean result = redisTemplate.expireAt(key, date);
  208.             log.info("expireAt(...) => result is -> {}", result);
  209.             if (result == null) {
  210.                 throw new RedisOpsResultIsNullException();
  211.             }
  212.             return result;
  213.         }
  214.  
  215.         /**
  216.          * 找到所有匹配pattern的key,并返回该key的结合.
  217.          * <p>
  218.          * 提示:若redis中键值对较多,此方法耗时相对较长,慎用！慎用！慎用！
  219.          *
  220.          * @param pattern 匹配模板
  221.          *                注: 常用的通配符有:
  222.          *                ?    有且只有一个;
  223.          *                *     >=0个;
  224.          * @return 匹配pattern的key的集合 可能为null
  225.          */
  226.         public static Set<String> keys(String pattern) {
  227.             log.info("keys(...) => pattern -> {}", pattern);
  228.             Set<String> keys = redisTemplate.keys(pattern);
  229.             log.info("keys(...) => keys -> {}", keys);
  230.             return keys;
  231.         }
  232.  
  233.         /**
  234.          * 将当前数据库中的key对应的key-value,移动到对应位置的数据库中
  235.          * <p>
  236.          * 注:单机版的redis,默认将存储分为16个db,index为0 到 15
  237.          * 注:同一个db下,key唯一； 但是在不同db中,key可以相同
  238.          * 注:若目标db下,已存在相同的key,那么move会失败,返回false
  239.          *
  240.          * @param key     定位要移动的key-value的key
  241.          * @param dbIndex 要移动到哪个db
  242.          * @return 移动是否成功
  243.          * 注: 若目标db下,已存在相同的key,那么move会失败,返回false
  244.          */
  245.         public static boolean move(String key, int dbIndex) {
  246.             log.info("move(...) => key  -> {},dbIndex -> {}", key, dbIndex);
  247.             Boolean result = redisTemplate.move(key, dbIndex);
  248.             log.info("move(...) =>result -> {}", result);
  249.             if (result == null) {
  250.                 throw new RedisOpsResultIsNullException();
  251.             }
  252.             return result;
  253.         }
  254.  
  255.         /**
  256.          * 移除key对应的key-value的过期时间,使该key-value一直存在
  257.          * <p>
  258.          * 注: 若key对应的key-value,本身就是一直存在(无过期时间的),那么persist方法会返回false;
  259.          * 若没有key对应的key-value存在,本那么persist方法会返回false;
  260.          *
  261.          * @param key 定位key-value的key
  262.          * @return 操作是否成功
  263.          */
  264.         public static boolean persist(String key) {
  265.             log.info("persist(...) => key -> {}", key);
  266.             Boolean result = redisTemplate.persist(key);
  267.             log.info("persist(...) => result -> {}", result);
  268.             if (result == null) {
  269.                 throw new RedisOpsResultIsNullException();
  270.             }
  271.             return result;
  272.         }
  273.  
  274.         /**
  275.          * 获取key对应的key-value的过期时间
  276.          * <p>
  277.          * 注: 若key-value永不过期,那么返回的为-1
  278.          * 注: 若不存在key对应的key-value,那么返回的为-2
  279.          * 注:若存在零碎时间不足1 SECONDS,则(大体上)四舍五入到SECONDS级别
  280.          *
  281.          * @param key 定位key-value的key
  282.          * @return 过期时间(单位s)
  283.          */
  284.         public static long getExpire(String key) {
  285.             return getExpire(key, TimeUnit.SECONDS);
  286.         }
  287.  
  288.         /**
  289.          * 获取key对应的key-value的过期时间
  290.          * <p>
  291.          * 注: 若key-value永不过期,那么返回的为-1
  292.          * 注: 若不存在key对应的key-value,那么返回的为-2
  293.          * 注:若存在零碎时间不足1 unit,则(大体上)四舍五入到unit别
  294.          *
  295.          * @param key 定位key-value的key
  296.          * @return 过期时间(单位unit)
  297.          */
  298.         public static long getExpire(String key, TimeUnit unit) {
  299.             log.info("getExpire(...) =>key -> {},unit is -> {}", key, unit);
  300.             Long result = redisTemplate.getExpire(key, unit);
  301.             log.info("getExpire(...) => result ->  {}", result);
  302.             if (result == null) {
  303.                 throw new RedisOpsResultIsNullException();
  304.             }
  305.             return result;
  306.         }
  307.  
  308.         /**
  309.          * 从redis的所有key中,随机获取一个key
  310.          * <p>
  311.          * 注: 若redis中不存在任何key-value,那么这里返回null
  312.          *
  313.          * @return 随机获取到的一个key
  314.          */
  315.         public static String randomKey() {
  316.             String result = redisTemplate.randomKey();
  317.             log.info("randomKey(...) => result is -> {}", result);
  318.             return result;
  319.         }
  320.  
  321.         /**
  322.          * 重命名对应的oldKey为新的newKey
  323.          * <p>
  324.          * 注: 若oldKey不存在,则会抛出异常.
  325.          * 注: 若redis中已存在与newKey一样的key,
  326.          * 那么原key-value会被丢弃,
  327.          * 只留下新的key,以及原来的value
  328.          * 示例说明: 假设redis中已有 (keyAlpha,valueAlpha) 和 (keyBeta,valueBeat),
  329.          * 在使用rename(keyAlpha,keyBeta)替换后,redis中只会剩下(keyBeta,valueAlpha)
  330.          *
  331.          * @param oldKey 旧的key
  332.          * @param newKey 新的key
  333.          * @throws RedisSystemException 若oldKey不存在时,抛出此异常
  334.          */
  335.         public static void rename(String oldKey, String newKey) {
  336.             log.info("rename(...) => oldKey -> {},newKey -> {}", oldKey, newKey);
  337.             redisTemplate.rename(oldKey, newKey);
  338.         }
  339.  
  340.         /**
  341.          * 当redis中不存在newKey时,重命名对应的oldKey为新的newKey
  342.          * 否者不进行重命名操作
  343.          * <p>
  344.          * 注: 若oldKey不存在,则会抛出异常.
  345.          *
  346.          * @param oldKey 旧的key
  347.          * @param newKey 新的key
  348.          * @throws RedisSystemException 若oldKey不存在时,抛出此异常
  349.          */
  350.         public static boolean renameIfAbsent(String oldKey, String newKey) {
  351.             log.info("renameIfAbsent(...) => oldKey -> {},newKey -> {}", oldKey, newKey);
  352.             Boolean result = redisTemplate.renameIfAbsent(oldKey, newKey);
  353.             log.info("renameIfAbsent(...) => result -> {}", result);
  354.             if (result == null) {
  355.                 throw new RedisOpsResultIsNullException();
  356.             }
  357.             return result;
  358.         }
  359.  
  360.         /**
  361.          * 获取key对应的value的数据类型
  362.          * <p>
  363.          * 注: 若redis中不存在该key对应的key-value,那么这里返回NONE
  364.          *
  365.          * @param key 用于定位的key
  366.          * @return key对应的value的数据类型
  367.          */
  368.         public static DataType type(String key) {
  369.             log.info("type(...) => key -> {}", key);
  370.             DataType result = redisTemplate.type(key);
  371.             log.info("type(...) => result -> {}", result);
  372.             return result;
  373.         }
  374.     }
  375.  
  376.     /**
  377.      * string相关操作
  378.      */
  379.     public static class StringOps {
  380.  
  381.         /**
  382.          * 设置key-value
  383.          * <p>
  384.          * 注: 若已存在相同的key,那么原来的key-value会被丢弃
  385.          *
  386.          * @param key   key
  387.          * @param value key对应的value
  388.          */
  389.         public static void set(String key, String value) {
  390.             log.info("set(...) => key -> {},value -> {}", key, value);
  391.             redisTemplate.opsForValue().set(key, value);
  392.         }
  393.  
  394.         /**
  395.          * 处理redis中key对应的value值,将第offset位的值,设置为1或0
  396.          * <p>
  397.          * 说明: 在redis中,存储的字符串都是以二级制的进行存在的; 如存储的key-value里,值为abc,实际上,
  398.          * 在redis里面存储的是011000010110001001100011,前8为对应a,中间8为对应b,后面8位对应c
  399.          * 示例：这里如果setBit(key,6,true)的话,就是将索引位置6的那个数,设置值为1,值就变成
  400.          * 了011000110110001001100011
  401.          * 追注:offset即index,从0开始
  402.          * <p>
  403.          * 注: 参数value为true,则设置为1；参数value为false,则设置为0
  404.          * <p>
  405.          * 注: 若redis中不存在对应的key,那么会自动创建新的
  406.          * 注: offset可以超过value在二进制下的索引长度
  407.          *
  408.          * @param key    定位value的key
  409.          * @param offset 要改变的bit的索引
  410.          * @param value  改为1或0,true - 改为1,false - 改为0
  411.          * @return set是否成功
  412.          */
  413.         public static boolean setBit(String key, long offset, boolean value) {
  414.             log.info("setBit(...) => key -> {},offset -> {},value -> {}", key, offset, value);
  415.             Boolean result = redisTemplate.opsForValue().setBit(key, offset, value);
  416.             log.info("setBit(...) => result -> {}", result);
  417.             if (result == null) {
  418.                 throw new RedisOpsResultIsNullException();
  419.             }
  420.             return result;
  421.         }
  422.  
  423.         /**
  424.          * 设置key-value
  425.          * <p>
  426.          * 注: 若已存在相同的key,那么原来的key-value会被丢弃
  427.          *
  428.          * @param key     key
  429.          * @param value   key对应的value
  430.          * @param timeout 过时时长
  431.          * @param unit    timeout的单位
  432.          */
  433.         public static void setEx(String key, String value, long timeout, TimeUnit unit) {
  434.             log.info("setEx(...) => key -> {},value -> {},timeout -> {},unit -> {}",
  435.                     key, value, timeout, unit);
  436.             redisTemplate.opsForValue().set(key, value, timeout, unit);
  437.         }
  438.  
  439.         /**
  440.          * 若不存在key时,向redis中添加key-value,返回成功/失败
  441.          * 若存在,则不作任何操作,返回false
  442.          *
  443.          * @param key   key
  444.          * @param value key对应的value
  445.          * @return set是否成功
  446.          */
  447.         public static boolean setIfAbsent(String key, String value) {
  448.             log.info("setIfAbsent(...) => key -> {},value -> {}", key, value);
  449.             Boolean result = redisTemplate.opsForValue().setIfAbsent(key, value);
  450.             log.info("setIfAbsent(...) => result -> {}", result);
  451.             if (result == null) {
  452.                 throw new RedisOpsResultIsNullException();
  453.             }
  454.             return result;
  455.         }
  456.  
  457.         /**
  458.          * 若不存在key时,向redis中添加一个(具有超时时长的)key-value,返回成功/失败
  459.          * 若存在,则不作任何操作,返回false
  460.          *
  461.          * @param key     key
  462.          * @param value   key对应的value
  463.          * @param timeout 超时时长
  464.          * @param unit    timeout的单位
  465.          * @return set是否成功
  466.          */
  467.         public static boolean setIfAbsent(String key, String value, long timeout, TimeUnit unit) {
  468.             log.info("setIfAbsent(...) => key -> {},value -> {},key -> {},value -> {}", key, value, timeout, unit);
  469.             Boolean result = redisTemplate.opsForValue().setIfAbsent(key, value, timeout, unit);
  470.             log.info("setIfAbsent(...) => result -> {}", result);
  471.             if (result == null) {
  472.                 throw new RedisOpsResultIsNullException();
  473.             }
  474.             return result;
  475.         }
  476.  
  477.         /**
  478.          * 从(redis中key对应的)value的offset位置起(包含该位置),用replaceValue替换对应长度的值
  479.          * <p>
  480.          * 举例说明:
  481.          * 1.假设redis中存在key-value ("ds","0123456789"); 调
  482.          * 用setRange("ds","abcdefghijk",3)后,redis中该value值就变为了[012abcdefghijk]
  483.          * <p>
  484.          * 2.假设redis中存在key-value ("jd","0123456789");调
  485.          * 用setRange("jd","xyz",3)后,redis中该value值就变为了[012xyz6789]
  486.          * <p>
  487.          * 3.假设redis中存在key-value ("ey","0123456789");调
  488.          * 用setRange("ey","qwer",15)后,redis中该value值就变为了[0123456789     qwer]
  489.          * 注:case3比较特殊,offset超过了原value的长度了,中间就会有一些空格来填充,但是如果在程序
  490.          * 中直接输出的话,中间那部分空格可能会出现乱码
  491.          *
  492.          * @param key          定位key-value的key
  493.          * @param replaceValue 要替换的值
  494.          * @param offset       起始位置
  495.          */
  496.         public static void setRange(String key, String replaceValue, long offset) {
  497.             log.info("setRange(...) => key -> {},replaceValue -> {},offset -> {}", key, replaceValue, offset);
  498.             redisTemplate.opsForValue().set(key, replaceValue, offset);
  499.         }
  500.  
  501.         /**
  502.          * 获取到key对应的value的长度
  503.          * <p>
  504.          * 注: 长度等于{@link String#length}
  505.          * 注: 若redis中不存在对应的key-value,则返回值为0.
  506.          *
  507.          * @param key 定位value的key
  508.          * @return value的长度
  509.          */
  510.         public static long size(String key) {
  511.             log.info("size(...) => key -> {}", key);
  512.             Long result = redisTemplate.opsForValue().size(key);
  513.             log.info("size(...) => result -> {}", result);
  514.             if (result == null) {
  515.                 throw new RedisOpsResultIsNullException();
  516.             }
  517.             return result;
  518.         }
  519.  
  520.         /**
  521.          * 批量设置 key-value
  522.          * <p>
  523.          * 注: 若存在相同的key,则原来的key-value会被丢弃
  524.          *
  525.          * @param maps key-value 集
  526.          */
  527.         public static void multiSet(Map<String, String> maps) {
  528.             log.info("multiSet(...) => maps -> {}", maps);
  529.             redisTemplate.opsForValue().multiSet(maps);
  530.         }
  531.  
  532.         /**
  533.          * 当redis中,不存在任何一个keys时,才批量设置 key-value,并返回成功/失败.
  534.          * 否者,不进行任何操作,并返回false
  535.          * <p>
  536.          * 即: 假设调用此方法时传入的参数map是这样的: {k1=v1,k2=v2,k3=v3}
  537.          * 那么redis中,k1、k2、k3都不存在时,才会批量设置key-value;
  538.          * 否则不会设置任何key-value
  539.          * <p>
  540.          * 注: 若存在相同的key,则原来的key-value会被丢弃
  541.          * <p>
  542.          * 注:
  543.          *
  544.          * @param maps key-value 集
  545.          * @return 操作是否成功
  546.          */
  547.         public static boolean multiSetIfAbsent(Map<String, String> maps) {
  548.             log.info("multiSetIfAbsent(...) => maps -> {}", maps);
  549.             Boolean result = redisTemplate.opsForValue().multiSetIfAbsent(maps);
  550.             log.info("multiSetIfAbsent(...) => result -> {}", result);
  551.             if (result == null) {
  552.                 throw new RedisOpsResultIsNullException();
  553.             }
  554.             return result;
  555.         }
  556.  
  557.         /**
  558.          * 增/减 整数
  559.          * <p>
  560.          * 注: 负数则为减
  561.          * 注: 若key对应的value值不支持增/减操作(即: value不是数字),那么会
  562.          * 抛出org.springframework.data.redis.RedisSystemException
  563.          *
  564.          * @param key       用于定位value的key
  565.          * @param increment 增加多少
  566.          * @return 增加后的总值
  567.          * @throws RedisSystemException key对应的value值不支持增/减操作时
  568.          */
  569.         public static long incrBy(String key, long increment) {
  570.             log.info("incrBy(...) => key -> {},increment -> {}", key, increment);
  571.             Long result = redisTemplate.opsForValue().increment(key, increment);
  572.             log.info("incrBy(...) => result -> {}", result);
  573.             if (result == null) {
  574.                 throw new RedisOpsResultIsNullException();
  575.             }
  576.             return result;
  577.         }
  578.  
  579.         /**
  580.          * 增/减 浮点数
  581.          * <p>
  582.          * 注: 慎用浮点数,会有精度问题
  583.          * 如: 先 RedisUtil.StringOps.set("ds","123");
  584.          * 然后再RedisUtil.StringOps.incrByFloat("ds",100.6);
  585.          * 就会看到精度问题
  586.          * 注: 负数则为减
  587.          * 注: 若key对应的value值不支持增/减操作(即: value不是数字),那么会
  588.          * 抛出org.springframework.data.redis.RedisSystemException
  589.          *
  590.          * @param key       用于定位value的key
  591.          * @param increment 增加多少
  592.          * @return 增加后的总值
  593.          * @throws RedisSystemException key对应的value值不支持增/减操作时
  594.          */
  595.         public static double incrByFloat(String key, double increment) {
  596.             log.info("incrByFloat(...) => key -> {},increment -> {}", key, increment);
  597.             Double result = redisTemplate.opsForValue().increment(key, increment);
  598.             log.info("incrByFloat(...) => result -> {}", result);
  599.             if (result == null) {
  600.                 throw new RedisOpsResultIsNullException();
  601.             }
  602.             return result;
  603.         }
  604.  
  605.         /**
  606.          * 追加值到末尾
  607.          * <p>
  608.          * 注: 当redis中原本不存在key时,那么（从效果上来看）此方法就等价于{@link this#set(String, String)}
  609.          *
  610.          * @param key   定位value的key
  611.          * @param value 要追加的value值
  612.          * @return 追加后, 整个value的长度
  613.          */
  614.         public static int append(String key, String value) {
  615.             log.info("append(...) => key -> {},value -> {}", key, value);
  616.             Integer result = redisTemplate.opsForValue().append(key, value);
  617.             log.info("append(...) => result -> {}", result);
  618.             if (result == null) {
  619.                 throw new RedisOpsResultIsNullException();
  620.             }
  621.             return result;
  622.         }
  623.  
  624.         /**
  625.          * 根据key,获取到对应的value值
  626.          *
  627.          * @param key key-value对应的key
  628.          * @return 该key对应的值
  629.          * 注: 若key不存在,则返回null
  630.          */
  631.         public static String get(String key) {
  632.             log.info("get(...) => key -> {}", key);
  633.             String result = redisTemplate.opsForValue().get(key);
  634.             log.info("get(...) => result -> {} ", result);
  635.             return result;
  636.         }
  637.  
  638.         /**
  639.          * 对(key对应的)value进行截取,截取范围为[start,end]
  640.          * <p>
  641.          * 注: 若[start,end]的范围不在value的范围中,那么返回的是空字符串 ""
  642.          * 注: 若value只有一部分在[start,end]的范围中,那么返回的是value对应部分的内容(即:不足的地方,并不会以空来填充)
  643.          *
  644.          * @param key   定位value的key
  645.          * @param start 起始位置 (从0开始)
  646.          * @param end   结尾位置 (从0开始)
  647.          * @return 截取后的字符串
  648.          */
  649.         public static String getRange(String key, long start, long end) {
  650.             log.info("getRange(...) => kry -> {}", key);
  651.             String result = redisTemplate.opsForValue().get(key, start, end);
  652.             log.info("getRange(...) => result -> {} ", result);
  653.             return result;
  654.         }
  655.  
  656.         /**
  657.          * 给指定key设置新的value,并返回旧的value
  658.          * <p>
  659.          * 注: 若redis中不存在key,那么此操作仍然可以成功,不过返回的旧值是null
  660.          *
  661.          * @param key      定位value的key
  662.          * @param newValue 要为该key设置的新的value值
  663.          * @return 旧的value值
  664.          */
  665.         public static String getAndSet(String key, String newValue) {
  666.             log.info("getAndSet(...) => key -> {},value -> {}", key, newValue);
  667.             String oldValue = redisTemplate.opsForValue().getAndSet(key, newValue);
  668.             log.info("getAndSet(...) => oldValue -> {}", oldValue);
  669.             return oldValue;
  670.         }
  671.  
  672.         /**
  673.          * 获取(key对应的)value在二进制下,offset位置的bit值
  674.          * <p>
  675.          * 注: 当offset的值在(二进制下的value的)索引范围外时,返回的也是false
  676.          * <p>
  677.          * 示例:
  678.          * RedisUtil.StringOps.set("akey","a");
  679.          * 字符串a,转换为二进制为01100001
  680.          * 那么getBit("akey",6)获取到的结果为false
  681.          *
  682.          * @param key    定位value的key
  683.          * @param offset 定位bit的索引
  684.          * @return offset位置对应的bit的值(true - 1, false - 0)
  685.          */
  686.         public static boolean getBit(String key, long offset) {
  687.             log.info("getBit(...) => key -> {},offset -> {}", key, offset);
  688.             Boolean result = redisTemplate.opsForValue().getBit(key, offset);
  689.             log.info("getBit(...) => result -> {}", result);
  690.             if (result == null) {
  691.                 throw new RedisOpsResultIsNullException();
  692.             }
  693.             return result;
  694.         }
  695.  
  696.         /**
  697.          * 批量获取value值
  698.          * <p>
  699.          * 注: 若redis中,对应的key不存在,那么该key对应的返回的value值为null
  700.          *
  701.          * @param keys key集
  702.          * @return value值集合
  703.          */
  704.         public static List<String> multiGet(Collection<String> keys) {
  705.             log.info("multiGet(...) => keys -> {}", keys);
  706.             List<String> result = redisTemplate.opsForValue().multiGet(keys);
  707.             log.info("multiGet(...) => result -> {}", result);
  708.             return result;
  709.         }
  710.     }
  711.  
  712.     /**
  713.      * hash相关操作
  714.      * <p>
  715.      * 提示: 简单的,可以将redis中hash的数据结构看作是 Map<String,Map<HK,HV>>
  716.      */
  717.     public static class HashOps {
  718.  
  719.         /**
  720.          * 向key对应的hash中,增加一个键值对entryKey-entryValue
  721.          * <p>
  722.          * 注: 同一个hash里面,若已存在相同的entryKey,那么此操作将丢弃原来的entryKey-entryValue,
  723.          * 而使用新的entryKey-entryValue
  724.          *
  725.          * @param key        定位hash的key
  726.          * @param entryKey   要向hash中增加的键值对里的 键
  727.          * @param entryValue 要向hash中增加的键值对里的 值
  728.          */
  729.         public static void hPut(String key, String entryKey, String entryValue) {
  730.             log.info("hPut(...) => key -> {},entryKey -> {},entryValue -> {}", key, entryKey, entryValue);
  731.             redisTemplate.opsForHash().put(key, entryKey, entryValue);
  732.         }
  733.  
  734.         /**
  735.          * 向key对应的hash中,增加maps(即: 批量增加entry集)
  736.          * <p>
  737.          * 注: 同一个hash里面,若已存在相同的entryKey,那么此操作将丢弃原来的entryKey-entryValue,
  738.          * 而使用新的entryKey-entryValue
  739.          *
  740.          * @param key  定位hash的key
  741.          * @param maps 要向hash中增加的键值对集
  742.          */
  743.         public static void hPutAll(String key, Map<String, String> maps) {
  744.             log.info("hPutAll(...) => key -> {},maps -> {}", key, maps);
  745.             redisTemplate.opsForHash().putAll(key, maps);
  746.         }
  747.  
  748.         /**
  749.          * 当key对应的hash中,不存在entryKey时,才(向key对应的hash中,)增加entryKey-entryValue
  750.          * 否则,不进行任何操作
  751.          *
  752.          * @param key        定位hash的key
  753.          * @param entryKey   要向hash中增加的键值对里的 键
  754.          * @param entryValue 要向hash中增加的键值对里的 值
  755.          * @return 操作是否成功
  756.          */
  757.         public static boolean hPutIfAbsent(String key, String entryKey, String entryValue) {
  758.             log.info("hPutIfAbsent(...) => key -> {},entryKey -> {},entryValue -> {}",
  759.                     key, entryKey, entryValue);
  760.             Boolean result = redisTemplate.opsForHash().putIfAbsent(key, entryKey, entryValue);
  761.             log.info("hPutIfAbsent(...) => result -> {}", result);
  762.             if (result != null) {
  763.                 throw new RedisOpsResultIsNullException();
  764.             }
  765.             return result;
  766.         }
  767.  
  768.         /**
  769.          * 获取到key对应的hash里面的对应字段的值
  770.          * <p>
  771.          * 注: 若redis中不存在对应的key,则返回null
  772.          * 若key对应的hash中不存在对应的entryKey,也会返回null
  773.          *
  774.          * @param key      定位hash的key
  775.          * @param entryKey 定位hash里面的entryValue的entryKey
  776.          * @return key对应的hash里的entryKey对应的entryValue值
  777.          */
  778.         public static Object hGet(String key, String entryKey) {
  779.             log.info("hGet(...) => key -> {},entryKey -> {}", key, entryKey);
  780.             Object entryValue = redisTemplate.opsForHash().get(key, entryKey);
  781.             log.info("hGet(...) => entryValue -> {}", entryValue);
  782.             return entryValue;
  783.         }
  784.  
  785.         /**
  786.          * 获取到key对应的hash(即: 获取到key对应的Map<HK,HV>)
  787.          * <p>
  788.          * 注: 若redis中不存在对应的key,则返回一个没有任何entry的空的Map(,而不是返回null)
  789.          *
  790.          * @param key 定位hash的key
  791.          * @return key对应的hash
  792.          */
  793.         public static Map<Object, Object> hGetAll(String key) {
  794.             log.info("hGetAll(...) => key -> {}", key);
  795.             Map<Object, Object> result = redisTemplate.opsForHash().entries(key);
  796.             log.info("hGetAll(...) => result -> {}", result);
  797.             return result;
  798.         }
  799.  
  800.         /**
  801.          * 批量获取(key对应的)hash中的entryKey的entryValue
  802.          * <p>
  803.          * 注: 若hash中对应的entryKey不存在,那么返回的对应的entryValue值为null
  804.          * 注: redis中key不存在,那么返回的List中,每个元素都为null
  805.          * 追注: 这个List本身不为null,size也不为0,只是每个list中的每个元素为null而已
  806.          *
  807.          * @param key       定位hash的key
  808.          * @param entryKeys 需要获取的hash中的字段集
  809.          * @return hash中对应entryKeys的对应entryValue集
  810.          */
  811.         public static List<Object> hMultiGet(String key, Collection<Object> entryKeys) {
  812.             log.info("hMultiGet(...) => key -> {},entryKeys -> {}", key, entryKeys);
  813.             List<Object> entryValues = redisTemplate.opsForHash().multiGet(key, entryKeys);
  814.             log.info("hMultiGet(...) => entryValues -> {}", entryValues);
  815.             return entryValues;
  816.         }
  817.  
  818.         /**
  819.          * (批量)删除(key对应的)hash中的对应entryKey-entryValue
  820.          * <p>
  821.          * 注: 1、若redis中不存在对应的key,则返回0;
  822.          * 2、若要删除的entryKey,在key对应的hash中不存在,在count不会+1,如:
  823.          * RedisUtil.HashOps.hPut("ds","name","邓沙利文");
  824.          * RedisUtil.HashOps.hPut("ds","birthday","1994-02-05");
  825.          * RedisUtil.HashOps.hPut("ds","hobby","女");
  826.          * 则调用RedisUtil.HashOps.hDelete("ds","name","birthday","hobby","non-exist-entryKey")
  827.          * 的返回结果为3
  828.          * 注: 若(key对应的)hash中的所有entry都被删除了,那么该key也会被删除
  829.          *
  830.          * @param key       定位hash的key
  831.          * @param entryKeys 定位要删除的entryKey-entryValue的entryKey
  832.          * @return 删除了对应hash中多少个entry
  833.          */
  834.         public static long hDelete(String key, Object... entryKeys) {
  835.             log.info("hDelete(...) => key -> {},entryKeys -> {}", key, entryKeys);
  836.             Long count = redisTemplate.opsForHash().delete(key, entryKeys);
  837.             log.info("hDelete(...) => count -> {}", count);
  838.             if (count == null) {
  839.                 throw new RedisOpsResultIsNullException();
  840.             }
  841.             return count;
  842.         }
  843.  
  844.         /**
  845.          * 查看(key对应的)hash中,是否存在entryKey对应的entry
  846.          * <p>
  847.          * 注: 若redis中不存在key,则返回false
  848.          * 注: 若key对应的hash中不存在对应的entryKey,也会返回false
  849.          *
  850.          * @param key      定位hash的key
  851.          * @param entryKey 定位hash中entry的entryKey
  852.          * @return hash中是否存在entryKey对应的entry.
  853.          */
  854.         public static boolean hExists(String key, String entryKey) {
  855.             log.info("hDelete(...) => key -> {},entryKeys -> {}", key, entryKey);
  856.             Boolean exist = redisTemplate.opsForHash().hasKey(key, entryKey);
  857.             log.info("hDelete(...) => exist -> {}", exist);
  858.             return exist;
  859.         }
  860.  
  861.         /**
  862.          * 增/减(hash中的某个entryValue值) 整数
  863.          * <p>
  864.          * 注: 负数则为减
  865.          * 注: 若key不存在,那么会自动创建对应的hash,并创建对应的entryKey、entryValue,entryValue的初始值为increment
  866.          * 注: 若entryKey不存在,那么会自动创建对应的entryValue,entryValue的初始值为increment
  867.          * 注: 若key对应的value值不支持增/减操作(即: value不是数字),那么会
  868.          * 抛出org.springframework.data.redis.RedisSystemException
  869.          *
  870.          * @param key       用于定位hash的key
  871.          * @param entryKey  用于定位entryValue的entryKey
  872.          * @param increment 增加多少
  873.          * @return 增加后的总值
  874.          * @throws RedisSystemException key对应的value值不支持增/减操作时
  875.          */
  876.         public static long hIncrBy(String key, Object entryKey, long increment) {
  877.             log.info("hIncrBy(...) => key -> {},entryKey -> {},increment -> {}",
  878.                     key, entryKey, increment);
  879.             Long result = redisTemplate.opsForHash().increment(key, entryKey, increment);
  880.             log.info("hIncrBy(...) => result -> {}", result);
  881.             if (result == null) {
  882.                 throw new RedisOpsResultIsNullException();
  883.             }
  884.             return result;
  885.         }
  886.  
  887.         /**
  888.          * 增/减(hash中的某个entryValue值) 浮点数
  889.          * <p>
  890.          * 注: 负数则为减
  891.          * 注: 若key不存在,那么会自动创建对应的hash,并创建对应的entryKey、entryValue,entryValue的初始值为increment
  892.          * 注: 若entryKey不存在,那么会自动创建对应的entryValue,entryValue的初始值为increment
  893.          * 注: 若key对应的value值不支持增/减操作(即: value不是数字),那么会
  894.          * 抛出org.springframework.data.redis.RedisSystemException
  895.          * 注: 因为是浮点数,所以可能会和{@link StringOps#incrByFloat(String, double)}一样,出现精度问题
  896.          * 追注: 本人简单测试了几组数据,暂未出现精度问题
  897.          *
  898.          * @param key       用于定位hash的key
  899.          * @param entryKey  用于定位entryValue的entryKey
  900.          * @param increment 增加多少
  901.          * @return 增加后的总值
  902.          * @throws RedisSystemException key对应的value值不支持增/减操作时
  903.          */
  904.         public static double hIncrByFloat(String key, Object entryKey, double increment) {
  905.             log.info("hIncrByFloat(...) => key -> {},entryKey -> {},increment -> {}",
  906.                     key, entryKey, increment);
  907.             Double result = redisTemplate.opsForHash().increment(key, entryKey, increment);
  908.             log.info("hIncrByFloat(...) => result -> {}", result);
  909.             if (result == null) {
  910.                 throw new RedisOpsResultIsNullException();
  911.             }
  912.             return result;
  913.         }
  914.  
  915.         /**
  916.          * 获取(key对应的)hash中的所有entryKey
  917.          * <p>
  918.          * 注: 若key不存在,则返回的是一个空的Set(,而不是返回null)
  919.          *
  920.          * @param key 定位hash的key
  921.          * @return hash中的所有entryKey
  922.          */
  923.         public static Set<Object> hKeys(String key) {
  924.             log.info("hKeys(...) => key -> {}", key);
  925.             Set<Object> entryKeys = redisTemplate.opsForHash().keys(key);
  926.             log.info("hKeys(...) => entryKeys -> {}", entryKeys);
  927.             return entryKeys;
  928.         }
  929.  
  930.         /**
  931.          * 获取(key对应的)hash中的所有entryValue
  932.          * <p>
  933.          * 注: 若key不存在,则返回的是一个空的List(,而不是返回null)
  934.          *
  935.          * @param key 定位hash的key
  936.          * @return hash中的所有entryValue
  937.          */
  938.         public static List<Object> hValues(String key) {
  939.             log.info("hValues(...) => key -> {}", key);
  940.             List<Object> entryValues = redisTemplate.opsForHash().values(key);
  941.             log.info("hValues(...) => entryValues -> {}", entryValues);
  942.             return entryValues;
  943.         }
  944.  
  945.         /**
  946.          * 获取(key对应的)hash中的所有entry的数量
  947.          * <p>
  948.          * 注: 若redis中不存在对应的key,则返回值为0
  949.          *
  950.          * @param key 定位hash的key
  951.          * @return (key对应的)hash中, entry的个数
  952.          */
  953.         public static long hSize(String key) {
  954.             log.info("hSize(...) => key -> {}", key);
  955.             Long count = redisTemplate.opsForHash().size(key);
  956.             log.info("hSize(...) => count -> {}", count);
  957.             if (count == null) {
  958.                 throw new RedisOpsResultIsNullException();
  959.             }
  960.             return count;
  961.         }
  962.  
  963.         /**
  964.          * 根据options匹配到(key对应的)hash中的对应的entryKey,并返回对应的entry集
  965.          * <p>
  966.          * <p>
  967.          * 注: ScanOptions实例的创建方式举例:
  968.          * 1、ScanOptions.NONE
  969.          * 2、ScanOptions.scanOptions().match("n??e").build()
  970.          *
  971.          * @param key     定位hash的key
  972.          * @param options 匹配entryKey的条件
  973.          *                注: ScanOptions.NONE表示全部匹配
  974.          *                注: ScanOptions.scanOptions().match(pattern).build()表示按照pattern匹配,
  975.          *                其中pattern中可以使用通配符 * ? 等,
  976.          *                * 表示>=0个字符
  977.          *                ？ 表示有且只有一个字符
  978.          *                此处的匹配规则与{@link KeyOps#keys(String)}处的一样
  979.          * @return 匹配到的(key对应的)hash中的entry
  980.          */
  981.         @SneakyThrows
  982.         public static Cursor<Entry<Object, Object>> hScan(String key, ScanOptions options) {
  983.             log.info("hScan(...) => key -> {},options -> {}", key, mapper.writeValueAsString(options));
  984.             Cursor<Entry<Object, Object>> cursor = redisTemplate.opsForHash().scan(key, options);
  985.             log.info("hScan(...) => cursor -> {}", mapper.writeValueAsString(cursor));
  986.             return cursor;
  987.         }
  988.     }
  989.  
  990.     /**
  991.      * list相关操作
  992.      * <p>
  993.      * 提示: 列表中的元素,可以重复
  994.      * <p>
  995.      * 提示: list是有序的
  996.      * <p>
  997.      * 提示: redis中的list中的索引,可分为两类,这两类都可以用来定位list中元素:
  998.      * 类别一: 从left到right,是从0开始依次增大:   0, 1, 2, 3...
  999.      * 类别二: 从right到left,是从-1开始依次减小: -1,-2,-3,-4...
  1000.      */
  1001.     public static class ListOps {
  1002.  
  1003.         /**
  1004.          * 从左端推入元素进列表
  1005.          * <p>
  1006.          * 注: 若redis中不存在对应的key,那么会自动创建
  1007.          *
  1008.          * @param key  定位list的key
  1009.          * @param item 要推入list的元素
  1010.          * @return 推入后, (key对应的)list的size
  1011.          */
  1012.         public static long lLeftPush(String key, String item) {
  1013.             log.info("lLeftPush(...) => key -> {},item -> {}", key, item);
  1014.             Long size = redisTemplate.opsForList().leftPush(key, item);
  1015.             log.info("lLeftPush(...) => size -> {}", size);
  1016.             if (size == null) {
  1017.                 throw new RedisOpsResultIsNullException();
  1018.             }
  1019.             return size;
  1020.         }
  1021.  
  1022.         /**
  1023.          * 从左端批量推入元素进列表
  1024.          * <p>
  1025.          * 注: 若redis中不存在对应的key,那么会自动创建
  1026.          * 注: 这一批item中,先push左侧的,后push右侧的
  1027.          *
  1028.          * @param key   定位list的key
  1029.          * @param items 要批量推入list的元素集
  1030.          * @return 推入后, (key对应的)list的size
  1031.          */
  1032.         public static long lLeftPushAll(String key, String... items) {
  1033.             log.info("lLeftPushAll(...) => key -> {},items -> {}", key, items);
  1034.             Long size = redisTemplate.opsForList().leftPushAll(key, items);
  1035.             log.info("lLeftPushAll(...) => size -> {}", size);
  1036.             if (size == null) {
  1037.                 throw new RedisOpsResultIsNullException();
  1038.             }
  1039.             return size;
  1040.         }
  1041.  
  1042.         /**
  1043.          * 从左端批量推入元素进列表
  1044.          * <p>
  1045.          * 注: 若redis中不存在对应的key,那么会自动创建
  1046.          * 注: 这一批item中,那个item先从Collection取出来,就先push哪个
  1047.          *
  1048.          * @param key   定位list的key
  1049.          * @param items 要批量推入list的元素集
  1050.          * @return 推入后, (key对应的)list的size
  1051.          */
  1052.         public static long lLeftPushAll(String key, Collection<String> items) {
  1053.             log.info("lLeftPushAll(...) => key -> {},items -> {}", key, items);
  1054.             Long size = redisTemplate.opsForList().leftPushAll(key, items);
  1055.             log.info("lLeftPushAll(...) => size -> {}", size);
  1056.             if (size == null) {
  1057.                 throw new RedisOpsResultIsNullException();
  1058.             }
  1059.             return size;
  1060.         }
  1061.  
  1062.         /**
  1063.          * 如果redis中存在key,则从左端批量推入元素进列表;
  1064.          * 否则,不进行任何操作
  1065.          *
  1066.          * @param key  定位list的key
  1067.          * @param item 要推入list的项
  1068.          * @return 推入后, (key对应的)list的size
  1069.          */
  1070.         public static long lLeftPushIfPresent(String key, String item) {
  1071.             log.info("lLeftPushIfPresent(...) => key -> {},item -> {}", key, item);
  1072.             Long size = redisTemplate.opsForList().leftPushIfPresent(key, item);
  1073.             log.info("lLeftPushIfPresent(...) => size -> {}", size);
  1074.             if (size == null) {
  1075.                 throw new RedisOpsResultIsNullException();
  1076.             }
  1077.             return size;
  1078.         }
  1079.  
  1080.         /**
  1081.          * 若key对应的list中存在pivot项,那么将item放入第一个pivot项前(即:放在第一个pivot项左边);
  1082.          * 若key对应的list中不存在pivot项,那么不做任何操作,直接返回-1
  1083.          * <p>
  1084.          * 注: 若redis中不存在对应的key,那么会自动创建
  1085.          *
  1086.          * @param key  定位list的key
  1087.          * @param item 要推入list的元素
  1088.          * @return 推入后, (key对应的)list的size
  1089.          */
  1090.         public static long lLeftPush(String key, String pivot, String item) {
  1091.             log.info("lLeftPush(...) => key -> {},pivot -> {},item -> {}", key, pivot, item);
  1092.             Long size = redisTemplate.opsForList().leftPush(key, pivot, item);
  1093.             log.info("lLeftPush(...) => size -> {}", size);
  1094.             if (size == null) {
  1095.                 throw new RedisOpsResultIsNullException();
  1096.             }
  1097.             return size;
  1098.         }
  1099.  
  1100.         /**
  1101.          * 与{@link ListOps#lLeftPush(String, String)}类比即可,不过是从list右侧推入元素
  1102.          */
  1103.         public static long lRightPush(String key, String item) {
  1104.             log.info("lRightPush(...) => key -> {},item -> {}", key, item);
  1105.             Long size = redisTemplate.opsForList().rightPush(key, item);
  1106.             log.info("lRightPush(...) => size -> {}", size);
  1107.             if (size == null) {
  1108.                 throw new RedisOpsResultIsNullException();
  1109.             }
  1110.             return size;
  1111.         }
  1112.  
  1113.         /**
  1114.          * 与{@link ListOps#lLeftPushAll(String, String...)}类比即可,不过是从list右侧推入元素
  1115.          */
  1116.         public static long lRightPushAll(String key, String... items) {
  1117.             log.info("lRightPushAll(...) => key -> {},items -> {}", key, items);
  1118.             Long size = redisTemplate.opsForList().rightPushAll(key, items);
  1119.             log.info("lRightPushAll(...) => size -> {}", size);
  1120.             if (size == null) {
  1121.                 throw new RedisOpsResultIsNullException();
  1122.             }
  1123.             return size;
  1124.         }
  1125.  
  1126.         /**
  1127.          * 与{@link ListOps#lLeftPushAll(String, Collection<String>)}类比即可,不过是从list右侧推入元素
  1128.          */
  1129.         public static long lRightPushAll(String key, Collection<String> items) {
  1130.             log.info("lRightPushAll(...) => key -> {},items -> {}", key, items);
  1131.             Long size = redisTemplate.opsForList().rightPushAll(key, items);
  1132.             log.info("lRightPushAll(...) => size -> {}", size);
  1133.             if (size == null) {
  1134.                 throw new RedisOpsResultIsNullException();
  1135.             }
  1136.             return size;
  1137.         }
  1138.  
  1139.         /**
  1140.          * 与{@link ListOps#lLeftPushIfPresent(String, String)}类比即可,不过是从list右侧推入元素
  1141.          */
  1142.         public static long lRightPushIfPresent(String key, String item) {
  1143.             log.info("lRightPushIfPresent(...) => key -> {},item -> {}", key, item);
  1144.             Long size = redisTemplate.opsForList().rightPushIfPresent(key, item);
  1145.             log.info("lRightPushIfPresent(...) => size -> {}", size);
  1146.             if (size == null) {
  1147.                 throw new RedisOpsResultIsNullException();
  1148.             }
  1149.             return size;
  1150.         }
  1151.  
  1152.         /**
  1153.          * 与{@link ListOps#lLeftPush(String, String, String)}类比即可,不过是从list右侧推入元素
  1154.          */
  1155.         public static long lRightPush(String key, String pivot, String item) {
  1156.             log.info("lLeftPush(...) => key -> {},pivot -> {},item -> {}", key, pivot, item);
  1157.             Long size = redisTemplate.opsForList().rightPush(key, pivot, item);
  1158.             log.info("lLeftPush(...) => size -> {}", size);
  1159.             if (size == null) {
  1160.                 throw new RedisOpsResultIsNullException();
  1161.             }
  1162.             return size;
  1163.         }
  1164.  
  1165.         /**
  1166.          * 【非阻塞队列】 从左侧移出(key对应的)list中的第一个元素,并将该元素返回
  1167.          * <p>
  1168.          * 注: 此方法是非阻塞的,即: 若(key对应的)list中的所有元素都被pop移出了,此时,再进行pop的话,会立即返回null
  1169.          * 注: 此方法是非阻塞的,即: 若redis中不存在对应的key,那么会立即返回null
  1170.          * 注: 若将(key对应的)list中的所有元素都pop完了,那么该key会被删除
  1171.          *
  1172.          * @param key 定位list的key
  1173.          * @return 移出的那个元素
  1174.          */
  1175.         public static String lLeftPop(String key) {
  1176.             log.info("lLeftPop(...) => key -> {}", key);
  1177.             String item = redisTemplate.opsForList().leftPop(key);
  1178.             log.info("lLeftPop(...) => item -> {}", item);
  1179.             return item;
  1180.         }
  1181.  
  1182.         /**
  1183.          * 【阻塞队列】 从左侧移出(key对应的)list中的第一个元素,并将该元素返回
  1184.          * <p>
  1185.          * 注: 此方法是阻塞的,即: 若(key对应的)list中的所有元素都被pop移出了,此时,再进行pop的话,
  1186.          * 会阻塞timeout这么久,然后返回null
  1187.          * 注: 此方法是阻塞的,即: 若redis中不存在对应的key,那么会阻塞timeout这么久,然后返回null
  1188.          * 注: 若将(key对应的)list中的所有元素都pop完了,那么该key会被删除
  1189.          * <p>
  1190.          * 提示: 若阻塞过程中,目标key-list出现了,且里面有item了,那么会立马停止阻塞,进行元素移出并返回
  1191.          *
  1192.          * @param key     定位list的key
  1193.          * @param timeout 超时时间
  1194.          * @param unit    timeout的单位
  1195.          * @return 移出的那个元素
  1196.          */
  1197.         public static String lLeftPop(String key, long timeout, TimeUnit unit) {
  1198.             log.info("lLeftPop(...) => key -> {},timeout -> {},unit -> {}", key, timeout, unit);
  1199.             String item = redisTemplate.opsForList().leftPop(key, timeout, unit);
  1200.             log.info("lLeftPop(...) => item -> {}", item);
  1201.             return item;
  1202.         }
  1203.  
  1204.         /**
  1205.          * 与{@link ListOps#lLeftPop(String)}类比即可,不过是从list右侧移出元素
  1206.          */
  1207.         public static String lRightPop(String key) {
  1208.             log.info("lRightPop(...) => key -> {}", key);
  1209.             String item = redisTemplate.opsForList().rightPop(key);
  1210.             log.info("lRightPop(...) => item -> {}", item);
  1211.             return item;
  1212.         }
  1213.  
  1214.         /**
  1215.          * 与{@link ListOps#lLeftPop(String, long, TimeUnit)}类比即可,不过是从list右侧移出元素
  1216.          */
  1217.         public static String lRightPop(String key, long timeout, TimeUnit unit) {
  1218.             log.info("lRightPop(...) => key -> {},timeout -> {},unit -> {}", key, timeout, unit);
  1219.             String item = redisTemplate.opsForList().rightPop(key, timeout, unit);
  1220.             log.info("lRightPop(...) => item -> {}", item);
  1221.             return item;
  1222.         }
  1223.  
  1224.         /**
  1225.          * 【非阻塞队列】 从sourceKey对应的sourceList右侧移出一个item,并将这个item推
  1226.          * 入(destinationKey对应的)destinationList的左侧
  1227.          * <p>
  1228.          * 注: 若sourceKey对应的list中没有item了,则立马认为(从sourceKey对应的list中pop出来的)item为null,
  1229.          * null并不会往destinationKey对应的list中push
  1230.          * 追注: 此时,此方法的返回值是null
  1231.          * <p>
  1232.          * 注: 若将(sourceKey对应的)list中的所有元素都pop完了,那么该sourceKey会被删除
  1233.          *
  1234.          * @param sourceKey      定位sourceList的key
  1235.          * @param destinationKey 定位destinationList的key
  1236.          * @return 移动的这个元素
  1237.          */
  1238.         public static String lRightPopAndLeftPush(String sourceKey, String destinationKey) {
  1239.             log.info("lRightPopAndLeftPush(...) => sourceKey -> {},destinationKey -> {}",
  1240.                     sourceKey, destinationKey);
  1241.             String item = redisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey);
  1242.             log.info("lRightPopAndLeftPush(...) => item -> {}", item);
  1243.             return item;
  1244.         }
  1245.  
  1246.         /**
  1247.          * 【阻塞队列】 从sourceKey对应的sourceList右侧移出一个item,并将这个item推
  1248.          * 入(destinationKey对应的)destinationList的左侧
  1249.          * <p>
  1250.          * 注: 若sourceKey对应的list中没有item了,则阻塞等待,直到能从sourceList中移出一个非null的item(或等待时长超时);
  1251.          * case1: 等到了一个非null的item,那么继续下面的push操作,并返回这个item
  1252.          * case2: 超时了,还没等到非null的item,那么pop出的结果就未null,此时并不会往destinationList进行push
  1253.          * 此时,此方法的返回值是null
  1254.          * <p>
  1255.          * 注: 若将(sourceKey对应的)list中的所有元素都pop完了,那么该sourceKey会被删除
  1256.          *
  1257.          * @param sourceKey      定位sourceList的key
  1258.          * @param destinationKey 定位destinationList的key
  1259.          * @param timeout        超时时间
  1260.          * @param unit           timeout的单位
  1261.          * @return 移动的这个元素
  1262.          */
  1263.         public static String lRightPopAndLeftPush(String sourceKey, String destinationKey, long timeout,
  1264.                                                   TimeUnit unit) {
  1265.             log.info("lRightPopAndLeftPush(...) => sourceKey -> {},destinationKey -> {},timeout -> {},"
  1266.                     + " unit -> {}", sourceKey, destinationKey, timeout, unit);
  1267.             String item = redisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey, timeout, unit);
  1268.             log.info("lRightPopAndLeftPush(...) => item -> {}", item);
  1269.             return item;
  1270.         }
  1271.  
  1272.         /**
  1273.          * 设置(key对应的)list中对应索引位置index处的元素为item
  1274.          * <p>
  1275.          * 注: 若key不存在,则会抛出org.springframework.data.redis.RedisSystemException
  1276.          * 注: 若索引越界,也会抛出org.springframework.data.redis.RedisSystemException
  1277.          *
  1278.          * @param key   定位list的key
  1279.          * @param index 定位list中的元素的索引
  1280.          * @param item  要替换成的值
  1281.          */
  1282.         public static void lSet(String key, long index, String item) {
  1283.             log.info("lSet(...) => key -> {},index -> {},item -> {}", key, index, item);
  1284.             redisTemplate.opsForList().set(key, index, item);
  1285.         }
  1286.  
  1287.         /**
  1288.          * 通过索引index,获取(key对应的)list中的元素
  1289.          * <p>
  1290.          * 注: 若key不存在 或 index超出(key对应的)list的索引范围,那么返回null
  1291.          *
  1292.          * @param key   定位list的key
  1293.          * @param index 定位list中的item的索引
  1294.          * @return list中索引index对应的item
  1295.          */
  1296.         public static String lIndex(String key, long index) {
  1297.             log.info("lIndex(...) => key -> {},index -> {}", key, index);
  1298.             String item = redisTemplate.opsForList().index(key, index);
  1299.             log.info("lIndex(...) => item -> {}", item);
  1300.             return item;
  1301.         }
  1302.  
  1303.         /**
  1304.          * 获取(key对应的)list中索引在[start,end]之间的item集
  1305.          * <p>
  1306.          * 注: 含start、含end
  1307.          * 注: 当key不存在时,获取到的是空的集合
  1308.          * 注: 当获取的范围比list的范围还要大时,获取到的是这两个范围的交集
  1309.          * <p>
  1310.          * 提示: 可通过RedisUtil.ListOps.lRange(key,0,-1)来获取到该key对应的整个list
  1311.          *
  1312.          * @param key   定位list的key
  1313.          * @param start 起始元素的index
  1314.          * @param end   结尾元素的index
  1315.          * @return 对应的元素集合
  1316.          */
  1317.         public static List<String> lRange(String key, long start, long end) {
  1318.             log.info("lRange(...) => key -> {},start -> {},end -> {}", key, start, end);
  1319.             List<String> result = redisTemplate.opsForList().range(key, start, end);
  1320.             log.info("lRange(...) => result -> {}", result);
  1321.             return result;
  1322.         }
  1323.  
  1324.         /**
  1325.          * 获取(key对应的)list
  1326.          *
  1327.          * @param key 定位list的key
  1328.          * @return (key对应的)list
  1329.          * @see ListOps#lRange(String, long, long)
  1330.          */
  1331.         public static List<String> lWholeList(String key) {
  1332.             log.info("lWholeList(...) => key -> {}", key);
  1333.             List<String> result = redisTemplate.opsForList().range(key, 0, -1);
  1334.             log.info("lWholeList(...) => result -> {}", result);
  1335.             return result;
  1336.         }
  1337.  
  1338.         /**
  1339.          * 获取(key对应的)list的size
  1340.          * <p>
  1341.          * 注: 当key不存在时,获取到的size为0.
  1342.          *
  1343.          * @param key 定位list的key
  1344.          * @return list的size
  1345.          */
  1346.         public static long lSize(String key) {
  1347.             log.info("lSize(...) => key -> {}", key);
  1348.             Long size = redisTemplate.opsForList().size(key);
  1349.             log.info("lSize(...) => size -> {}", size);
  1350.             if (size == null) {
  1351.                 throw new RedisOpsResultIsNullException();
  1352.             }
  1353.             return size;
  1354.         }
  1355.  
  1356.         /**
  1357.          * 删除(key对应的)list中,前expectCount个值等于item的项
  1358.          * <p>
  1359.          * 注: 若expectCount == 0,则表示删除list中所有的值等于item的项.
  1360.          * 注: 若expectCount > 0, 则表示删除从左往右进行
  1361.          * 注: 若expectCount < 0, 则表示删除从右往左进行
  1362.          * <p>
  1363.          * 注: 若list中,值等于item的项的个数少于expectCount时,那么会删除list中所有的值等于item的项
  1364.          * 注: 当key不存在时,返回0
  1365.          * 注: 若lRemove后,将(key对应的)list中没有任何元素了,那么该key会被删除
  1366.          *
  1367.          * @param key         定位list的key
  1368.          * @param expectCount 要删除的item的个数
  1369.          * @param item        要删除的item
  1370.          * @return 实际删除了的item的个数
  1371.          */
  1372.         public static long lRemove(String key, long expectCount, String item) {
  1373.             log.info("lRemove(...) => key -> {},expectCount -> {},item -> {}", key, expectCount, item);
  1374.             Long actualCount = redisTemplate.opsForList().remove(key, expectCount, item);
  1375.             log.info("lRemove(...) => actualCount -> {}", actualCount);
  1376.             if (actualCount == null) {
  1377.                 throw new RedisOpsResultIsNullException();
  1378.             }
  1379.             return actualCount;
  1380.         }
  1381.  
  1382.         /**
  1383.          * 裁剪(即: 对list中的元素取交集)
  1384.          * <p>
  1385.          * 举例说明: list中的元素索引范围是[0,8],而这个方法传入的[start,end]为 [3,10],
  1386.          * 那么裁剪就是对[0,8]和[3,10]进行取交集,得到[3,8],那么裁剪后
  1387.          * 的list中,只剩下(原来裁剪前)索引在[3,8]之间的元素了
  1388.          * <p>
  1389.          * 注: 若裁剪后的(key对应的)list就是空的,那么该key会被删除
  1390.          *
  1391.          * @param key   定位list的key
  1392.          * @param start 要删除的item集的起始项的索引
  1393.          * @param end   要删除的item集的结尾项的索引
  1394.          */
  1395.         public static void lTrim(String key, long start, long end) {
  1396.             log.info("lTrim(...) => key -> {},start -> {},end -> {}", key, start, end);
  1397.             redisTemplate.opsForList().trim(key, start, end);
  1398.         }
  1399.  
  1400.     }
  1401.  
  1402.     /**
  1403.      * set相关操作
  1404.      * <p>
  1405.      * 提示: set中的元素,不可以重复
  1406.      * 提示: set是无序的
  1407.      * 提示: redis中String的数据结构可参考resources/data-structure/Set(集合)的数据结构(示例一).png
  1408.      * redis中String的数据结构可参考resources/data-structure/Set(集合)的数据结构(示例二).png
  1409.      */
  1410.     public static class SetOps {
  1411.  
  1412.         /**
  1413.          * 向(key对应的)set中添加items
  1414.          * <p>
  1415.          * 注: 若key不存在,则会自动创建
  1416.          * 注: set中的元素会去重
  1417.          *
  1418.          * @param key   定位set的key
  1419.          * @param items 要向(key对应的)set中添加的items
  1420.          * @return 此次添加操作, 添加到set中的元素的个数
  1421.          */
  1422.         public static long sAdd(String key, String... items) {
  1423.             log.info("sAdd(...) => key -> {},items -> {}", key, items);
  1424.             Long count = redisTemplate.opsForSet().add(key, items);
  1425.             log.info("sAdd(...) => count -> {}", count);
  1426.             if (count == null) {
  1427.                 throw new RedisOpsResultIsNullException();
  1428.             }
  1429.             return count;
  1430.         }
  1431.  
  1432.         /**
  1433.          * 从(key对应的)set中删除items
  1434.          * <p>
  1435.          * 注: 若key不存在,则返回0
  1436.          * 注: 若已经将(key对应的)set中的项删除完了,那么对应的key也会被删除
  1437.          *
  1438.          * @param key   定位set的key
  1439.          * @param items 要移除的items
  1440.          * @return 实际删除了的个数
  1441.          */
  1442.         public static long sRemove(String key, Object... items) {
  1443.             log.info("sRemove(...) => key -> {},items -> {}", key, items);
  1444.             Long count = redisTemplate.opsForSet().remove(key, items);
  1445.             log.info("sRemove(...) => count -> {}", count);
  1446.             if (count == null) {
  1447.                 throw new RedisOpsResultIsNullException();
  1448.             }
  1449.             return count;
  1450.         }
  1451.  
  1452.         /**
  1453.          * 从(key对应的)set中随机移出一个item,并返回这个item
  1454.          * <p>
  1455.          * 注: 因为set是无序的,所以移出的这个item,是随机的; 并且,哪怕
  1456.          * 是数据一样的set,多次测试移出操作,移除的元素也是随机的
  1457.          * <p>
  1458.          * 注: 若已经将(key对应的)set中的项pop完了,那么对应的key会被删除
  1459.          *
  1460.          * @param key 定位set的key
  1461.          * @return 移出的项
  1462.          */
  1463.         public static String sPop(String key) {
  1464.             log.info("sPop(...) => key -> {}", key);
  1465.             String popItem = redisTemplate.opsForSet().pop(key);
  1466.             log.info("sPop(...) => popItem -> {}", popItem);
  1467.             return popItem;
  1468.         }
  1469.  
  1470.         /**
  1471.          * 将(sourceKey对应的)sourceSet中的元素item,移动到(destinationKey对应的)destinationSet中
  1472.          * <p>
  1473.          * 注: 当sourceKey不存在时,返回false
  1474.          * 注: 当item不存在时,返回false
  1475.          * 注: 若destinationKey不存在,那么在移动时会自动创建
  1476.          * 注: 若已经将(sourceKey对应的)set中的项move出去完了,那么对应的sourceKey会被删除
  1477.          *
  1478.          * @param sourceKey      定位sourceSet的key
  1479.          * @param item           要移动的项目
  1480.          * @param destinationKey 定位destinationSet的key
  1481.          * @return 移动成功与否
  1482.          */
  1483.         public static boolean sMove(String sourceKey, String item, String destinationKey) {
  1484.             Boolean result = redisTemplate.opsForSet().move(sourceKey, item, destinationKey);
  1485.             log.info("sMove(...) => sourceKey -> {},destinationKey -> {},item -> {}",
  1486.                     sourceKey, destinationKey, item);
  1487.             log.info("sMove(...) =>  result -> {}", result);
  1488.             if (result == null) {
  1489.                 throw new RedisOpsResultIsNullException();
  1490.             }
  1491.             return result;
  1492.         }
  1493.  
  1494.         /**
  1495.          * 获取(key对应的)set中的元素个数
  1496.          * <p>
  1497.          * 注: 若key不存在,则返回0
  1498.          *
  1499.          * @param key 定位set的key
  1500.          * @return (key对应的)set中的元素个数
  1501.          */
  1502.         public static long sSize(String key) {
  1503.             log.info("sSize(...) => key -> {}", key);
  1504.             Long size = redisTemplate.opsForSet().size(key);
  1505.             log.info("sSize(...) => size -> {}", size);
  1506.             if (size == null) {
  1507.                 throw new RedisOpsResultIsNullException();
  1508.             }
  1509.             return size;
  1510.         }
  1511.  
  1512.         /**
  1513.          * 判断(key对应的)set中是否含有item
  1514.          * <p>
  1515.          * 注: 若key不存在,则返回false
  1516.          *
  1517.          * @param key  定位set的key
  1518.          * @param item 被查找的项
  1519.          * @return (key对应的)set中是否含有item
  1520.          */
  1521.         public static boolean sIsMember(String key, Object item) {
  1522.             log.info("sSize(...) => key -> {},size -> {}", key, item);
  1523.             Boolean result = redisTemplate.opsForSet().isMember(key, item);
  1524.             log.info("sSize(...) => result -> {}", result);
  1525.             if (result == null) {
  1526.                 throw new RedisOpsResultIsNullException();
  1527.             }
  1528.             return result;
  1529.         }
  1530.  
  1531.         /**
  1532.          * 获取两个(key对应的)Set的交集
  1533.          * <p>
  1534.          * 注: 若不存在任何交集,那么返回空的集合(,而不是null)
  1535.          * 注: 若其中一个key不存在(或两个key都不存在),那么返回空的集合(,而不是null)
  1536.          *
  1537.          * @param key      定位其中一个set的键
  1538.          * @param otherKey 定位其中另一个set的键
  1539.          * @return item交集
  1540.          */
  1541.         public static Set<String> sIntersect(String key, String otherKey) {
  1542.             log.info("sIntersect(...) => key -> {},otherKey -> {}", key, otherKey);
  1543.             Set<String> intersectResult = redisTemplate.opsForSet().intersect(key, otherKey);
  1544.             log.info("sIntersect(...) => intersectResult -> {}", intersectResult);
  1545.             return intersectResult;
  1546.         }
  1547.  
  1548.         /**
  1549.          * 获取多个(key对应的)Set的交集
  1550.          * <p>
  1551.          * 注: 若不存在任何交集,那么返回空的集合(,而不是null)
  1552.          * 注: 若>=1个key不存在,那么返回空的集合(,而不是null)
  1553.          *
  1554.          * @param key       定位其中一个set的键
  1555.          * @param otherKeys 定位其它set的键集
  1556.          * @return item交集
  1557.          */
  1558.         public static Set<String> sIntersect(String key, Collection<String> otherKeys) {
  1559.             log.info("sIntersect(...) => key -> {},otherKeys -> {}", key, otherKeys);
  1560.             Set<String> intersectResult = redisTemplate.opsForSet().intersect(key, otherKeys);
  1561.             log.info("sIntersect(...) => intersectResult -> {}", intersectResult);
  1562.             return intersectResult;
  1563.         }
  1564.  
  1565.         /**
  1566.          * 获取两个(key对应的)Set的交集,并将结果add到storeKey对应的Set中
  1567.          * <p>
  1568.          * case1: 交集不为空,storeKey不存在,则 会创建对应的storeKey,并将交集添加到(storeKey对应的)set中
  1569.          * case2: 交集不为空,storeKey已存在,则 会清除原(storeKey对应的)set中所有的项,然后将交集添加到(storeKey对应的)set中
  1570.          * case3: 交集为空,则不进行下面的操作,直接返回0
  1571.          * <p>
  1572.          * 注: 求交集的部分,详见{@link SetOps#sIntersect(String, String)}
  1573.          *
  1574.          * @param key      定位其中一个set的键
  1575.          * @param otherKey 定位其中另一个set的键
  1576.          * @param storeKey 定位(要把交集添加到哪个)set的key
  1577.          * @return add到(storeKey对应的)Set后, 该set对应的size
  1578.          */
  1579.         public static long sIntersectAndStore(String key, String otherKey, String storeKey) {
  1580.             log.info("sIntersectAndStore(...) => key -> {},otherKey -> {},storeKey -> {}",
  1581.                     key, otherKey, storeKey);
  1582.             Long size = redisTemplate.opsForSet().intersectAndStore(key, otherKey, storeKey);
  1583.             log.info("sIntersectAndStore(...) => size -> {}", size);
  1584.             if (size == null) {
  1585.                 throw new RedisOpsResultIsNullException();
  1586.             }
  1587.             return size;
  1588.         }
  1589.  
  1590.         /**
  1591.          * 获取多个(key对应的)Set的交集,并将结果add到storeKey对应的Set中
  1592.          * <p>
  1593.          * case1: 交集不为空,storeKey不存在,则 会创建对应的storeKey,并将交集添加到(storeKey对应的)set中
  1594.          * case2: 交集不为空,storeKey已存在,则 会清除原(storeKey对应的)set中所有的项,然后将交集添加到(storeKey对应的)set中
  1595.          * case3: 交集为空,则不进行下面的操作,直接返回0
  1596.          * <p>
  1597.          * 注: 求交集的部分,详见{@link SetOps#sIntersect(String, Collection)}
  1598.          */
  1599.         public static long sIntersectAndStore(String key, Collection<String> otherKeys, String storeKey) {
  1600.             log.info("sIntersectAndStore(...) => key -> {},otherKeys -> {},storeKey -> {}", key, otherKeys, storeKey);
  1601.             Long size = redisTemplate.opsForSet().intersectAndStore(key, otherKeys, storeKey);
  1602.             log.info("sIntersectAndStore(...) => size -> {}", size);
  1603.             if (size == null) {
  1604.                 throw new RedisOpsResultIsNullException();
  1605.             }
  1606.             return size;
  1607.         }
  1608.  
  1609.         /**
  1610.          * 获取两个(key对应的)Set的并集
  1611.          * <p>
  1612.          * 注: 并集中的元素也是唯一的,这是Set保证的
  1613.          *
  1614.          * @param key      定位其中一个set的键
  1615.          * @param otherKey 定位其中另一个set的键
  1616.          * @return item并集
  1617.          */
  1618.         public static Set<String> sUnion(String key, String otherKey) {
  1619.             log.info("sUnion(...) => key -> {},otherKey -> {}", key, otherKey);
  1620.             Set<String> unionResult = redisTemplate.opsForSet().union(key, otherKey);
  1621.             log.info("sUnion(...) => unionResult -> {}", unionResult);
  1622.             return unionResult;
  1623.         }
  1624.  
  1625.         /**
  1626.          * 获取两个(key对应的)Set的并集
  1627.          * <p>
  1628.          * 注: 并集中的元素也是唯一的,这是Set保证的
  1629.          *
  1630.          * @param key       定位其中一个set的键
  1631.          * @param otherKeys 定位其它set的键集
  1632.          * @return item并集
  1633.          */
  1634.         public static Set<String> sUnion(String key, Collection<String> otherKeys) {
  1635.             log.info("sUnion(...) => key -> {},otherKeys -> {}", key, otherKeys);
  1636.             Set<String> unionResult = redisTemplate.opsForSet().union(key, otherKeys);
  1637.             log.info("sUnion(...) => unionResult -> {}", unionResult);
  1638.             return unionResult;
  1639.         }
  1640.  
  1641.         /**
  1642.          * 获取两个(key对应的)Set的并集,并将结果add到storeKey对应的Set中
  1643.          * <p>
  1644.          * case1: 并集不为空,storeKey不存在,则 会创建对应的storeKey,并将并集添加到(storeKey对应的)set中
  1645.          * case2: 并集不为空,storeKey已存在,则 会清除原(storeKey对应的)set中所有的项,然后将并集添加到(storeKey对应的)set中
  1646.          * case3: 并集为空,则不进行下面的操作,直接返回0
  1647.          * <p>
  1648.          * 注: 求并集的部分,详见{@link SetOps#sUnion(String, String)}
  1649.          *
  1650.          * @param key      定位其中一个set的键
  1651.          * @param otherKey 定位其中另一个set的键
  1652.          * @param storeKey 定位(要把并集添加到哪个)set的key
  1653.          * @return add到(storeKey对应的)Set后, 该set对应的size
  1654.          */
  1655.         public static long sUnionAndStore(String key, String otherKey, String storeKey) {
  1656.             log.info("sUnionAndStore(...) => key -> {},otherKey -> {},storeKey -> {}",
  1657.                     key, otherKey, storeKey);
  1658.             Long size = redisTemplate.opsForSet().unionAndStore(key, otherKey, storeKey);
  1659.             log.info("sUnionAndStore(...) => size -> {}", size);
  1660.             if (size == null) {
  1661.                 throw new RedisOpsResultIsNullException();
  1662.             }
  1663.             return size;
  1664.         }
  1665.  
  1666.         /**
  1667.          * 获取两个(key对应的)Set的并集,并将结果add到storeKey对应的Set中
  1668.          * <p>
  1669.          * case1: 并集不为空,storeKey不存在,则 会创建对应的storeKey,并将并集添加到(storeKey对应的)set中
  1670.          * case2: 并集不为空,storeKey已存在,则 会清除原(storeKey对应的)set中所有的项,然后将并集添加到(storeKey对应的)set中
  1671.          * case3: 并集为空,则不进行下面的操作,直接返回0
  1672.          * <p>
  1673.          * 注: 求并集的部分,详见{@link SetOps#sUnion(String, Collection)}
  1674.          *
  1675.          * @param key       定位其中一个set的键
  1676.          * @param otherKeys 定位其它set的键集
  1677.          * @param storeKey  定位(要把并集添加到哪个)set的key
  1678.          * @return add到(storeKey对应的)Set后, 该set对应的size
  1679.          */
  1680.         public static long sUnionAndStore(String key, Collection<String> otherKeys, String storeKey) {
  1681.             log.info("sUnionAndStore(...) => key -> {},otherKeys -> {},storeKey -> {}",
  1682.                     key, otherKeys, storeKey);
  1683.             Long size = redisTemplate.opsForSet().unionAndStore(key, otherKeys, storeKey);
  1684.             log.info("sUnionAndStore(...) => size -> {}", size);
  1685.             if (size == null) {
  1686.                 throw new RedisOpsResultIsNullException();
  1687.             }
  1688.             return size;
  1689.         }
  1690.  
  1691.         /**
  1692.          * 获取 (key对应的)Set 减去 (otherKey对应的)Set 的差集
  1693.          * <p>
  1694.          * 注: 如果被减数key不存在,那么结果为空的集合(,而不是null)
  1695.          * 注: 如果被减数key存在,但减数key不存在,那么结果即为(被减数key对应的)Set
  1696.          *
  1697.          * @param key      定位"被减数set"的键
  1698.          * @param otherKey 定位"减数set"的键
  1699.          * @return item差集
  1700.          */
  1701.         public static Set<String> sDifference(String key, String otherKey) {
  1702.             log.info("sDifference(...) => key -> {},otherKey -> {}",
  1703.                     key, otherKey);
  1704.             Set<String> differenceResult = redisTemplate.opsForSet().difference(key, otherKey);
  1705.             log.info("sDifference(...) => differenceResult -> {}", differenceResult);
  1706.             return differenceResult;
  1707.         }
  1708.  
  1709.         /**
  1710.          * 获取 (key对应的)Set 减去 (otherKeys对应的)Sets 的差集
  1711.          * <p>
  1712.          * 注: 如果被减数key不存在,那么结果为空的集合(,而不是null)
  1713.          * 注: 如果被减数key存在,但减数key不存在,那么结果即为(被减数key对应的)Set
  1714.          * <p>
  1715.          * 提示: 当有多个减数时,被减数先减去哪一个减数,后减去哪一个减数,是无所谓的,是不影响最终结果的
  1716.          *
  1717.          * @param key       定位"被减数set"的键
  1718.          * @param otherKeys 定位"减数集sets"的键集
  1719.          * @return item差集
  1720.          */
  1721.         public static Set<String> sDifference(String key, Collection<String> otherKeys) {
  1722.             log.info("sDifference(...) => key -> {},otherKeys -> {}", key, otherKeys);
  1723.             Set<String> differenceResult = redisTemplate.opsForSet().difference(key, otherKeys);
  1724.             log.info("sDifference(...) => differenceResult -> {}", differenceResult);
  1725.             return differenceResult;
  1726.         }
  1727.  
  1728.         /**
  1729.          * 获取 (key对应的)Set 减去 (otherKey对应的)Set 的差集,并将结果add到storeKey对应的Set中
  1730.          * <p>
  1731.          * case1: 差集不为空,storeKey不存在,则 会创建对应的storeKey,并将差集添加到(storeKey对应的)set中
  1732.          * case2: 差集不为空,storeKey已存在,则 会清除原(storeKey对应的)set中所有的项,然后将差集添加到(storeKey对应的)set中
  1733.          * case3: 差集为空,则不进行下面的操作,直接返回0
  1734.          * <p>
  1735.          * 注: 求并集的部分,详见{@link SetOps#sDifference(String, String)}
  1736.          *
  1737.          * @param key      定位"被减数set"的键
  1738.          * @param otherKey 定位"减数set"的键
  1739.          * @param storeKey 定位(要把差集添加到哪个)set的key
  1740.          * @return add到(storeKey对应的)Set后, 该set对应的size
  1741.          */
  1742.         public static long sDifferenceAndStore(String key, String otherKey, String storeKey) {
  1743.             log.info("sDifferenceAndStore(...) => key -> {},otherKey -> {},storeKey -> {}",
  1744.                     key, otherKey, storeKey);
  1745.             Long size = redisTemplate.opsForSet().differenceAndStore(key, otherKey, storeKey);
  1746.             log.info("sDifferenceAndStore(...) => size -> {}", size);
  1747.             if (size == null) {
  1748.                 throw new RedisOpsResultIsNullException();
  1749.             }
  1750.             return size;
  1751.         }
  1752.  
  1753.         /**
  1754.          * 获取 (key对应的)Set 减去 (otherKey对应的)Set 的差集,并将结果add到storeKey对应的Set中
  1755.          * <p>
  1756.          * case1: 差集不为空,storeKey不存在,则 会创建对应的storeKey,并将差集添加到(storeKey对应的)set中
  1757.          * case2: 差集不为空,storeKey已存在,则 会清除原(storeKey对应的)set中所有的项,然后将差集添加到(storeKey对应的)set中
  1758.          * case3: 差集为空,则不进行下面的操作,直接返回0
  1759.          * <p>
  1760.          * 注: 求并集的部分,详见{@link SetOps#sDifference(String, String)}
  1761.          *
  1762.          * @param key       定位"被减数set"的键
  1763.          * @param otherKeys 定位"减数集sets"的键集
  1764.          * @param storeKey  定位(要把差集添加到哪个)set的key
  1765.          * @return add到(storeKey对应的)Set后, 该set对应的size
  1766.          */
  1767.         public static long sDifferenceAndStore(String key, Collection<String> otherKeys, String storeKey) {
  1768.             log.info("sDifferenceAndStore(...) => key -> {},otherKeys -> {},storeKey -> {}",
  1769.                     key, otherKeys, storeKey);
  1770.             Long size = redisTemplate.opsForSet().differenceAndStore(key, otherKeys, storeKey);
  1771.             log.info("sDifferenceAndStore(...) => size -> {}", size);
  1772.             if (size == null) {
  1773.                 throw new RedisOpsResultIsNullException();
  1774.             }
  1775.             return size;
  1776.         }
  1777.  
  1778.         /**
  1779.          * 获取key对应的set
  1780.          * <p>
  1781.          * 注: 若key不存在,则返回的是空的set(,而不是null)
  1782.          *
  1783.          * @param key 定位set的key
  1784.          * @return (key对应的)set
  1785.          */
  1786.         public static Set<String> sMembers(String key) {
  1787.             log.info("sMembers(...) => key -> {}", key);
  1788.             Set<String> members = redisTemplate.opsForSet().members(key);
  1789.             log.info("sMembers(...) => members -> {}", members);
  1790.             return members;
  1791.         }
  1792.  
  1793.         /**
  1794.          * 从key对应的set中随机获取一项
  1795.          *
  1796.          * @param key 定位set的key
  1797.          * @return 随机获取到的项
  1798.          */
  1799.         public static String sRandomMember(String key) {
  1800.             log.info("sRandomMember(...) => key -> {}", key);
  1801.             String randomItem = redisTemplate.opsForSet().randomMember(key);
  1802.             log.info("sRandomMember(...) => randomItem -> {}", randomItem);
  1803.             return randomItem;
  1804.         }
  1805.  
  1806.         /**
  1807.          * 从key对应的set中获取count次随机项(,set中的同一个项可能被多次获取)
  1808.          * <p>
  1809.          * 注: count可大于set的size
  1810.          * 注: 取出来的结果里可能存在相同的值
  1811.          *
  1812.          * @param key   定位set的key
  1813.          * @param count 要取多少项
  1814.          * @return 随机获取到的项集
  1815.          */
  1816.         public static List<String> sRandomMembers(String key, long count) {
  1817.             log.info("sRandomMembers(...) => key -> {},count -> {}", key, count);
  1818.             List<String> randomItems = redisTemplate.opsForSet().randomMembers(key, count);
  1819.             log.info("sRandomMembers(...) => randomItems -> {}", randomItems);
  1820.             return randomItems;
  1821.         }
  1822.  
  1823.         /**
  1824.          * 从key对应的set中随机获取count个项
  1825.          * <p>
  1826.          * 注: 若count >= set的size,那么返回的即为这个key对应的set
  1827.          * 注: 取出来的结果里没有重复的项
  1828.          *
  1829.          * @param key   定位set的key
  1830.          * @param count 要取多少项
  1831.          * @return 随机获取到的项集
  1832.          */
  1833.         public static Set<String> sDistinctRandomMembers(String key, long count) {
  1834.             log.info("sDistinctRandomMembers(...) => key -> {},count -> {}", key, count);
  1835.             Set<String> distinctRandomItems = redisTemplate.opsForSet().distinctRandomMembers(key, count);
  1836.             log.info("sDistinctRandomMembers(...) => distinctRandomItems -> {}", distinctRandomItems);
  1837.             return distinctRandomItems;
  1838.         }
  1839.  
  1840.         /**
  1841.          * 根据options匹配到(key对应的)set中的对应的item,并返回对应的item集
  1842.          * <p>
  1843.          * <p>
  1844.          * 注: ScanOptions实例的创建方式举例:
  1845.          * 1、ScanOptions.NONE
  1846.          * 2、ScanOptions.scanOptions().match("n??e").build()
  1847.          *
  1848.          * @param key     定位set的key
  1849.          * @param options 匹配set中的item的条件
  1850.          *                注: ScanOptions.NONE表示全部匹配
  1851.          *                注: ScanOptions.scanOptions().match(pattern).build()表示按照pattern匹配,
  1852.          *                其中pattern中可以使用通配符 * ? 等,
  1853.          *                * 表示>=0个字符
  1854.          *                ？ 表示有且只有一个字符
  1855.          *                此处的匹配规则与{@link KeyOps#keys(String)}处的一样
  1856.          * @return 匹配到的(key对应的)set中的项
  1857.          */
  1858.         @SneakyThrows
  1859.         public static Cursor<String> sScan(String key, ScanOptions options) {
  1860.             log.info("sScan(...) => key -> {},options -> {}", key, mapper.writeValueAsString(options));
  1861.             Cursor<String> cursor = redisTemplate.opsForSet().scan(key, options);
  1862.             log.info("sScan(...) => cursor -> {}", mapper.writeValueAsString(cursor));
  1863.             return cursor;
  1864.         }
  1865.     }
  1866.  
  1867.     /**
  1868.      * ZSet相关操作
  1869.      * <p>
  1870.      * 特别说明: ZSet是有序的,
  1871.      * 不仅体现在： redis中的存储上有序
  1872.      * 还体现在:   此工具类ZSetOps中返回值类型为Set<?>的方法,实际返回类型是LinkedHashSet<?>
  1873.      * <p>
  1874.      * 提示: redis中的ZSet,一定程度等于redis中的Set + redis中的Hash的结合体
  1875.      * 提示: redis中String的数据结构可参考resources/data-structure/ZSet(有序集合)的数据结构(示例一).png
  1876.      * redis中String的数据结构可参考resources/data-structure/ZSet(有序集合)的数据结构(示例二).png
  1877.      * 提示: ZSet中的entryKey即为成员项,entryValue即为这个成员项的分值,ZSet根据成员的分值,来堆成员进行排序
  1878.      */
  1879.     public static class ZSetOps {
  1880.  
  1881.         /**
  1882.          * 向(key对应的)zset中添加(item,score)
  1883.          * <p>
  1884.          * 注: item为entryKey成员项,score为entryValue分数值
  1885.          * <p>
  1886.          * 注: 若(key对应的)zset中已存在(与此次要添加的项)相同的item项,那么此次添加操作会失败,返回false；
  1887.          * 但是！！！ zset中原item的score会被更新为此次add的相同item项的score
  1888.          * 所以,也可以通过zAdd达到更新item对应score的目的
  1889.          * <p>
  1890.          * 注: score可为正、可为负、可为0; 总之,double范围内都可以
  1891.          * <p>
  1892.          * 注: 若score的值一样,则按照item排序
  1893.          *
  1894.          * @param key   定位set的key
  1895.          * @param item  要往(key对应的)zset中添加的成员项
  1896.          * @param score item的分值
  1897.          * @return 是否添加成功
  1898.          */
  1899.         public static boolean zAdd(String key, String item, double score) {
  1900.             log.info("zAdd(...) => key -> {},item -> {},score -> {}", key, item, score);
  1901.             Boolean result = redisTemplate.opsForZSet().add(key, item, score);
  1902.             log.info("zAdd(...) => result -> {}", result);
  1903.             if (result == null) {
  1904.                 throw new RedisOpsResultIsNullException();
  1905.             }
  1906.             return result;
  1907.         }
  1908.  
  1909.         /**
  1910.          * 批量添加entry<item,score>
  1911.          * <p>
  1912.          * 注: 若entry<item,score>集中存在item相同的项(,score不一样),那么redis在执行真正的批量add操作前,会
  1913.          * 将其中一个item过滤掉
  1914.          * 注: 同样的,若(key对应的)zset中已存在(与此次要添加的项)相同的item项,那么此次批量添加操作中,
  1915.          * 对该item项的添加会失败,会失败,成功计数器不会加1；但是！！！ zset中原item的score会被更新为此
  1916.          * 次add的相同item项的score所以,也可以通过zAdd达到更新item对应score的目的
  1917.          *
  1918.          * @param key     定位set的key
  1919.          * @param entries 要添加的entry<item,score>集
  1920.          * @return 本次添加进(key对应的)zset中的entry的个数
  1921.          */
  1922.         @SneakyThrows
  1923.         public static long zAdd(String key, Set<TypedTuple<String>> entries) {
  1924.             log.info("zAdd(...) => key -> {},entries -> {}", key, mapper.writeValueAsString(entries));
  1925.             Long count = redisTemplate.opsForZSet().add(key, entries);
  1926.             log.info("zAdd(...) => count -> {}", count);
  1927.             if (count == null) {
  1928.                 throw new RedisOpsResultIsNullException();
  1929.             }
  1930.             return count;
  1931.         }
  1932.  
  1933.         /**
  1934.          * 从(key对应的)zset中移除项
  1935.          * <p>
  1936.          * 注:若key不存在,则返回0
  1937.          *
  1938.          * @param key   定位set的key
  1939.          * @param items 要移除的项集
  1940.          * @return 实际移除了的项的个数
  1941.          */
  1942.         public static long zRemove(String key, Object... items) {
  1943.             log.info("zRemove(...) => key -> {},items -> {}", key, items);
  1944.             Long count = redisTemplate.opsForZSet().remove(key, items);
  1945.             log.info("zRemove(...) => count -> {}", count);
  1946.             if (count == null) {
  1947.                 throw new RedisOpsResultIsNullException();
  1948.             }
  1949.             return count;
  1950.         }
  1951.  
  1952.         /**
  1953.          * 移除(key对应的)zset中,排名范围在[startIndex,endIndex]内的item
  1954.          * <p>
  1955.          * 注:默认的,按score.item升序排名,排名从0开始
  1956.          * <p>
  1957.          * 注: 类似于List中的索引,排名可以分为多个方式:
  1958.          * 从前到后(正向)的排名: 0、1、2...
  1959.          * 从后到前(反向)的排名: -1、-2、-3...
  1960.          * <p>
  1961.          * 注: 不论是使用正向排名,还是使用反向排名,使用此方法时,应保证 startRange代表的元素的位置
  1962.          * 在endRange代表的元素的位置的前面,如:
  1963.          * 示例一: RedisUtil.ZSetOps.zRemoveRange("name",0,2);
  1964.          * 示例二: RedisUtil.ZSetOps.zRemoveRange("site",-2,-1);
  1965.          * 示例三: RedisUtil.ZSetOps.zRemoveRange("foo",0,-1);
  1966.          * <p>
  1967.          * 注:若key不存在,则返回0
  1968.          *
  1969.          * @param key        定位set的key
  1970.          * @param startRange 开始项的排名
  1971.          * @param endRange   结尾项的排名
  1972.          * @return 实际移除了的项的个数
  1973.          */
  1974.         public static long zRemoveRange(String key, long startRange, long endRange) {
  1975.             log.info("zRemoveRange(...) => key -> {},startRange -> {},endRange -> {}",
  1976.                     key, startRange, endRange);
  1977.             Long count = redisTemplate.opsForZSet().removeRange(key, startRange, endRange);
  1978.             log.info("zRemoveRange(...) => count -> {}", count);
  1979.             if (count == null) {
  1980.                 throw new RedisOpsResultIsNullException();
  1981.             }
  1982.             return count;
  1983.         }
  1984.  
  1985.         /**
  1986.          * 移除(key对应的)zset中,score范围在[minScore,maxScore]内的item
  1987.          * <p>
  1988.          * 提示: 虽然删除范围包含两侧的端点(即:包含minScore和maxScore),但是由于double存在精度问题,所以建议:
  1989.          * 设置值时,minScore应该设置得比要删除的项里,最小的score还小一点
  1990.          * maxScore应该设置得比要删除的项里,最大的score还大一点
  1991.          * 追注: 本人简单测试了几组数据,暂未出现精度问题
  1992.          * <p>
  1993.          * 注:若key不存在,则返回0
  1994.          *
  1995.          * @param key      定位set的key
  1996.          * @param minScore score下限(含这个值)
  1997.          * @param maxScore score上限(含这个值)
  1998.          * @return 实际移除了的项的个数
  1999.          */
  2000.         public static long zRemoveRangeByScore(String key, double minScore, double maxScore) {
  2001.             log.info("zRemoveRangeByScore(...) => key -> {},startIndex -> {},startIndex -> {}",
  2002.                     key, minScore, maxScore);
  2003.             Long count = redisTemplate.opsForZSet().removeRangeByScore(key, minScore, maxScore);
  2004.             log.info("zRemoveRangeByScore(...) => count -> {}", count);
  2005.             if (count == null) {
  2006.                 throw new RedisOpsResultIsNullException();
  2007.             }
  2008.             return count;
  2009.         }
  2010.  
  2011.         /**
  2012.          * 增/减 (key对应的zset中,)item的分数值
  2013.          *
  2014.          * @param key   定位zset的key
  2015.          * @param item  项
  2016.          * @param delta 变化量(正 - 增,负 - 减)
  2017.          * @return 修改后的score值
  2018.          */
  2019.         public static double zIncrementScore(String key, String item, double delta) {
  2020.             log.info("zIncrementScore(...) => key -> {},item -> {},delta -> {}", key, item, delta);
  2021.             Double scoreValue = redisTemplate.opsForZSet().incrementScore(key, item, delta);
  2022.             log.info("zIncrementScore(...) => scoreValue -> {}", scoreValue);
  2023.             if (scoreValue == null) {
  2024.                 throw new RedisOpsResultIsNullException();
  2025.             }
  2026.             return scoreValue;
  2027.         }
  2028.  
  2029.         /**
  2030.          * 返回item在(key对应的)zset中的(按score从小到大的)排名
  2031.          * <p>
  2032.          * 注: 排名从0开始 即意味着,此方法等价于: 返回item在(key对应的)zset中的位置索引
  2033.          * 注: 若key或item不存在,返回null
  2034.          * 注: 排序规则是score,item,即:优先以score排序,若score相同,则再按item排序
  2035.          *
  2036.          * @param key  定位zset的key
  2037.          * @param item 项
  2038.          * @return 排名(等价于 : 索引)
  2039.          */
  2040.         public static long zRank(String key, Object item) {
  2041.             log.info("zRank(...) => key -> {},item -> {}", key, item);
  2042.             Long rank = redisTemplate.opsForZSet().rank(key, item);
  2043.             log.info("zRank(...) => rank -> {}", rank);
  2044.             if (rank == null) {
  2045.                 throw new RedisOpsResultIsNullException();
  2046.             }
  2047.             return rank;
  2048.         }
  2049.  
  2050.         /**
  2051.          * 返回item在(key对应的)zset中的(按score从大到小的)排名
  2052.          * <p>
  2053.          * 注: 排名从0开始补充: 因为是按score从大到小排序的,所以最大score对应的item的排名为0
  2054.          * 注: 若key或item不存在,返回null
  2055.          * 注: 排序规则是score,item,即:优先以score排序,若score相同,则再按item排序
  2056.          *
  2057.          * @param key  定位zset的key
  2058.          * @param item 项
  2059.          * @return 排名(等价于 : 索引)
  2060.          */
  2061.         public static long zReverseRank(String key, Object item) {
  2062.             log.info("zReverseRank(...) => key -> {},item -> {}", key, item);
  2063.             Long reverseRank = redisTemplate.opsForZSet().reverseRank(key, item);
  2064.             log.info("zReverseRank(...) => reverseRank -> {}", reverseRank);
  2065.             if (reverseRank == null) {
  2066.                 throw new RedisOpsResultIsNullException();
  2067.             }
  2068.             return reverseRank;
  2069.         }
  2070.  
  2071.         /**
  2072.          * 根据索引位置,获取(key对应的)zset中排名处于[start,end]中的item项集
  2073.          * <p>
  2074.          * 注: 不论是使用正向排名,还是使用反向排名,使用此方法时,应保证 startIndex代表的元素的
  2075.          * 位置在endIndex代表的元素的位置的前面,如:
  2076.          * 示例一: RedisUtil.ZSetOps.zRange("name",0,2);
  2077.          * 示例二: RedisUtil.ZSetOps.zRange("site",-2,-1);
  2078.          * 示例三: RedisUtil.ZSetOps.zRange("foo",0,-1);
  2079.          * <p>
  2080.          * 注: 若key不存在,则返回空的集合
  2081.          * <p>
  2082.          * 注: 当[start,end]的范围比实际zset的范围大时,返回范围上"交集"对应的项集合
  2083.          *
  2084.          * @param key   定位zset的key
  2085.          * @param start 排名开始位置
  2086.          * @param end   排名结束位置
  2087.          * @return 对应的item项集
  2088.          */
  2089.         public static Set<String> zRange(String key, long start, long end) {
  2090.             log.info("zRange(...) => key -> {},start -> {},end -> {}", key, start, end);
  2091.             Set<String> result = redisTemplate.opsForZSet().range(key, start, end);
  2092.             log.info("zRange(...) => result -> {}", result);
  2093.             return result;
  2094.         }
  2095.  
  2096.         /**
  2097.          * 获取(key对应的)zset中的所有item项
  2098.          *
  2099.          * @param key 定位zset的键
  2100.          * @return (key对应的)zset中的所有item项
  2101.          * @see ZSetOps#zRange(String, long, long)
  2102.          */
  2103.         public static Set<String> zWholeZSetItem(String key) {
  2104.             log.info("zWholeZSetItem(...) => key -> {}", key);
  2105.             Set<String> result = redisTemplate.opsForZSet().range(key, 0, -1);
  2106.             log.info("zWholeZSetItem(...) =>result -> {}", result);
  2107.             return result;
  2108.         }
  2109.  
  2110.         /**
  2111.          * 根据索引位置,获取(key对应的)zset中排名处于[start,end]中的entry集
  2112.          * <p>
  2113.          * 注: 不论是使用正向排名,还是使用反向排名,使用此方法时,应保证 startIndex代表的元素的
  2114.          * 位置在endIndex代表的元素的位置的前面,如:
  2115.          * 示例一: RedisUtil.ZSetOps.zRange("name",0,2);
  2116.          * 示例二: RedisUtil.ZSetOps.zRange("site",-2,-1);
  2117.          * 示例三: RedisUtil.ZSetOps.zRange("foo",0,-1);
  2118.          * <p>
  2119.          * 注: 若key不存在,则返回空的集合
  2120.          * <p>
  2121.          * 注: 当[start,end]的范围比实际zset的范围大时,返回范围上"交集"对应的项集合
  2122.          * <p>
  2123.          * 注: 此方法和{@link ZSetOps#zRange(String, long, long)}类似,不过此方法返回的不是item集,而是entry集
  2124.          *
  2125.          * @param key   定位zset的key
  2126.          * @param start 排名开始位置
  2127.          * @param end   排名结束位置
  2128.          * @return 对应的entry集
  2129.          */
  2130.         @SneakyThrows
  2131.         public static Set<TypedTuple<String>> zRangeWithScores(String key, long start, long end) {
  2132.             log.info("zRangeWithScores(...) => key -> {},start -> {},end -> {}", key, start, end);
  2133.             Set<TypedTuple<String>> entries = redisTemplate.opsForZSet().rangeWithScores(key, start, end);
  2134.             log.info("zRangeWithScores(...) => entries -> {}", mapper.writeValueAsString(entries));
  2135.             return entries;
  2136.         }
  2137.  
  2138.         /**
  2139.          * 获取(key对应的)zset中的所有entry
  2140.          *
  2141.          * @param key 定位zset的键
  2142.          * @return (key对应的)zset中的所有entry
  2143.          * @see ZSetOps#zRangeWithScores(String, long, long)
  2144.          */
  2145.         @SneakyThrows
  2146.         public static Set<TypedTuple<String>> zWholeZSetEntry(String key) {
  2147.             log.info("zWholeZSetEntry(...) => key -> {}", key);
  2148.             Set<TypedTuple<String>> entries = redisTemplate.opsForZSet().rangeWithScores(key, 0, -1);
  2149.             log.info("zWholeZSetEntry(...) => entries -> {}", key, mapper.writeValueAsString(entries));
  2150.             return entries;
  2151.         }
  2152.  
  2153.         /**
  2154.          * 根据score,获取(key对应的)zset中分数值处于[minScore,maxScore]中的item项集
  2155.          * <p>
  2156.          * 注: 若key不存在,则返回空的集合
  2157.          * 注: 当[minScore,maxScore]的范围比实际zset中score的范围大时,返回范围上"交集"对应的项集合
  2158.          * <p>
  2159.          * 提示: 虽然删除范围包含两侧的端点(即:包含minScore和maxScore),但是由于double存在精度问题,所以建议:
  2160.          * 设置值时,minScore应该设置得比要删除的项里,最小的score还小一点
  2161.          * maxScore应该设置得比要删除的项里,最大的score还大一点
  2162.          * 追注: 本人简单测试了几组数据,暂未出现精度问题
  2163.          *
  2164.          * @param key      定位zset的key
  2165.          * @param minScore score下限
  2166.          * @param maxScore score上限
  2167.          * @return 对应的item项集
  2168.          */
  2169.         public static Set<String> zRangeByScore(String key, double minScore, double maxScore) {
  2170.             log.info("zRangeByScore(...) => key -> {},minScore -> {},maxScore -> {}", key, minScore, maxScore);
  2171.             Set<String> items = redisTemplate.opsForZSet().rangeByScore(key, minScore, maxScore);
  2172.             log.info("zRangeByScore(...) => items -> {}", items);
  2173.             return items;
  2174.         }
  2175.  
  2176.         /**
  2177.          * 根据score,获取(key对应的)zset中分数值处于[minScore,maxScore]中的,score处于[minScore,
  2178.          * 排名大于等于offset的count个item项
  2179.          * <p>
  2180.          * 特别注意: 对于不是特别熟悉redis的人来说,offset 和 count最好都使用正数,避免引起理解上的歧义
  2181.          * <p>
  2182.          * 注: 若key不存在,则返回空的集合
  2183.          * <p>
  2184.          * 提示: 虽然删除范围包含两侧的端点(即:包含minScore和maxScore),但是由于double存在精度问题,所以建议:
  2185.          * 设置值时,minScore应该设置得比要删除的项里,最小的score还小一点
  2186.          * maxScore应该设置得比要删除的项里,最大的score还大一点
  2187.          * 追注: 本人简单测试了几组数据,暂未出现精度问题
  2188.          *
  2189.          * @param key      定位zset的key
  2190.          * @param minScore score下限
  2191.          * @param maxScore score上限
  2192.          * @param offset   偏移量(即:排名下限)
  2193.          * @param count    期望获取到的元素个数
  2194.          * @return 对应的item项集
  2195.          */
  2196.         public static Set<String> zRangeByScore(String key, double minScore, double maxScore,
  2197.                                                 long offset, long count) {
  2198.             log.info("zRangeByScore(...) => key -> {},minScore -> {},maxScore -> {},offset -> {},"
  2199.                     + "count -> {}", key, minScore, maxScore, offset, count);
  2200.             Set<String> items = redisTemplate.opsForZSet().rangeByScore(key, minScore, maxScore, offset, count);
  2201.             log.info("zRangeByScore(...) => items -> {}", items);
  2202.             return items;
  2203.         }
  2204.  
  2205.         /**
  2206.          * 获取(key对应的)zset中的所有score处于[minScore,maxScore]中的entry
  2207.          *
  2208.          * @param key      定位zset的键
  2209.          * @param minScore score下限
  2210.          * @param maxScore score上限
  2211.          * @return (key对应的)zset中的所有score处于[minScore, maxScore]中的entry
  2212.          * @see ZSetOps#zRangeByScore(String, double, double)
  2213.          * <p>
  2214.          * 注: 若key不存在,则返回空的集合
  2215.          * 注: 当[minScore,maxScore]的范围比实际zset中score的范围大时,返回范围上"交集"对应的项集合
  2216.          */
  2217.         @SneakyThrows
  2218.         public static Set<TypedTuple<String>> zRangeByScoreWithScores(String key, double minScore, double maxScore) {
  2219.             log.info("zRangeByScoreWithScores(...) => key -> {},minScore -> {},maxScore -> {}",
  2220.                     key, minScore, maxScore);
  2221.             Set<TypedTuple<String>> entries = redisTemplate.opsForZSet().rangeByScoreWithScores(key, minScore, maxScore);
  2222.             log.info("zRangeByScoreWithScores(...) => entries -> {}", mapper.writeValueAsString(entries));
  2223.             return entries;
  2224.         }
  2225.  
  2226.         /**
  2227.          * 获取(key对应的)zset中,score处于[minScore,maxScore]里的、排名大于等于offset的count个entry
  2228.          * <p>
  2229.          * 特别注意: 对于不是特别熟悉redis的人来说,offset 和 count最好都使用正数,避免引起理解上的歧义
  2230.          *
  2231.          * @param key      定位zset的键
  2232.          * @param minScore score下限
  2233.          * @param maxScore score上限
  2234.          * @param offset   偏移量(即:排名下限)
  2235.          * @param count    期望获取到的元素个数
  2236.          * @return [startIndex, endIndex] & [minScore,maxScore]里的entry
  2237.          */
  2238.         @SneakyThrows
  2239.         public static Set<TypedTuple<String>> zRangeByScoreWithScores(String key, double minScore,
  2240.                                                                       double maxScore, long offset,
  2241.                                                                       long count) {
  2242.             log.info("zRangeByScoreWithScores(...) => key -> {},minScore -> {},maxScore -> {},"
  2243.                             + " offset -> {},count -> {}",
  2244.                     key, minScore, maxScore, offset, count);
  2245.             Set<TypedTuple<String>> entries = redisTemplate.opsForZSet().rangeByScoreWithScores(key, minScore,
  2246.                     maxScore, offset, count);
  2247.             log.info("zRangeByScoreWithScores(...) => entries -> {}", mapper.writeValueAsString(entries));
  2248.             return entries;
  2249.         }
  2250.  
  2251.  
  2252.         /**
  2253.          * 获取时,先按score倒序,然后根据索引位置,获取(key对应的)zset中排名处于[start,end]中的item项集
  2254.          *
  2255.          * @see ZSetOps#zRange(String, long, long) 只是zReverseRange这里会提前多一个倒序
  2256.          */
  2257.         public static Set<String> zReverseRange(String key, long start, long end) {
  2258.             log.info("zReverseRange(...) => key -> {},start -> {},end -> {}", key, start, end);
  2259.             Set<String> entries = redisTemplate.opsForZSet().reverseRange(key, start, end);
  2260.             log.info("zReverseRange(...) => entries -> {}", entries);
  2261.             return entries;
  2262.         }
  2263.  
  2264.         /**
  2265.          * 获取时,先按score倒序,然后根据索引位置,获取(key对应的)zset中排名处于[start,end]中的entry集
  2266.          *
  2267.          * @see ZSetOps#zRangeWithScores(String, long, long) 只是zReverseRangeWithScores这里会提前多一个倒序
  2268.          */
  2269.         @SneakyThrows
  2270.         public static Set<TypedTuple<String>> zReverseRangeWithScores(String key, long start, long end) {
  2271.             log.info("zReverseRangeWithScores(...) => key -> {},start -> {},end -> {}", key, start, end);
  2272.             Set<TypedTuple<String>> entries = redisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
  2273.             log.info("zReverseRangeWithScores(...) => entries -> {}", mapper.writeValueAsString(entries));
  2274.             return entries;
  2275.         }
  2276.  
  2277.         /**
  2278.          * 获取时,先按score倒序,然后根据score,获取(key对应的)zset中分数值处于[minScore,maxScore]中的item项集
  2279.          *
  2280.          * @see ZSetOps#zRangeByScore(String, double, double) 只是zReverseRangeByScore这里会提前多一个倒序
  2281.          */
  2282.         public static Set<String> zReverseRangeByScore(String key, double minScore, double maxScore) {
  2283.             log.info("zReverseRangeByScore(...) => key -> {},minScore -> {},maxScore -> {}",
  2284.                     key, minScore, maxScore);
  2285.             Set<String> items = redisTemplate.opsForZSet().reverseRangeByScore(key, minScore, maxScore);
  2286.             log.info("zReverseRangeByScore(...) => items -> {}", items);
  2287.             return items;
  2288.         }
  2289.  
  2290.         /**
  2291.          * 获取时,先按score倒序,然后获取(key对应的)zset中的所有score处于[minScore,maxScore]中的entry
  2292.          *
  2293.          * @see ZSetOps#zRangeByScoreWithScores(String, double, double) 只是zReverseRangeByScoreWithScores这里会提前多一个倒序
  2294.          */
  2295.         @SneakyThrows
  2296.         public static Set<TypedTuple<String>> zReverseRangeByScoreWithScores(String key, double minScore, double maxScore) {
  2297.             log.info("zReverseRangeByScoreWithScores(...) => key -> {},minScore -> {},maxScore -> {}",
  2298.                     key, minScore, maxScore);
  2299.             Set<TypedTuple<String>> entries = redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key,
  2300.                     minScore, maxScore);
  2301.             log.info("zReverseRangeByScoreWithScores(...) => entries -> {}", mapper.writeValueAsString(entries));
  2302.             return entries;
  2303.         }
  2304.  
  2305.         /**
  2306.          * 获取时,先按score倒序,然后根据score,获取(key对应的)zset中分数值处于[minScore,maxScore]中的,
  2307.          * score处于[minScore,排名大于等于offset的count个item项
  2308.          *
  2309.          * @see ZSetOps#zRangeByScore(String, double, double, long, long) 只是zReverseRangeByScore这里会提前多一个倒序
  2310.          */
  2311.         public static Set<String> zReverseRangeByScore(String key, double minScore, double maxScore, long offset, long count) {
  2312.             log.info("zReverseRangeByScore(...) => key -> {},minScore -> {},maxScore -> {},offset -> {},"
  2313.                     + "count -> {}", key, minScore, maxScore, offset, count);
  2314.             Set<String> items = redisTemplate.opsForZSet().reverseRangeByScore(key, minScore, maxScore, offset, count);
  2315.             log.info("items -> {}", items);
  2316.             return items;
  2317.         }
  2318.  
  2319.         /**
  2320.          * 统计(key对应的zset中)score处于[minScore,maxScore]中的item的个数
  2321.          *
  2322.          * @param key      定位zset的key
  2323.          * @param minScore score下限
  2324.          * @param maxScore score上限
  2325.          * @return [minScore, maxScore]中item的个数
  2326.          */
  2327.         public static long zCount(String key, double minScore, double maxScore) {
  2328.             log.info("zCount(...) => key -> {},minScore -> {},maxScore -> {}", key, minScore, maxScore);
  2329.             Long count = redisTemplate.opsForZSet().count(key, minScore, maxScore);
  2330.             log.info("zCount(...) => count -> {}", count);
  2331.             if (count == null) {
  2332.                 throw new RedisOpsResultIsNullException();
  2333.             }
  2334.             return count;
  2335.         }
  2336.  
  2337.         /**
  2338.          * 统计(key对应的)zset中item的个数
  2339.          * <p>
  2340.          * 注: 此方法等价于{@link ZSetOps#zZCard(String)}
  2341.          *
  2342.          * @param key 定位zset的key
  2343.          * @return zset中item的个数
  2344.          */
  2345.         public static long zSize(String key) {
  2346.             log.info("zSize(...) => key -> {}", key);
  2347.             Long size = redisTemplate.opsForZSet().size(key);
  2348.             log.info("zSize(...) => size -> {}", size);
  2349.             if (size == null) {
  2350.                 throw new RedisOpsResultIsNullException();
  2351.             }
  2352.             return size;
  2353.         }
  2354.  
  2355.         /**
  2356.          * 统计(key对应的)zset中item的个数
  2357.          * <p>
  2358.          * 注: 此方法等价于{@link ZSetOps#zSize(String)}
  2359.          *
  2360.          * @param key 定位zset的key
  2361.          * @return zset中item的个数
  2362.          */
  2363.         public static long zZCard(String key) {
  2364.             log.info("zZCard(...) => key -> {}", key);
  2365.             Long size = redisTemplate.opsForZSet().zCard(key);
  2366.             log.info("zZCard(...) => size -> {}", size);
  2367.             if (size == null) {
  2368.                 throw new RedisOpsResultIsNullException();
  2369.             }
  2370.             return size;
  2371.         }
  2372.  
  2373.         /**
  2374.          * 统计(key对应的)zset中指定item的score
  2375.          *
  2376.          * @param key  定位zset的key
  2377.          * @param item zset中的item
  2378.          * @return item的score
  2379.          */
  2380.         public static double zScore(String key, Object item) {
  2381.             log.info("zScore(...) => key -> {},item -> {}", key, item);
  2382.             Double score = redisTemplate.opsForZSet().score(key, item);
  2383.             log.info("zScore(...) => score -> {}", score);
  2384.             if (score == null) {
  2385.                 throw new RedisOpsResultIsNullException();
  2386.             }
  2387.             return score;
  2388.         }
  2389.  
  2390.         /**
  2391.          * 获取两个(key对应的)ZSet的并集,并将结果add到storeKey对应的ZSet中
  2392.          * <p>
  2393.          * 注: 和set一样,zset中item是唯一的,在多个zset进行Union时,处理相同的item时,score的值会变为对应的score之和,如：
  2394.          * RedisUtil.ZSetOps.zAdd("name1","a",1);和RedisUtil.ZSetOps.zAdd("name2","a",2);
  2395.          * 对(name1和name2对应的)zset进行zUnionAndStore之后,新的zset中的项a,对应的score值为3
  2396.          * <p>
  2397.          * case1: 交集不为空,storeKey不存在,则 会创建对应的storeKey,并将并集添加到(storeKey对应的)ZSet中
  2398.          * case2: 交集不为空,storeKey已存在,则 会清除原(storeKey对应的)ZSet中所有的项,然后将并集添加到(storeKey对应的)ZSet中
  2399.          * case3: 交集为空,则不进行下面的操作,直接返回0
  2400.          *
  2401.          * @param key      定位其中一个zset的键
  2402.          * @param otherKey 定位另外的zset的键
  2403.          * @param storeKey 定位(要把交集添加到哪个)set的key
  2404.          * @return add到(storeKey对应的)ZSet后, 该ZSet对应的size
  2405.          */
  2406.         public static long zUnionAndStore(String key, String otherKey, String storeKey) {
  2407.             log.info("zUnionAndStore(...) => key -> {},otherKey -> {},storeKey -> {}", key, otherKey, storeKey);
  2408.             Long size = redisTemplate.opsForZSet().unionAndStore(key, otherKey, storeKey);
  2409.             log.info("zUnionAndStore(...) => size -> {}", size);
  2410.             if (size == null) {
  2411.                 throw new RedisOpsResultIsNullException();
  2412.             }
  2413.             return size;
  2414.         }
  2415.  
  2416.         /**
  2417.          * 获取两个(key对应的)ZSet的并集,并将结果add到storeKey对应的ZSet中
  2418.          * <p>
  2419.          * 注: 和set一样,zset中item是唯一的,在多个zset进行Union时,处理相同的item时,score的值会变为对应的score之和,如：
  2420.          * RedisUtil.ZSetOps.zAdd("name1","a",1);和RedisUtil.ZSetOps.zAdd("name2","a",2);
  2421.          * 对(name1和name2对应的)zset进行zUnionAndStore之后,新的zset中的项a,对应的score值为3
  2422.          * <p>
  2423.          * case1: 并集不为空,storeKey不存在,则 会创建对应的storeKey,并将并集添加到(storeKey对应的)ZSet中
  2424.          * case2: 并集不为空,storeKey已存在,则 会清除原(storeKey对应的)ZSet中所有的项,然后将并集添加到(storeKey对应的)ZSet中
  2425.          * case3: 并集为空,则不进行下面的操作,直接返回0
  2426.          *
  2427.          * @param key       定位其中一个set的键
  2428.          * @param otherKeys 定位其它set的键集
  2429.          * @param storeKey  定位(要把并集添加到哪个)set的key
  2430.          * @return add到(storeKey对应的)ZSet后, 该ZSet对应的size
  2431.          */
  2432.         public static long zUnionAndStore(String key, Collection<String> otherKeys, String storeKey) {
  2433.             log.info("zUnionAndStore(...) => key -> {},otherKeys -> {},storeKey -> {}", key, otherKeys, storeKey);
  2434.             Long size = redisTemplate.opsForZSet().unionAndStore(key, otherKeys, storeKey);
  2435.             log.info("zUnionAndStore(...) => size -> {}", size);
  2436.             if (size == null) {
  2437.                 throw new RedisOpsResultIsNullException();
  2438.             }
  2439.             return size;
  2440.         }
  2441.  
  2442.         /**
  2443.          * 获取两个(key对应的)ZSet的交集,并将结果add到storeKey对应的ZSet中
  2444.          * <p>
  2445.          * 注: 和set一样,zset中item是唯一的,在多个zset进行Intersect时,处理相同的item时,score的值会变为对应的score之和,如：
  2446.          * RedisUtil.ZSetOps.zAdd("name1","a",1);
  2447.          * RedisUtil.ZSetOps.zAdd("name1","b",100);
  2448.          * 和R
  2449.          * edisUtil.ZSetOps.zAdd("name2","a",2);
  2450.          * edisUtil.ZSetOps.zAdd("name2","c",200);
  2451.          * 对(name1和name2对应的)zset进行zIntersectAndStore之后,新的zset中的项a,对应的score值为3
  2452.          * <p>
  2453.          * case1: 交集不为空,storeKey不存在,则 会创建对应的storeKey,并将交集添加到(storeKey对应的)ZSet中
  2454.          * case2: 交集不为空,storeKey已存在,则 会清除原(storeKey对应的)ZSet中所有的项,然后将交集添加到(storeKey对应的)ZSet中
  2455.          * case3: 交集为空,则不进行下面的操作,直接返回0
  2456.          *
  2457.          * @param key      定位其中一个ZSet的键
  2458.          * @param otherKey 定位其中另一个ZSet的键
  2459.          * @param storeKey 定位(要把交集添加到哪个)ZSet的key
  2460.          * @return add到(storeKey对应的)ZSet后, 该ZSet对应的size
  2461.          */
  2462.         public static long zIntersectAndStore(String key, String otherKey, String storeKey) {
  2463.             log.info("zIntersectAndStore(...) => key -> {},otherKey -> {},storeKey -> {}", key, otherKey, storeKey);
  2464.             Long size = redisTemplate.opsForZSet().intersectAndStore(key, otherKey, storeKey);
  2465.             log.info("zIntersectAndStore(...) => size -> {}", size);
  2466.             if (size == null) {
  2467.                 throw new RedisOpsResultIsNullException();
  2468.             }
  2469.             return size;
  2470.         }
  2471.  
  2472.         /**
  2473.          * 获取多个(key对应的)ZSet的交集,并将结果add到storeKey对应的ZSet中
  2474.          * <p>
  2475.          * case1: 交集不为空,storeKey不存在,则 会创建对应的storeKey,并将交集添加到(storeKey对应的)ZSet中
  2476.          * case2: 交集不为空,storeKey已存在,则 会清除原(storeKey对应的)ZSet中所有的项,然后将交集添加到(storeKey对应的)ZSet中
  2477.          * case3: 交集为空,则不进行下面的操作,直接返回0
  2478.          *
  2479.          * @param key       定位其中一个set的键
  2480.          * @param otherKeys 定位其它set的键集
  2481.          * @param storeKey  定位(要把并集添加到哪个)set的key
  2482.          * @return add到(storeKey对应的)ZSet后, 该ZSet对应的size
  2483.          */
  2484.         public static long zIntersectAndStore(String key, Collection<String> otherKeys, String storeKey) {
  2485.             log.info("zIntersectAndStore(...) => key -> {},otherKeys -> {},storeKey -> {}",
  2486.                     key, otherKeys, storeKey);
  2487.             Long size = redisTemplate.opsForZSet().intersectAndStore(key, otherKeys, storeKey);
  2488.             log.info("zIntersectAndStore(...) => size -> {}", size);
  2489.             if (size == null) {
  2490.                 throw new RedisOpsResultIsNullException();
  2491.             }
  2492.             return size;
  2493.         }
  2494.     }
  2495.  
  2496.     /**
  2497.      * redis分布式锁(单机版).
  2498.      * <p>
  2499.      * 使用方式(示例):
  2500.      * boolean flag = false;
  2501.      * String lockName = "sichuan:mianyang:fucheng:ds";
  2502.      * String lockValue = UUID.randomUUID().toString();
  2503.      * try {
  2504.      * //	非阻塞获取(锁的最大存活时间采用默认值)
  2505.      * flag = RedisUtil.LockOps.getLock(lockName,lockValue);
  2506.      * //	非阻塞获取e.g.
  2507.      * flag = RedisUtil.LockOps.getLock(lockName,lockValue,3,TimeUnit.SECONDS);
  2508.      * // 阻塞获取(锁的最大存活时间采用默认值)
  2509.      * flag = RedisUtil.LockOps.getLockUntilTimeout(lockName,lockValue,2000);
  2510.      * // 阻塞获取e.g.
  2511.      * flag = RedisUtil.LockOps.getLockUntilTimeout(lockName,lockValue,2,TimeUnit.SECONDS,2000);
  2512.      * if (!flag) {
  2513.      * throw new RuntimeException(" obtain redis-lock[" + lockName + "] fail");
  2514.      * }
  2515.      * // your logic
  2516.      * //	...
  2517.      * } finally {
  2518.      * if (flag) {
  2519.      * RedisUtil.LockOps.releaseLock(lockName,lockValue);
  2520.      * }
  2521.      * }
  2522.      * <p>
  2523.      * |--------------------------------------------------------------------------------------------------------------------|
  2524.      * |单机版分布式锁、集群版分布式锁,特别说明:                                                                                 |
  2525.      * |   - 此锁是针对单机Redis的分布式锁;                                                                                    |
  2526.      * |   - 对于Redis集群而言,此锁可能存在失效的情况考虑如下情况:                                                              |
  2527.      * |         首先,当客户端A通过key-value(假设为key名为key123)在Master上获取到一个锁                                        |
  2528.      * |         然后,Master试着把这个数据同步到Slave的时候突然挂了(此时Slave上没有该分布式锁的key123)                            |
  2529.      * |         接着,Slave变成了Master                                                                                    |
  2530.      * |         不巧的是,客户端B此时也一以相同的key去获取分布式锁；                                                              |
  2531.      * |                 因为现在的Master上没有key123代表的分布式锁,                                                           |
  2532.      * |                 所以客户端B此时再通过key123去获取分布式锁时,                                                           |
  2533.      * |                 就能获取成功                                                                                       |
  2534.      * |         那么此时,客户端A和客户端B同时获取到了同一把分布式锁,分布式锁失效                                                 |
  2535.      * |   - 在Redis集群模式下,如果需要严格的分布式锁的话,可使用Redlock算法来实现Redlock算法原理简述:                              |
  2536.      * |     - 获取分布式锁：                                                                                                 |
  2537.      * |           1. 客户端获取服务器当前的的时间t0                                                                           |
  2538.      * |           2. 使用相同的key和value依次向5个实例获取锁                                                                  |
  2539.      * |              注:为了避免在某个redis节点耗时太久而影响到对后面的Redis节点的锁的获取;                                         |
  2540.      * |                 客户端在获取每一个Redis节点的锁的时候,自身需要设置一个较小的等待获取锁超时的时间,                            |
  2541.      * |                 一旦都在某个节点获取分布式锁的时间超过了超时时间,那么就认为在这个节点获取分布式锁失败,                       |
  2542.      * |                 （不把时间浪费在这一个节点上）,继续获取下一个节点的分布式锁                                              |
  2543.      * |           3. 客户端通过当前时间(t1)减去t0,计算(从所有redis节点)获取锁所消耗的总时间t2(注：t2=t1-t0)                      |
  2544.      * |              只有t2小于锁本身的锁定时长(注:若锁的锁定时长是1小时,假设下午一点开始上锁,那么锁会在下午两点                     |
  2545.      * |              的时候失效,而你却在两点后才获取到锁,这个时候已经没意义了),并且,客户端在至少在多半Redis                        |
  2546.      * |              节点上获取到锁,我们才认为分布式锁获取成功                                                                |
  2547.      * |           5. 如果锁已经获取,那么  锁的实际有效时长 = 锁的总有效时长 - 获取分布式锁所消耗的时长; 锁的实际有效时长 应保证 > 0    |
  2548.      * |              注: 也就是说,如果获取锁失败,那么                                                                        |
  2549.      * |                  A. 可能是   获取到的锁的个数,不满足大多数原则                                                         |
  2550.      * |                  B. 也可能是 锁的实际有效时长不大于0                                                                  |
  2551.      * |      - 释放分布式锁： 在每个redis节点上试着删除锁(,不论有没有在该节点上获取到锁)                                          |
  2552.      * |   - 集群下的分布式锁,可直接使用现有类库<a href="https://github.com/redisson/redisson"/>                                |
  2553.      * |                                                                                                                    |
  2554.      * |   注: 如果Redis集群项目能够容忍master宕机导致单机版分布式锁失效的情况的话,那么是直接使用单机版分布式锁在Redis集群的项目中的；     |
  2555.      * |       如果Redis集群项目不能容忍单机版分布式锁失效的情况的话,那么请使用基于RedLock算法的集群版分布式锁；                        |
  2556.      * |--------------------------------------------------------------------------------------------------------------------|
  2557.      */
  2558.     public static class LockOps {
  2559.  
  2560.         /**
  2561.          * lua脚本,保证 释放锁脚本 的原子性(以避免,并发场景下,释放了别人的锁)
  2562.          */
  2563.         private static final String RELEASE_LOCK_LUA;
  2564.  
  2565.         /**
  2566.          * 分布式锁默认(最大)存活时长
  2567.          */
  2568.         public static final long DEFAULT_LOCK_TIMEOUT = 3;
  2569.  
  2570.         /**
  2571.          * DEFAULT_LOCK_TIMEOUT的单位
  2572.          */
  2573.         public static final TimeUnit DEFAULT_TIMEOUT_UNIT = TimeUnit.SECONDS;
  2574.  
  2575.         static {
  2576.             // 不论lua中0是否代表失败; 对于java的Boolean而言,返回0,则会被解析为false
  2577.             RELEASE_LOCK_LUA = "if redis.call('get',KEYS[1]) == ARGV[1] "
  2578.                     + "then "
  2579.                     + "    return redis.call('del',KEYS[1]) "
  2580.                     + "else "
  2581.                     + "    return 0 "
  2582.                     + "end ";
  2583.         }
  2584.  
  2585.         /**
  2586.          * 获取(分布式)锁.
  2587.          * <p>
  2588.          * 注: 获取结果是即时返回的、是非阻塞的
  2589.          *
  2590.          * @see LockOps#getLock(String, String, long, TimeUnit)
  2591.          */
  2592.         public static boolean getLock(final String key, final String value) {
  2593.             return getLock(key, value, DEFAULT_LOCK_TIMEOUT, DEFAULT_TIMEOUT_UNIT);
  2594.         }
  2595.  
  2596.         /**
  2597.          * 获取(分布式)锁
  2598.          * 若成功,则直接返回;
  2599.          * 若失败,则进行重试,直到成功 或 超时为止
  2600.          * <p>
  2601.          * 注: 获取结果是阻塞的,要么成功,要么超时,才返回
  2602.          *
  2603.          * @param retryTimeoutLimit 重试的超时时长(ms)
  2604.          *                          其它参数可详见:
  2605.          * @return 是否成功
  2606.          * @see LockOps#getLock(String, String, long, TimeUnit)
  2607.          */
  2608.         public static boolean getLockUntilTimeout(final String key, final String value,
  2609.                                                   final long retryTimeoutLimit) {
  2610.             return getLockUntilTimeout(key, value, DEFAULT_LOCK_TIMEOUT, DEFAULT_TIMEOUT_UNIT, retryTimeoutLimit);
  2611.         }
  2612.  
  2613.         /**
  2614.          * 获取(分布式)锁
  2615.          * 若成功,则直接返回;
  2616.          * 若失败,则进行重试,直到成功 或 超时为止
  2617.          * <p>
  2618.          * 注: 获取结果是阻塞的,要么成功,要么超时,才返回
  2619.          *
  2620.          * @param retryTimeoutLimit 重试的超时时长(ms)
  2621.          *                          其它参数可详见:
  2622.          * @return 是否成功
  2623.          * @see LockOps#getLock(String, String, long, TimeUnit, boolean)
  2624.          */
  2625.         public static boolean getLockUntilTimeout(final String key, final String value,
  2626.                                                   final long timeout, final TimeUnit unit,
  2627.                                                   final long retryTimeoutLimit) {
  2628.             log.info("getLockUntilTimeout(...) => key -> {},value -> {},timeout -> {},unit -> {},"
  2629.                     + "retryTimeoutLimit -> {}ms", key, value, timeout, unit, retryTimeoutLimit);
  2630.             long startTime = Instant.now().toEpochMilli();
  2631.             long now = startTime;
  2632.             do {
  2633.                 try {
  2634.                     boolean alreadyGotLock = getLock(key, value, timeout, unit, false);
  2635.                     if (alreadyGotLock) {
  2636.                         log.info("getLockUntilTimeout(...) => consume time -> {}ms,result -> true", now - startTime);
  2637.                         return true;
  2638.                     }
  2639.                 } catch (Exception e) {
  2640.                     log.warn("getLockUntilTimeout(...) => try to get lock failure! e.getMessage -> {}",
  2641.                             e.getMessage());
  2642.                 }
  2643.                 now = Instant.now().toEpochMilli();
  2644.             } while (now < startTime + retryTimeoutLimit);
  2645.             log.info("getLockUntilTimeout(...) => consume time -> {}ms,result -> false", now - startTime);
  2646.             return false;
  2647.         }
  2648.  
  2649.         /**
  2650.          * 获取(分布式)锁
  2651.          * <p>
  2652.          * 注: 获取结果是即时返回的、是非阻塞的
  2653.          *
  2654.          * @see LockOps#getLock(String, String, long, TimeUnit, boolean)
  2655.          */
  2656.         public static boolean getLock(final String key, final String value,
  2657.                                       final long timeout, final TimeUnit unit) {
  2658.             return getLock(key, value, timeout, unit, true);
  2659.         }
  2660.  
  2661.         /**
  2662.          * 获取(分布式)锁
  2663.          * <p>
  2664.          * 注: 获取结果是即时返回的、是非阻塞的
  2665.          *
  2666.          * @param key       锁名
  2667.          * @param value     锁名对应的value
  2668.          *                  注: value一般采用全局唯一的值,如: requestId、uuid等
  2669.          *                  这样,释放锁的时候,可以再次验证value值,
  2670.          *                  保证自己上的锁只能被自己释放,而不会被别人释放
  2671.          *                  当然,如果锁超时时,会被redis自动删除释放
  2672.          * @param timeout   锁的(最大)存活时长
  2673.          *                  注: 一般的,获取锁与释放锁 都是成对使用的,在锁在达到(最大)存活时长之前,都会被主动释放
  2674.          *                  但是在某些情况下(如:程序获取锁后,释放锁前,崩了),锁得不到释放,这时就需要等锁过
  2675.          *                  了(最大)存活时长后,被redis自动删除清理了这样就能保证redis中不会留下死数据
  2676.          * @param unit      timeout的单位
  2677.          * @param recordLog 是否记录日志
  2678.          * @return 是否成功
  2679.          */
  2680.         public static boolean getLock(final String key, final String value,
  2681.                                       final long timeout, final TimeUnit unit,
  2682.                                       boolean recordLog) {
  2683.             if (recordLog) {
  2684.                 log.info("getLock(...) => key -> {},value -> {},timeout -> {},unit -> {},recordLog -> {}",
  2685.                         key, value, timeout, unit, recordLog);
  2686.             }
  2687.             Boolean result = redisTemplate.execute((RedisConnection connection) ->
  2688.                     connection.set(key.getBytes(StandardCharsets.UTF_8),
  2689.                             value.getBytes(StandardCharsets.UTF_8),
  2690.                             Expiration.seconds(unit.toSeconds(timeout)),
  2691.                             RedisStringCommands.SetOption.SET_IF_ABSENT)
  2692.             );
  2693.             if (recordLog) {
  2694.                 log.info("getLock(...) => result -> {}", result);
  2695.             }
  2696.             if (result == null) {
  2697.                 throw new RedisOpsResultIsNullException();
  2698.             }
  2699.             return result;
  2700.         }
  2701.  
  2702.         /**
  2703.          * 释放(分布式)锁
  2704.          * <p>
  2705.          * 注: 此方式能(通过value的唯一性)保证: 自己加的锁,只能被自己释放
  2706.          * 注: 锁超时时,也会被redis自动删除释放
  2707.          *
  2708.          * @param key   锁名
  2709.          * @param value 锁名对应的value
  2710.          * @return 释放锁是否成功
  2711.          */
  2712.         public static boolean releaseLock(final String key, final String value) {
  2713.             log.info("releaseLock(...) => key -> {},lockValue -> {}", key, value);
  2714.             Boolean result = redisTemplate.execute((RedisConnection connection) ->
  2715.                     connection.eval(RELEASE_LOCK_LUA.getBytes(),
  2716.                             ReturnType.BOOLEAN, 1,
  2717.                             key.getBytes(StandardCharsets.UTF_8), value.getBytes(StandardCharsets.UTF_8))
  2718.             );
  2719.             log.info("releaseLock(...) => result -> {}", result);
  2720.             if (result == null) {
  2721.                 throw new RedisOpsResultIsNullException();
  2722.             }
  2723.             return result;
  2724.         }
  2725.  
  2726.         /**
  2727.          * 释放锁,不校验该key对应的value值
  2728.          * <p>
  2729.          * 注: 此方式释放锁,可能导致: 自己加的锁,结果被别人释放了
  2730.          * 所以不建议使用此方式释放锁
  2731.          *
  2732.          * @param key 锁名
  2733.          */
  2734.         @Deprecated
  2735.         public static void releaseLock(final String key) {
  2736.             KeyOps.delete(key);
  2737.         }
  2738.     }
  2739.  
  2740.     /**
  2741.      * 当使用Pipeline 或 Transaction操作redis时,(不论redis中实际操作是否成功,这里)结果(都)会返回null
  2742.      * 此时,如果试着将null转换为基本类型的数据时,会抛出此异常
  2743.      * <p>
  2744.      * 即: 此工具类中的某些方法,希望不要使用Pipeline或Transaction操作redis
  2745.      * <p>
  2746.      * 注: Pipeline 或 Transaction默认是不启用的,可详见源码:
  2747.      *
  2748.      * @see LettuceConnection#isPipelined()
  2749.      * @see LettuceConnection#isQueueing()
  2750.      * @see JedisConnection#isPipelined()
  2751.      * @see JedisConnection#isQueueing()
  2752.      */
  2753.     public static class RedisOpsResultIsNullException extends NullPointerException {
  2754.  
  2755.         public RedisOpsResultIsNullException() {
  2756.             super();
  2757.         }
  2758.  
  2759.         public RedisOpsResultIsNullException(String message) {
  2760.             super(message);
  2761.         }
  2762.     }
  2763.  
  2764.     /**
  2765.      * 提供一些基础功能支持
  2766.      */
  2767.     public static class Helper {
  2768.  
  2769.         /**
  2770.          * 默认拼接符
  2771.          */
  2772.         public static final String DEFAULT_SYMBOL = ":";
  2773.  
  2774.         /**
  2775.          * 拼接args
  2776.          *
  2777.          * @see Helper#joinBySymbol(String, String...)
  2778.          */
  2779.         public static String join(String... args) {
  2780.             return Helper.joinBySymbol(DEFAULT_SYMBOL, args);
  2781.         }
  2782.  
  2783.         /**
  2784.          * 使用symbol拼接args
  2785.          *
  2786.          * @param symbol 分隔符,如: 【:】
  2787.          * @param args   要拼接的元素数组,如: 【a b c】
  2788.          * @return 拼接后的字符串, 如  【a:b:c】
  2789.          */
  2790.         public static String joinBySymbol(String symbol, String... args) {
  2791.             if (symbol == null || symbol.trim().length() == 0) {
  2792.                 throw new RuntimeException(" symbol must not be empty!");
  2793.             }
  2794.             if (args == null || args.length == 0) {
  2795.                 throw new RuntimeException(" args must not be empty!");
  2796.             }
  2797.             StringBuilder sb = new StringBuilder(16);
  2798.             for (String arg : args) {
  2799.                 sb.append(arg).append(symbol);
  2800.             }
  2801.             sb.replace(sb.length() - symbol.length(), sb.length(), "");
  2802.             return sb.toString();
  2803.         }
  2804.  
  2805.     }
  2806. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/703881
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号