AI 助理
备案控制台
开发者社区 数据库 文章 正文

SpringBoot整合Redis(十九)上

2022-01-09 414
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
Redis 开源版，标准版 2GB
推荐场景：
搭建游戏排行榜
云数据库 Tair（兼容Redis），内存型 2GB
推荐场景：
通过缓存加速数据库访问
简介： 一. Redis的介绍和安装二. SpringBoot 整合 Redis的简单用法

一. Redis的介绍和安装

关于Redis介绍和教程，可以看官网介绍


Redis教程


Redis的 Windows版本的安装，可以看官网介绍:


Redis Windows 版本安装


二. SpringBoot 整合 Redis的简单用法

二.一 环境准备

二.一.一 Redis服务器安装并且启动成功

说明目前 Redis服务器启动成功， 客户端可以正常的连接，访问并操作。

127.0.0.1:6379> auth zk123   // 密码登录
OK
127.0.0.1:6379> select 15    //选择第16个，即最后一个数据库进行操作
OK
127.0.0.1:6379[15]> set name TwoButterfly   //set 命令设置值
OK
127.0.0.1:6379[15]> get name     //get 命令获取值
"TwoButterfly"
127.0.0.1:6379[15]> flushdb     //清空当前数据库的信息
OK
127.0.0.1:6379[15]> keys *    //查询数据库的信息
(empty list or set)
127.0.0.1:6379[15]>

1.png

二.一.二 创建SpringBoot整合Redis的项目 SpringBoot_Redis

按照 SpringBoot整合Mybatis的项目 SpringBoot_MyBatis 即可。

具体可以看 老蝴蝶以前写的文章。

springboot 数据库下有一个 user表， 对应的实体类为:

User.java

@Data
public class User implements Serializable {
    /**
     * @param id id编号
     * @param name 姓名
     * @param sex 性别
     * @param age 年龄
     * @param description 描述
     */
    private Integer id;
    private String name;
    private String sex;
    private Integer age;
    private String description;
}

接下来，才是整合的关键.

二.二 pom.xml 添加依赖

在原有的依赖基础上，添加新的依赖

<!--依赖 data-redis的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--不能忘记这个依赖-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

二.三 application.yml 配置文件配置Redis的相关信息

# 引入 数据库的相关配置
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springboot?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=UTF-8&useSSL=false&allowMultiQueries=true
    username: root
    password: abc123
  # 配置Redis的使用
  redis:
    database: 15 # 所使用的数据库  默认是0
    host: 127.0.0.1  #所使用的redis的主机地址
    port: 6379  # 端口号  默认是 6379
    password: zk123 # 密码
    timeout: 5000 # 超时时间  5000毫秒
    # 连接池 lettuce 的配置
    lettuce:
      pool:
        max-active: 100
        min-idle: 10
        max-wait: 100000

只需要简单的这两步，就可以将 Redis整合进来了。

二.四 SpringBoot整合Redis测试 RedisTests

只用简单的设置字符串和对象的操作，进行演示。

二.四.一 字符串类型测试

@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
@Log4j2
public class RedisTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    /**
     * 用String 进行举例。
     */
    @Test
    public void stringTest(){
        //1. 放置普通的字符串信息
        String name="岳泽霖";
        redisTemplate.opsForValue().set("name",name);
        String getName=(String)redisTemplate.opsForValue().get("name");
        log.info("RedisTemplate获取信息:"+getName);
        stringRedisTemplate.opsForValue().set("sname",name);
        String sGetName=stringRedisTemplate.opsForValue().get("sname");
        log.info("StringRedisTemplate 获取信息:>>>"+sGetName);
    }
}

控制台打印:

2.png

控制台 打印的，都是正常的，不乱码。

通过Redis 客户端 进行查看

3.png

可以发现， RedisTemplate 设置的 name 变成了 乱码， 而 StringTemplate 并没有乱码。

查看对应的值 ,先看 name 的

4.png

发现 值 value 也是乱码的。

再看 sname 的:

5.png

值并不是乱码的。

二.四.二 设置 Bean 测试

@Test
    public void beanTest(){
        //1. 放置JavaBean 信息
        User user=new User();
        user.setId(1);
        user.setName("岳泽霖");
        user.setSex("男");
        user.setAge(26);
        user.setDescription("一个快乐的程序员");
        redisTemplate.opsForValue().set("bean",user);
        //获取信息
        User rUser=(User)redisTemplate.opsForValue().get("bean");
        log.info("RedisTemplate获取用户信息:>>>"+rUser.toString());
        //StringRedisTemplate 放置对象 user, 不太好放置。
    }

运行，控制台打印输出

6.png

从Redis客户端进行查看:

7.png

对象值发生了乱码， 不易查看。

发生乱码的原因，实际是没有对key 和 value进行相关的序列化。

二.五 Redis 对Key 和Value 序列化配置

二.五.一 序列化配置 RedisConfig

package top.yueshushu.learn.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisConfig {
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(new StringRedisSerializer());
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

二.五.二 序列化测试

依次运行 stringTest（） 方法和 beanTest() 方法， 查看客户端的相关信息

name:

8.png

bean:

9.png

这个时候，就很直观的展示出来了。

二.六 RedisUtil 工具类

Redis可以对 String,List,Set,Map,ZSet 等多种类型进行操作，一般都会创建相应的工具类。

老蝴蝶也创建了一个相应的工具类，方便使用。

package top.yueshushu.learn.util;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
@Slf4j
@Component(value = "redisUtil")
public class RedisUtil {
  @Resource
  private RedisTemplate<String, Object> redisTemplate;
  /** -------------------1.key相关操作--------------------- */
  /******1.1 删除操作开始******/
  /**
   * 功能描述: 通过key删除key
   */
  public void delByKey(String key) {
    redisTemplate.delete(key);
  }
  /**
   * 功能描述: 删除某个key是否成功，如果删除失败,则返回false.
   *
   * @param key redis的键值
   * @return 返回是否删除成功
   */
  public boolean remove(String key) {
    return Boolean.TRUE.equals(redisTemplate.delete(key));
  }
  /**
   * 功能描述: （谨慎使用） 以key为 前缀 模糊删除所有相关缓存数据 key+*
   *
   * @param key 删除redis键值对的 前缀匹配
   */
  public void deleteByPrefix(String key) {
    Set<String> keys = redisTemplate.keys(key + "*");
    if (!!CollectionUtils.isEmpty(keys)) {
      redisTemplate.delete(keys);
    }
  }
  /**
   * 功能描述:（谨慎使用）以key为 后缀 模糊删除所有相关缓存数据 *+key
   *
   * @param key 删除redis键值对的 后缀
   */
  public void deleteBySuffix(String key) {
    Set<String> keys = redisTemplate.keys("*" + key);
    if (!CollectionUtils.isEmpty(keys)) {
      redisTemplate.delete(keys);
    }
  }
  /**
   * 功能描述: 批量删除多个key
   *
   * @param keys 删除多个key,集合的形式
   */
  public void delete(Collection<String> keys) {
    redisTemplate.delete(keys);
  }
  public Long unlink(List<String> keys){
    return redisTemplate.unlink(keys);
  }
  public Boolean unlink(String key){
    return redisTemplate.unlink(key);
  }
  /**
   * 功能描述: （谨慎使用） 以key为 前缀 模糊删除所有相关缓存数据 key+*
   * @param key 删除redis键值对的 前缀匹配
   */
  public void unlinkByPrefix(String key) {
    Set<String> keys = redisTemplate.keys(key + "*");
    if (!!CollectionUtils.isEmpty(keys)) {
      redisTemplate.unlink(keys);
    }
  }
  /**
   * 功能描述:（谨慎使用）以key为 后缀 模糊删除所有相关缓存数据 *+key
   *
   * @param key 删除redis键值对的 后缀
   */
  public void unlinkBySuffix(String key) {
    Set<String> keys = redisTemplate.keys("*" + key);
    if (!CollectionUtils.isEmpty(keys)) {
      redisTemplate.unlink(keys);
    }
  }
  /******1.1 删除操作结束******/
  /******1.2 设置值操作开始******/
  /**
   * 功能描述: 通过key键存储值，可以是字符串，也可以是Java Bean对象。
   *
   * @param key   redis的键值
   * @param value 存储的值信息
   * @return 返回是否存储成功
   */
  public boolean set(String key, Object value) {
    try {
      redisTemplate.opsForValue().set(key, value);
      return true;
    } catch (Exception e) {
      log.error(e.getMessage(), e);
      return false;
    }
  }
  /**
   * 功能描述: 通过key键存储值,有失效时间，可以是字符串，也可以是Java Bean对象。
   *
   * @param key           redis的键值
   * @param value         存储的值信息
   * @param expireSeconds 失效的时间，单位是秒
   * @return 返回是否存储成功
   */
  public boolean set(String key, Object value, long expireSeconds) {
    try {
      if (expireSeconds > 0) {
        redisTemplate.opsForValue().set(key, value, expireSeconds, TimeUnit.SECONDS);
      } else {
        redisTemplate.opsForValue().set(key, value);
      }
      return true;
    } catch (Exception e) {
      log.error(e.getMessage(), e);
      return false;
    }
  }
  /**
   * 功能描述: 通过key键存储值,有失效时间，可以是字符串，也可以是Java Bean对象。
   *
   * @param key      redis的键值
   * @param value    存储的值信息
   * @param time     失效的时间
   * @param timeUnit 失效的时间单位，有秒，分钟，小时，天。
   * @return 返回是否存储成功
   */
  public boolean set(String key, Object value, long time, TimeUnit timeUnit) {
    try {
      if (time > 0) {
        redisTemplate.opsForValue().set(key, value, time, timeUnit);
      } else {
        redisTemplate.opsForValue().set(key, value);
      }
      return true;
    } catch (Exception e) {
      log.error("发生异常", e);
      return false;
    }
  }
  /**
   * 功能描述: 通过key键存储值,指定失效日期，可以是字符串，也可以是Java Bean对象。
   * @param key redis的键值
   * @param value 存储的值信息
   * @param date 失效的时间
   * @return 返回是否存储成功
   */
  public boolean setExpireAt(String key, Object value, Date date) {
    try {
      redisTemplate.opsForValue().set(key, value);
      redisTemplate.expireAt(key, date);
      return true;
    } catch (Exception e) {
      log.error("发生异常", e);
      return false;
    }
  }
  /**
   * 功能描述: 如果key值，不存在，才进行设置。 通过key键存储值，可以是字符串，也可以是Java Bean对象。
   *
   * @param key   redis的键值
   * @param value 存储的值信息
   * @return 返回是否存储成功
   */
  public boolean setIfAbsent(String key, Object value) {
    try {
      return redisTemplate.opsForValue().setIfAbsent(key, value);
    } catch (Exception e) {
      log.error(e.getMessage(), e);
      return false;
    }
  }
  /**
   * 功能描述: 如果key值，不存在，才进行设置。通过key键存储值,有失效时间，可以是字符串，也可以是Java Bean对象。
   *
   * @param key           redis的键值
   * @param value         存储的值信息
   * @param expireSeconds 失效的时间，单位是秒
   * @return 返回是否存储成功
   */
  public boolean setIfAbsent(String key, Object value, long expireSeconds) {
    try {
      if (expireSeconds > 0) {
        return redisTemplate.opsForValue().setIfAbsent(key, value, expireSeconds, TimeUnit.SECONDS);
      } else {
        return redisTemplate.opsForValue().setIfAbsent(key, value);
      }
    } catch (Exception e) {
      log.error(e.getMessage(), e);
      return false;
    }
  }
  /**
   * 功能描述: 如果key值，不存在，才进行设置。通过key键存储值,有失效时间，可以是字符串，也可以是Java Bean对象。
   *
   * @param key      redis的键值
   * @param value    存储的值信息
   * @param time     失效的时间
   * @param timeUnit 失效的时间单位，有秒，分钟，小时，天。
   * @return 返回是否存储成功
   */
  public boolean setIfAbsent(String key, Object value, long time, TimeUnit timeUnit) {
    try {
      if (time > 0) {
        return redisTemplate.opsForValue().setIfAbsent(key, value, time, timeUnit);
      } else {
        return redisTemplate.opsForValue().setIfAbsent(key, value);
      }
    } catch (Exception e) {
      log.error("发生异常", e);
      return false;
    }
  }
  /**
   * 功能描述:批量添加值,map形式
   *
   * @param maps 要添加的键值对集合
   */
  public void multiSet(Map<String, Object> maps) {
    redisTemplate.opsForValue().multiSet(maps);
  }
  /**
   * 功能描述: 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在
   *
   * @param maps 要添加的键值对集合
   * @return 之前已经存在返回false, 不存在返回true
   */
  public boolean multiSetIfAbsent(Map<String, Object> maps) {
    return redisTemplate.opsForValue().multiSetIfAbsent(maps);
  }
  /******1.2 设置值操作结束******/
  /******1.3 获取值操作开始******/
  /**
   * 功能描述: 获取指定 key 的值,Object类型， 可以返回字符串，也可以返回 JavaBean 对象。
   *
   * @param key redis的键值
   * @return 返回键值所对应的值
   */
  public Object getForObject(String key) {
    return redisTemplate.opsForValue().get(key);
  }
  /**
   * 功能描述: 获取指定 key 的值,常用于返回 JavaBean 对象。
   *
   * @param key redis的键值
   * @return 返回键值所对应的值，JavaBean形式。
   */
  public <V> V get(Object key) {
    try {
      return (V) redisTemplate.opsForValue().get(key);
    } catch (Exception e) {
      log.error(e.getMessage(), e);
      return null;
    }
  }
  /**
   * 功能描述: 将给定 key 的值设为 value ，并返回 key 的旧值(old value)
   *
   * @param key      redis的键值
   * @param newValue 设置新值
   * @return 返回key的旧值
   */
  public Object getAndSet(String key, Object newValue) {
    return redisTemplate.opsForValue().getAndSet(key, newValue);
  }
  /**
   * 功能描述: 批量获取相应的key的值列表信息
   *
   * @param keys
   * @return
   */
  public List<Object> multiGet(Collection<String> keys) {
    return redisTemplate.opsForValue().multiGet(keys);
  }
  /******1.3 获取值操作结束******/
  /******1.4 过期操作开始******/
  /**
   * 功能描述: 设置key的过期时间，单位是小时
   *
   * @param key      redis的键值
   * @param timeHour 过期时间，单位是小时
   */
  public void setExpire(String key, int timeHour) {
    redisTemplate.expire(key, timeHour, TimeUnit.HOURS);
  }
  /**
   * 功能描述: 设置key的过期时间，单位可以自定义
   *
   * @param key      redis的键值
   * @param timeout  过期时间
   * @param timeUnit 过期时间的基本单位
   */
  public void setExpire(String key, int timeout, TimeUnit timeUnit) {
    redisTemplate.expire(key, timeout, timeUnit);
  }
  /**
   * 功能描述: 设置key的过期时间，是否设置成功。 单位可以自定义
   *
   * @param key      redis的键值
   * @param timeout  过期时间
   * @param timeUnit 过期时间的基本单位
   * @return 返回是否设置成功
   */
  public Boolean expire(String key, long timeout, TimeUnit timeUnit) {
    return redisTemplate.expire(key, timeout, timeUnit);
  }
  /**
   * 功能描述: 设置key值在 date 时间时过期。
   *
   * @param key  redis的键值
   * @param date 设置的过期时间
   * @return 返回是否设置成功
   */
  public Boolean expireAt(String key, Date date) {
    return redisTemplate.expireAt(key, date);
  }
  /**
   * 功能描述: 返回 key 的剩余的过期时间,单位是秒
   *
   * @param key redis的键值
   * @return 返回 key 的剩余的过期时间,单位是秒
   */
  public Long getExpire(String key) {
    return redisTemplate.getExpire(key);
  }
  /**
   * 功能描述: 返回 key 的剩余的过期时间,单位自定义
   *
   * @param key      redis的键值
   * @param timeUnit 日期单位
   * @return 返回 key 的剩余的过期时间,单位自定义
   */
  public Long getExpire(String key, TimeUnit timeUnit) {
    return redisTemplate.getExpire(key, timeUnit);
  }
  /**
   * 功能描述: 移除 key 的过期时间，key 将持久保持
   *
   * @param key redis的键值
   * @return 返回是否设置成功
   */
  public Boolean persist(String key) {
    return redisTemplate.persist(key);
  }
  /******1.4 过期值操作结束******/
  /******1.5 其他key操作开始******/
  /**
   * 功能描述: 序列化key
   *
   * @param key redis的键值
   * @return 返回序列化好的key值
   */
  public byte[] dump(String key) {
    return redisTemplate.dump(key);
  }
  /**
   * 功能描述:是否存在key
   *
   * @param key redis的键值
   * @return true表示存在该key, false表示不存在该key
   */
  public Boolean hasKey(String key) {
    return redisTemplate.hasKey(key);
  }
  /**
   * 功能描述: 查找能匹配到的key
   *
   * @param pattern 匹配的正则式
   * @return 查找能匹配到的key
   */
  public Set<String> keys(String pattern) {
    return redisTemplate.keys(pattern);
  }
  /**
   * 功能描述: 查找能匹配到的key
   *
   * @param keyPattern 匹配的正则式
   * @return 查找能匹配到的key
   */
  public Set<String> getKeys(String keyPattern) {
    return redisTemplate.keys(keyPattern);
  }
  /**
   * 功能描述: 将当前数据库的 key 移动到给定的数据库 db 当中
   *
   * @param key     redis的键值
   * @param dbIndex 要移动到的数据，默认为0~15
   * @return
   */
  public Boolean move(String key, int dbIndex) {
    return redisTemplate.move(key, dbIndex);
  }
  /**
   * 功能描述： 从当前数据库中随机返回一个 key
   *
   * @return 随机返回一个key
   */
  public String randomKey() {
    return redisTemplate.randomKey();
  }
  /**
   * 功能描述：修改 key 的名称
   *
   * @param oldKey 老的键
   * @param newKey 新的键值
   */
  public void rename(String oldKey, String newKey) {
    redisTemplate.rename(oldKey, newKey);
  }
  /**
   * 功能描述: 仅当 newkey 不存在时，将 oldKey 改名为 newkey
   *
   * @param oldKey 老的键
   * @param newKey 新的键值
   * @return 返回设置是否成功
   */
  public Boolean renameIfAbsent(String oldKey, String newKey) {
    return redisTemplate.renameIfAbsent(oldKey, newKey);
  }
  /**
   * 功能描述: 返回 key 所储存的值的类型 为五种数据类型和none
   *
   * @param key redis的键值
   * @return 返回当前键值的数据类型
   */
  public DataType type(String key) {
    return redisTemplate.type(key);
  }
  /******1.5 其他key操作结束******/
  /** -------------------string相关操作--------------------- */
  /**
   * 功能描述:设置指定 key 的值
   *
   * @param key   redis的键值
   * @param value 键值要保存的字符串值
   */
  public void setForStr(String key, String value) {
    redisTemplate.opsForValue().set(key, value);
  }
  /**
   * 功能描述: 返回指定 key 的值
   *
   * @param key redis的键值
   */
  public String getForStr(String key) {
    Object value = redisTemplate.opsForValue().get(key);
    return null == value ? null : value.toString();
  }
  /**
   * 功能描述:返回 key 中字符串值的子字符
   *
   * @param key   redis的键值
   * @param start 开始索引
   * @param end   结束索引
   * @return 返回截取字符串的值
   */
  public String getRange(String key, long start, long end) {
    return redisTemplate.opsForValue().get(key, start, end);
  }
  /**
   * 功能描述: 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始
   *
   * @param key    redis的键值
   * @param value  要替换的值
   * @param offset 从指定位置开始覆写
   */
  public void setRange(String key, String value, long offset) {
    redisTemplate.opsForValue().set(key, value, offset);
  }
  /**
   * 功能描述:获取字符串的长度
   *
   * @param key redis的键值
   * @return 返回字符串的长度
   */
  public Long size(String key) {
    return redisTemplate.opsForValue().size(key);
  }
  /**
   * 功能描述: 将key对应的数字型字符串值加1
   *
   * @param key redis的键值 存储的是数字型字符串
   * @return 返回增加后的新值
   */
  public Long increment(String key) {
    return redisTemplate.opsForValue().increment(key);
  }
  /**
   * 功能描述: 增加(自增长), 负数则为自减
   *
   * @param key   redis的键值 存储的是数字型字符串
   * @param delta 增加的步长
   * @return 返回增加后的新值
   */
  public Long increment(String key, long delta) {
    return redisTemplate.opsForValue().increment(key, delta);
  }
  /**
   * 功能描述: 增加(自增长), 负数则为自减，可增加浮点型数
   *
   * @param key       redis的键值 存储的是数字型字符串
   * @param increment 增加的步长
   * @return 返回增加后的新值
   */
  public Double incrementByDouble(String key, double increment) {
    return redisTemplate.opsForValue().increment(key, increment);
  }
  /**
   * 功能描述: 追加到末尾,字符串添加
   *
   * @param key   redis的键值
   * @param value 要追加的值
   * @return 返回追加后的新值
   */
  public Integer append(String key, String value) {
    return redisTemplate.opsForValue().append(key, value);
  }
  /** -------------------3.hash相关操作------------------------- */
  /******3.1放置值开始******/
  /**
   * 功能描述: 往key 里面放置单个值
   *
   * @param key     redis的键值
   * @param hashKey 列字段名
   * @param value   列字段对应的值
   */
  public void hPut(String key, String hashKey, Object value) {
    redisTemplate.opsForHash().put(key, hashKey, value);
  }
  /**
   * 功能描述: 往key 里面放置多个值
   *
   * @param key  redis的键值
   * @param maps 字段键值集合
   */
  public void hPut(String key, Map<String, Object> maps) {
    redisTemplate.opsForHash().putAll(key, maps);
  }
  /**
   * 功能描述: 添加字段键值对,使用hPut() 方法
   *
   * @param key    redis的键值
   * @param hKey   字段名
   * @param hValue 字段值
   * @return
   * @deprecated 暂时不再使用
   */
  @Deprecated
  public boolean hSet(String key, Object hKey, Object hValue) {
    try {
      redisTemplate.opsForHash().put(key, hKey, hValue);
      return true;
    } catch (Exception e) {
      log.error("发生异常", e);
      return false;
    }
  }
  /**
   * 功能描述: 批量添加字段键值对，使用hPut() 方法
   *
   * @param key  redis的键值
   * @param maps 字段键值对集合
   * @return
   * @deprecated 暂时不再使用
   */
  @Deprecated
  public boolean hSet(String key, Map<String, ?> maps) {
    try {
      redisTemplate.opsForHash().putAll(key, maps);
      return true;
    } catch (Exception e) {
      log.error("发生异常", e);
      return false;
    }
  }
  /**
   * 功能描述: 仅当hashKey不存在时才设置
   *
   * @param key     redis的键值
   * @param hashKey 字段名
   * @param value   字段名对应的值
   * @return
   */
  public Boolean hPutIfAbsent(String key, String hashKey, Object value) {
    return redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
  }
  /**
   * 功能描述:为哈希表 key 中的指定字段的整数值加上增量 increment
   *
   * @param key       redis的键值
   * @param field     字段名
   * @param increment 步长
   * @return
   */
  public Long hIncrBy(String key, Object field, long increment) {
    return redisTemplate.opsForHash().increment(key, field, increment);
  }
  /**
   * 功能描述:为哈希表 key 中的指定字段的整数值加上增量 increment,浮点数
   *
   * @param key   redis的键值
   * @param field 字段名
   * @param delta 步长，可为浮点数
   * @return
   */
  public Double hIncrByFloat(String key, Object field, double delta) {
    return redisTemplate.opsForHash().increment(key, field, delta);
  }
  /******3.1放置值结束******/
  /******3.2获取值开始******/
  /**
   * 功能描述: 获取单个键值对
   *
   * @param key   redis的键值
   * @param field 字段名
   * @return
   */
  public Object hGet(String key, String field) {
    try {
      return redisTemplate.opsForHash().get(key, field);
    } catch (Exception e) {
      log.error("发生异常", e);
      return null;
    }
  }
  /**
   * 功能描述: 查询指定列的值
   *
   * @param key      redis的键值
   * @param hashKeys 字段名集合
   * @return
   */
  public List hMulGet(String key, Collection hashKeys) {
    List<?> list = redisTemplate.opsForHash().multiGet(key, hashKeys);
    return list.stream().filter(Objects::nonNull).collect(Collectors.toList());
  }
  /**
   * 功能描述: 查询指定列的值
   *
   * @param key      redis的键值
   * @param hashKeys 字段名集合
   * @return
   */
  public List hMulGet(String key, Object[] hashKeys) {
    if (null == hashKeys || hashKeys.length == 0) {
      return new ArrayList();
    }
    List<Object> keyList = Arrays.asList(hashKeys);
    List<?> list = redisTemplate.opsForHash().multiGet(key, keyList);
    return list.stream().filter(Objects::nonNull).collect(Collectors.toList());
  }
  /**
   * 功能描述: 根据大Key获取所有键值对,返回的是一个Object对象,需要强转成Map对象
   *
   * @param key redis的键值
   * @return
   */
  public Object hGet(String key) {
    try {
      return redisTemplate.opsForHash().entries(key);
    } catch (Exception e) {
      log.error("发生异常", e);
      return null;
    }
  }
  /**
   * 功能描述: 获取所有给定字段的值
   *
   * @param key redis的键值
   * @return 返回当前 key对应的所有字段的键值对集合
   */
  public Map<Object, Object> hGetAll(String key) {
    return redisTemplate.opsForHash().entries(key);
  }
  /**
   * 功能描述: 获取所有给定字段的值
   *
   * @param key    redis的键值
   * @param fields 指定的字段集合
   * @return 返回当前 key对应的筛选字段里面的键值对集合
   */
  public List<Object> hMultiGet(String key, Collection<Object> fields) {
    return redisTemplate.opsForHash().multiGet(key, fields);
  }
  /**
   * 功能描述:获取所有哈希表中的字段
   *
   * @param key redis的键值
   * @return
   */
  public Set<Object> hKeys(String key) {
    return redisTemplate.opsForHash().keys(key);
  }
  /**
   * 功能描述: 获取key里面的所有的值，返回map
   *
   * @param key redis键值
   * @return
   */
  public Object getHashValues(String key) {
    return redisTemplate.opsForHash().values(key);
  }
  /**
   * 功能描述: 弹出元素后删除，返回弹出的那个元素
   *
   * @param key   key
   * @param field 属性
   * @param <T>   返回类型
   * @return
   */
  public <T> T hPop(String key, String field) {
    Object result = redisTemplate.opsForHash().get(key, field);
    if (null != result) {
      hDel(key, field);
    }
    return (T) result;
  }
  /**
   * 功能描述: 弹出多个符合条件的元素后删除，返回弹出的那些元素
   *
   * @param key      key
   * @param hashKeys 属性值
   * @return
   */
  public List hMulPop(String key, Collection hashKeys) {
    List results = hMulGet(key, hashKeys);
    if (CollectionUtils.isEmpty(results)) {
      return Collections.emptyList();
    }
    redisTemplate.opsForHash().delete(key, hashKeys.toArray());
    return results;
  }
  /**
   * 功能描述: 获取hash列表中该键的各个属性值
   *
   * @param key key
   * @return
   */
  public Set<String> getHashFields(String key) {
    Object o = redisTemplate.opsForHash().keys(key);
    return (Set<String>) o;
  }
  /******3.2获取值结束******/
  /******3.3 删除操作开始******/
  /**
   * 功能描述: 移除相应的字段名,返回删除的属性的那个值。
   *
   * @param key   redis的键值
   * @param field 字段名
   * @return 返回该字段名所对应的值
   */
  @SuppressWarnings("unchecked")
  public Object hDelete(String key, String field) {
    Object result = redisTemplate.opsForHash().get(key, field);
    if (null != result) {
      hDel(key, field);
      return result;
    }
    return null;
  }
  /**
   * 功能描述: 删除key里面所有的字段集合,返回删除的成功数目。
   *
   * @param key      redis键值
   * @param hashKeys 字段集合
   * @return
   */
  public Long deleteHashKeys(String key, Object[] hashKeys) {
    return redisTemplate.opsForHash().delete(key, hashKeys);
  }
  /**
   * 功能描述: 删除key里面所有的字段集合,返回删除的成功数目。
   *
   * @param key      redis键值
   * @param hashKeys 字段集合
   * @return
   */
  public List deleteHashKeysForList(String key, Object[] hashKeys) {
    List results = hMulGet(key, hashKeys);
    if (CollectionUtils.isEmpty(results)) {
      return Collections.emptyList();
    }
    redisTemplate.opsForHash().delete(key, hashKeys);
    return results;
  }
  /**
   * 功能描述: 移除指定列的值
   *
   * @param key      redis的键值
   * @param hashKeys 字段名集合
   * @return
   */
  public List hDeleteForList(String key, Collection<Object> hashKeys) {
    List results = hMulGet(key, hashKeys);
    if (CollectionUtils.isEmpty(results)) {
      return Collections.emptyList();
    }
    redisTemplate.opsForHash().delete(key, hashKeys.toArray());
    return results;
  }
  /**
   * 功能描述: 删除指定的字段集合,是否全部删除成功。
   *
   * @param key   redis的键值
   * @param field 字段集合
   * @return
   */
  public boolean hDel(String key, Object... field) {
    try {
      redisTemplate.opsForHash().delete(key, field);
      return true;
    } catch (Exception e) {
      log.error("发生异常", e);
      return false;
    }
  }
  /******3.3 删除操作结束******/
  /******3.4其他操作开始******/
  /**
   * 功能描述:查看哈希表 key 中，指定的字段是否存在
   *
   * @param key   redis的键值
   * @param field 字段名
   * @return 查看哈希表 key 中，指定的字段是否存在
   */
  public boolean hExists(String key, String field) {
    return redisTemplate.opsForHash().hasKey(key, field);
  }
  /**
   * 功能描述: 根据大Key获取所有键值对,建议使用 hSize() 方法。
   *
   * @param key redis的键值
   * @return
   * @deprecated 暂时不再使用
   */
  @Deprecated
  public Long hLen(String key) {
    return redisTemplate.opsForHash().size(key);
  }
  /**
   * 功能描述: 根据大Key获取所有键值对
   *
   * @param key redis的键值
   * @return
   */
  public Long hSize(String key) {
    return redisTemplate.opsForHash().size(key);
  }
  /**
   * 功能描述: key里面是否该有字段
   *
   * @param key   redis的键值
   * @param field 字段名
   * @return
   */
  public boolean hasKey(String key, Object field) {
    try {
      return redisTemplate.opsForHash().hasKey(key, field);
    } catch (Exception e) {
      log.error("发生异常", e);
      return false;
    }
  }
  /******3.4其他操作结束******/
  /** ------------------------4.list相关操作---------------------------- */
  /*******4.1 放置值操作开始******/
  /**
   * 功能描述: 左放置
   *
   * @param key   redis键值
   * @param value 要放置的值
   * @return
   */
  public boolean leftPush(String key, Object value) {
    try {
      redisTemplate.opsForList().leftPush(key, value);
      return true;
    } catch (Exception e) {
      log.error("发生异常", e);
      return false;
    }
  }
  /**
   * 功能描述: 左批量放置集合形式
   *
   * @param key  redis键值
   * @param list 要放置的值集合
   * @return
   */
  public boolean leftPushAll(String key, Collection list) {
    try {
      redisTemplate.opsForList().leftPushAll(key, list);
      return true;
    } catch (Exception e) {
      log.error("发生异常", e);
      return false;
    }
  }
  /**
   * 功能描述: 批量放置值，可变参数形式放置
   *
   * @param key   redis的键值
   * @param value 放置的值
   * @return
   */
  public Long lLeftPushAll(String key, Object... value) {
    return redisTemplate.opsForList().leftPushAll(key, value);
  }
  /**
   * 功能描述:当list存在的时候才加入
   *
   * @param key   redis的键值
   * @param value 放置的值
   * @return
   */
  public Long lLeftPushIfPresent(String key, Object value) {
    return redisTemplate.opsForList().leftPushIfPresent(key, value);
  }
  /**
   * 功能描述:如果pivot存在,再pivot前面添加
   *
   * @param key   redis的键值
   * @param pivot 检测的值
   * @param value 要放置的值
   * @return
   */
  public Long lLeftPush(String key, Object pivot, Object value) {
    return redisTemplate.opsForList().leftPush(key, pivot, value);
  }
  /**
   * 功能描述: 右放置
   *
   * @param key   redis键值
   * @param value 要放置的值
   * @return
   */
  public boolean rightPush(String key, Object value) {
    try {
      redisTemplate.opsForList().rightPush(key, value);
      return true;
    } catch (Exception e) {
      log.error("发生异常", e);
      return false;
    }
  }
  public boolean rightPushAll(String key, Collection values) {
    try {
      redisTemplate.opsForList().rightPushAll(key, values);
      return true;
    } catch (Exception e) {
      log.error(e.getMessage(), e);
      return false;
    }
  }
  /**
   * 功能描述: 从右边添加,可变参数形式
   *
   * @param key   redis的键值
   * @param value 添加的值
   * @return
   */
  public Long lRightPushAll(String key, Object... value) {
    return redisTemplate.opsForList().rightPushAll(key, value);
  }
  /**
   * 功能描述: 为已存在的列表添加值，从右添加
   *
   * @param key   redis的键值
   * @param value 添加的值
   * @return
   */
  public Long lRightPushIfPresent(String key, Object value) {
    return redisTemplate.opsForList().rightPushIfPresent(key, value);
  }
  /**
   * 功能描述:在pivot元素的右边添加值
   *
   * @param key   redis的键值
   * @param pivot 检测的值
   * @param value 要放置的值
   * @return
   */
  public Long lRightPush(String key, Object pivot, Object value) {
    return redisTemplate.opsForList().rightPush(key, pivot, value);
  }
  /**
   * 功能描述: 更新指定索引的元素
   *
   * @param key   redis中的键
   * @param index 更新的索引
   * @param value 新值
   * @return
   */
  public boolean update(String key, int index, Object value) {
    try {
      redisTemplate.opsForList().set(key, index, value);
      return true;
    } catch (Exception e) {
      log.error("redisUtil的update异常:", e);
      return false;
    }
  }
  /*******4.1 放置值操作结束******/
  /*******4.2 获取值操作开始******/
  /**
   * 功能描述: 通过索引获取列表中的元素
   *
   * @param key   redis的键值
   * @param index 索引位置
   * @return
   */
  public Object lIndex(String key, long index) {
    return redisTemplate.opsForList().index(key, index);
  }
  /**
   * 功能描述: 获取列表指定范围内的元素
   *
   * @param key   redis的键值
   * @param start 开始位置, 0是开始位置
   * @param end   结束位置, -1返回所有
   * @return
   */
  public List<Object> lRange(String key, long start, long end) {
    return redisTemplate.opsForList().range(key, start, end);
  }
  /**
   * 功能描述: 从左到右全部查询集合中的数据信息
   *
   * @param key redis键值
   * @return
   */
  public Object range(String key) {
    try {
      List<Object> list = redisTemplate.opsForList().range(key, 0, -1);
      if (!org.springframework.util.CollectionUtils.isEmpty(list)) {
        return list;
      }
      return Collections.emptyList();
    } catch (Exception e) {
      log.error(e.getMessage(), e);
      return Collections.emptyList();
    }
  }
  /**
   * 功能描述: 从左边出栈,不删除元素。
   *
   * @param key redis键值
   * @return
   */
  public Object leftPop(String key) {
    try {
      return redisTemplate.opsForList().leftPop(key, 1, TimeUnit.SECONDS);
    } catch (Exception e) {
      log.error("发生异常", e);
      return null;
    }
  }
  /**
   * 功能描述: 从右边出栈，不删除元素。
   *
   * @param key redis键值
   * @return
   */
  public Object rightPop(String key) {
    try {
      return redisTemplate.opsForList().rightPop(key, 1, TimeUnit.SECONDS);
    } catch (Exception e) {
      log.error("发生异常", e);
      return null;
    }
  }
  /*******4.2 获取值操作结束******/
  /*******4.3 删除值操作开始******/
  /**
   * 功能描述:移出并获取列表的第一个元素
   *
   * @param key redis的键值
   * @return 删除的元素
   */
  public Object lLeftPop(String key) {
    return redisTemplate.opsForList().leftPop(key);
  }
  /**
   * 功能描述： 移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
   *
   * @param key      redis的键值
   * @param timeout  等待时间
   * @param timeUnit 时间单位
   * @return
   */
  public Object lBLeftPop(String key, long timeout, TimeUnit timeUnit) {
    return redisTemplate.opsForList().leftPop(key, timeout, timeUnit);
  }
  /**
   * 功能描述：移除并获取列表最后一个元素
   *
   * @param key redis的键值
   * @return 删除的元素
   */
  public Object lRightPop(String key) {
    return redisTemplate.opsForList().rightPop(key);
  }
  /**
   * 功能描述:移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
   *
   * @param key      redis的键值
   * @param timeout  等待时间
   * @param timeUnit 时间单位
   * @return
   */
  public Object lBRightPop(String key, long timeout, TimeUnit timeUnit) {
    return redisTemplate.opsForList().rightPop(key, timeout, timeUnit);
  }
  /**
   * 功能描述：删除集合中值等于value得元素
   *
   * @param key   redis中的键
   * @param index index=0, 删除所有值等于value的元素; index>0, 从头部开始删除第一个值等于value的元素;
   *              index<0, 从尾部开始删除第一个值等于value的元素;
   * @param value 要删除的值
   * @return
   */
  public Long lRem(String key, long index, Object value) {
    return redisTemplate.opsForList().remove(key, index, value);
  }
  /**
   * 功能描述:删除所有等于value 的元素
   *
   * @param key   redis中的键
   * @param value 要删除的值
   * @return
   */
  public long lRem(String key, Object value) {
    try {
      return redisTemplate.opsForList().remove(key, 0, value);
    } catch (Exception e) {
      log.error("发生异常", e);
      return 0;
    }
  }
  /*******4.3 删除值操作结束******/
  /*******4.5 其他操作开始******/
  /**
   * 功能描述:移除列表的最后一个元素，并将该元素添加到另一个列表并返回
   *
   * @param sourceKey      源集合
   * @param destinationKey 目标集合
   * @return
   */
  public Object lRightPopAndLeftPush(String sourceKey, String destinationKey) {
    return redisTemplate.opsForList().rightPopAndLeftPush(sourceKey,
        destinationKey);
  }
  /**
   * 功能描述：从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它；
   * 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
   *
   * @param sourceKey      源集合
   * @param destinationKey 目标集合
   * @param timeout        超时时间
   * @param timeUnit       时间单位
   * @return
   */
  public Object lBRightPopAndLeftPush(String sourceKey, String destinationKey,
                    long timeout, TimeUnit timeUnit) {
    return redisTemplate.opsForList().rightPopAndLeftPush(sourceKey,
        destinationKey, timeout, timeUnit);
  }
  /**
   * 功能描述:裁剪list
   *
   * @param key   redis中的键
   * @param start 开始的索引位置
   * @param end   结束的索引位置
   */
  public void lTrim(String key, long start, long end) {
    redisTemplate.opsForList().trim(key, start, end);
  }
  /**
   * 功能描述: 获取列表长度,建议使用 lSize 方法。
   *
   * @param key redis的键
   * @return
   * @deprecated 暂时不再使用
   */
  @Deprecated
  public Long lLen(String key) {
    return redisTemplate.opsForList().size(key);
  }
  /**
   * 功能描述: 获取列表长度
   *
   * @param key redis的键
   * @return
   */
  public Long lSize(String key) {
    return redisTemplate.opsForList().size(key);
  }
  /*******4.5 其他操作结束******/
  /** --------------------5.set相关操作-------------------------- */
  /*******5.1 添加放置操作开始******/
  /**
   * 功能描述: 批量往Set 里面添加元素，可变 参数形式
   *
   * @param key    redis键值
   * @param values 要放置的值
   * @return
   */
  public boolean sAdd(String key, Object... values) {
    try {
      redisTemplate.opsForSet().add(key, values);
      return true;
    } catch (Exception e) {
      log.error("发生异常", e);
      return false;
    }
  }
  /**
   * 功能描述: 单个往Set 里面添加元素
   *
   * @param key   redis键值
   * @param value 要放置的值
   * @return
   */
  public boolean sAdd(String key, Object value) {
    try {
      redisTemplate.opsForSet().add(key, value);
      return true;
    } catch (Exception e) {
      log.error("发生异常", e);
      return false;
    }
  }
  /*******5.1 添加放置操作结束******/
  /*******5.2 查询操作开始******/
  /**
   * 功能描述：返回里面的所有元素信息
   *
   * @param key redis键值
   * @return
   */
  public Object sMembers(String key) {
    try {
      return redisTemplate.opsForSet().members(key);
    } catch (Exception e) {
      log.error("发生异常", e);
      return null;
    }
  }
  /**
   * 功能描述：获取key里面的所有的元素
   *
   * @param key redis的键值
   */
  public Set<Object> setMembers(String key) {
    return redisTemplate.opsForSet().members(key);
  }
  /**
   * 功能描述：随机获取集合中的一个元素
   *
   * @param key redis的键值
   * @return
   */
  public Object sRandomMember(String key) {
    return redisTemplate.opsForSet().randomMember(key);
  }
  /**
   * 功能描述： 随机获取集合中count个元素，可能有重复的。
   *
   * @param key   redis的键值
   * @param count 数目
   * @return
   */
  public List<Object> sRandomMembers(String key, long count) {
    return redisTemplate.opsForSet().randomMembers(key, count);
  }
  /**
   * 功能描述：随机获取集合中count个元素并且去除重复的，没有重复的。
   *
   * @param key   redis的键
   * @param count 去重后的数目
   * @return
   */
  public Set<Object> sDistinctRandomMembers(String key, long count) {
    return redisTemplate.opsForSet().distinctRandomMembers(key, count);
  }
  /*******5.2 查询操作结束******/
  /*******5.3 删除操作开始******/
  /**
   * 功能描述: 移除集合里面的单个元素
   *
   * @param key   redis键值
   * @param value 要移除的单位元素的值
   * @return
   */
  public long sRem(String key, String value) {
    try {
      return redisTemplate.opsForSet().remove(key, value);
    } catch (Exception e) {
      log.error("发生异常", e);
      return 0;
    }
  }
  /**
   * 功能描述: 批量移除集合里面的元素,是否全部移除成功。
   *
   * @param key     redis键值
   * @param members 要移除的元素的值
   * @return
   */
  public boolean sRem(String key, Object... members) {
    try {
      redisTemplate.opsForSet().remove(key, members);
      return true;
    } catch (Exception e) {
      log.error("发生异常", e);
      return false;
    }
  }
  /**
   * 功能描述：set移除元素
   *
   * @param key    redis键值
   * @param values 要移除的元素
   * @return
   */
  public Long sRemMore(String key, Object... values) {
    return redisTemplate.opsForSet().remove(key, values);
  }
  /*******5.3 删除操作结束******/
  /*******5.4 交并差补操作开始******/
  /**
   * 功能描述:获取两个集合的交集
   *
   * @param key      第一个主集合
   * @param otherKey 第二个集合
   * @return
   */
  public Set<Object> sIntersect(String key, String otherKey) {
    return redisTemplate.opsForSet().intersect(key, otherKey);
  }
  /**
   * 功能描述:key集合与otherKey集合的交集存储到destKey集合中
   *
   * @param key      第一个主集合
   * @param otherKey 第二个集合
   * @param destKey  将结果放置到目标集合里面
   * @return
   */
  public Long sIntersectAndStore(String key, String otherKey, String destKey) {
    return redisTemplate.opsForSet().intersectAndStore(key, otherKey,
        destKey);
  }
  /**
   * 功能描述:获取两个集合的并集
   *
   * @param key       第一个主集合
   * @param otherKeys 第二个集合
   * @return
   */
  public Set<Object> sUnion(String key, String otherKeys) {
    return redisTemplate.opsForSet().union(key, otherKeys);
  }
  /**
   * 功能描述：key集合与otherKey集合的并集存储到destKey中
   *
   * @param key      第一个主集合
   * @param otherKey 第二个集合
   * @param destKey  将结果放置到目标集合里面
   * @return
   */
  public Long sUnionAndStore(String key, String otherKey, String destKey) {
    return redisTemplate.opsForSet().unionAndStore(key, otherKey, destKey);
  }
  /**
   * 功能描述：获取两个集合的差集
   *
   * @param key      第一个主集合
   * @param otherKey 第二个主集合
   * @return
   */
  public Set<Object> sDifference(String key, String otherKey) {
    return redisTemplate.opsForSet().difference(key, otherKey);
  }
  /**
   * 功能描述： key集合与otherKey集合的差集存储到destKey中
   *
   * @param key      第一个主集合
   * @param otherKey 其他集合
   * @param destKey  将结果放置到目标集合里面
   * @return
   */
  public Long sDifference(String key, String otherKey, String destKey) {
    return redisTemplate.opsForSet().differenceAndStore(key, otherKey,
        destKey);
  }
  /*******5.4 交并差补操作结束******/
  /*******5.5 其他操作开始******/
  /**
   * 功能描述：是否是集合里面的元素
   *
   * @param key   redis键值
   * @param value 要检测的对象
   * @return
   */
  public boolean isMembers(String key, Object value) {
    return redisTemplate.opsForSet().isMember(key, value);
  }
  /**
   * 功能描述：返回集合里面的元素数目,推荐使用 sSize方法
   *
   * @param key redis键值
   * @return
   * @deprecated 暂时不再使用
   */
  @Deprecated
  public Long setSize(String key) {
    return redisTemplate.opsForSet().size(key);
  }
  /**
   * 功能描述：返回集合里面的元素数目
   *
   * @param key redis键值
   * @return
   */
  public Long sSize(String key) {
    return redisTemplate.opsForSet().size(key);
  }
  /**
   * 功能描述:将元素value从一个集合移到另一个集合
   *
   * @param key     源集合的key
   * @param value   要移除的值
   * @param destKey 目标集合的key
   * @return
   */
  public Boolean sMove(String key, String value, String destKey) {
    return redisTemplate.opsForSet().move(key, value, destKey);
  }
  /*******5.5 其他操作结束******/
  /**------------------6.zSet相关操作--------------------------------*/
  /*******6.1 添加放置操作开始******/
  /**
   * 功能描述：添加元素,有序集合是按照元素的score值由小到大排列
   *
   * @param key   redis的键
   * @param value 放置的值
   * @param score 成绩
   * @return
   */
  public Boolean zAdd(String key, Object value, double score) {
    return redisTemplate.opsForZSet().add(key, value, score);
  }
  /**
   * 功能描述:增加元素的score值，并返回增加后的值
   *
   * @param key   redis的键
   * @param value 放置的值
   * @param delta 增加成绩
   * @return
   */
  public Double zIncrementScore(String key, String value, double delta) {
    return redisTemplate.opsForZSet().incrementScore(key, value, delta);
  }
  /*******6.1 添加放置操作结束******/
  /*******6.2 查询操作开始******/
  /**
   * 功能描述：返回该元素在集合的排名,有序集合是按照元素的score值由小到大排列. 最小的成绩是0
   *
   * @param key   redis的键
   * @param value 元素
   * @return 0表示第一位
   */
  public Long zRank(String key, Object value) {
    return redisTemplate.opsForZSet().rank(key, value);
  }
  /**
   * 功能描述：返回元素在集合的排名,按元素的score值由大到小排列。 最大的成绩是0
   *
   * @param key   redis的键
   * @param value 要检测的元素
   * @return
   */
  public Long zReverseRank(String key, Object value) {
    return redisTemplate.opsForZSet().reverseRank(key, value);
  }
  /**
   * 功能描述：获取集合的元素, 从小到大排序
   *
   * @param key   redis的键
   * @param start 开始位置
   * @param end   结束位置, -1查询所有
   * @return
   */
  public Set<Object> zRange(String key, long start, long end) {
    return redisTemplate.opsForZSet().range(key, start, end);
  }
  /**
   * 功能描述：获取集合的元素, 从大到小排序
   *
   * @param key   redis的键
   * @param start 开始
   * @param end   结束
   * @return
   */
  public Set<Object> zReverseRange(String key, long start, long end) {
    return redisTemplate.opsForZSet().reverseRange(key, start, end);
  }
  /**
   * 功能描述: 获取集合元素, 并且把score值也获取
   *
   * @param key   redis的键
   * @param start 开始位置
   * @param end   结束位置, -1查询所有
   * @return
   */
  public Set<ZSetOperations.TypedTuple<Object>> zRangeWithScores(String key, long start,
                                   long end) {
    return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
  }
  /**
   * 功能描述: 根据Score值查询集合元素，从小到大排序。不带成绩
   *
   * @param key redis的键
   * @param min 成绩最小值
   * @param max 成绩最大值
   * @return
   */
  public Set<Object> zRangeByScore(String key, double min, double max) {
    return redisTemplate.opsForZSet().rangeByScore(key, min, max);
  }
  /**
   * 功能描述:根据Score值查询集合元素, 从小到大排序，带成绩。
   *
   * @param key redis的键
   * @param min 最小值
   * @param max 最大值
   * @return
   */
  public Set<ZSetOperations.TypedTuple<Object>> zRangeByScoreWithScores(String key,
                                      double min, double max) {
    return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);
  }
  /**
   * 功能描述:根据Score值查询集合元素, 范围性查询，从小到大排序
   *
   * @param key   redis的键
   * @param min   成绩最小值
   * @param max   成绩最大值
   * @param start 位置开始
   * @param end   位置结束，-1表示查询全部。
   * @return
   */
  public Set<ZSetOperations.TypedTuple<Object>> zRangeByScoreWithScores(String key,
                                      double min, double max, long start, long end) {
    return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max,
        start, end);
  }
  /**
   * 功能描述：获取集合的元素, 从大到小排序, 并返回score值
   *
   * @param key   redis的键
   * @param start 开始
   * @param end   结束
   * @return
   */
  public Set<ZSetOperations.TypedTuple<Object>> zReverseRangeWithScores(String key,
                                      long start, long end) {
    return redisTemplate.opsForZSet().reverseRangeWithScores(key, start,
        end);
  }
  /**
   * 功能描述：根据Score值查询集合元素, 从大到小排序，没有成绩。
   *
   * @param key redis的键
   * @param min 最小成绩
   * @param max 最大成绩
   * @return
   */
  public Set<Object> zReverseRangeByScore(String key, double min,
                      double max) {
    return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max);
  }
  /**
   * 功能描述：根据Score值查询集合元素, 从大到小排序
   *
   * @param key redis的键
   * @param min 最小成绩
   * @param max 最大成绩
   * @return
   */
  public Set<ZSetOperations.TypedTuple<Object>> zReverseRangeByScoreWithScores(
      String key, double min, double max) {
    return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key,
        min, max);
  }
  /**
   * 功能描述：根据Score值查询集合元素, 从大到小排序，范围性排序
   *
   * @param key   redis的键
   * @param min   最小成绩
   * @param max   最大成绩
   * @param start 位置开始
   * @param end   位置结束，-1表示查询全部。
   * @return
   */
  public Set<Object> zReverseRangeByScore(String key, double min,
                      double max, long start, long end) {
    return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max,
        start, end);
  }
  /**
   * 功能描述：获取集合中value元素的score值
   *
   * @param key   redis的键
   * @param value 值
   * @return
   */
  public Double zScore(String key, Object value) {
    return redisTemplate.opsForZSet().score(key, value);
  }
  /*******6.2 查询操作结束******/
  /*******6.3 删除操作开始******/
  /**
   * 功能描述: 移除集合里面的元素
   *
   * @param key    redis的键
   * @param values 移除 的元素集合
   * @return
   */
  public Long zRemove(String key, Object... values) {
    return redisTemplate.opsForZSet().remove(key, values);
  }
  /**
   * 功能描述： 移除指定索引位置的成员
   *
   * @param key   redis的键
   * @param start 位置开始
   * @param end   位置结束，-1表示查询全部。
   * @return
   */
  public Long zRemoveRange(String key, long start, long end) {
    return redisTemplate.opsForZSet().removeRange(key, start, end);
  }
  /**
   * 功能描述： 根据指定的score值的范围来移除成员
   *
   * @param key redis的键
   * @param min 最小成绩
   * @param max 最大成绩
   * @return
   */
  public Long zRemoveRangeByScore(String key, double min, double max) {
    return redisTemplate.opsForZSet().removeRangeByScore(key, min, max);
  }
  /*******6.3 删除操作结束******/
  /*******6.4 交并差补操作开始******/
  /**
   * 功能描述：获取key和otherKey的并集并存储在destKey中
   *
   * @param key      第一个主集合
   * @param otherKey 第二个的集合
   * @param destKey  目标集合
   * @return
   */
  public Long zUnionAndStore(String key, String otherKey, String destKey) {
    return redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey);
  }
  /**
   * 功能描述: 获取key和其他的并集，并存储在destKey中
   *
   * @param key       第一个主集合
   * @param otherKeys 其他的集合
   * @param destKey   目标集合
   * @return
   */
  public Long zUnionAndStore(String key, Collection<String> otherKeys,
                 String destKey) {
    return redisTemplate.opsForZSet()
        .unionAndStore(key, otherKeys, destKey);
  }
  /**
   * 功能描述：获取key和otherKey的交集并存储在destKey中
   *
   * @param key      第一个主集合
   * @param otherKey 第二个的集合
   * @param destKey  目标集合
   * @return
   */
  public Long zIntersectAndStore(String key, String otherKey,
                   String destKey) {
    return redisTemplate.opsForZSet().intersectAndStore(key, otherKey,
        destKey);
  }
  /**
   * 功能描述: 获取key和其他的交集，并存储在destKey中
   *
   * @param key       第一个主集合
   * @param otherKeys 其他的集合
   * @param destKey   目标集合
   * @return
   */
  public Long zIntersectAndStore(String key, Collection<String> otherKeys,
                   String destKey) {
    return redisTemplate.opsForZSet().intersectAndStore(key, otherKeys,
        destKey);
  }
  /*******6.4 交并差补操作结束******/
  /*******6.5 其他操作开始******/
  /**
   * 功能描述：统计score值范围内集合元素数量
   *
   * @param key redis的键
   * @param min 最小成绩
   * @param max 最大成绩
   * @return
   */
  public Long zCount(String key, double min, double max) {
    return redisTemplate.opsForZSet().count(key, min, max);
  }
  /**
   * 功能描述： 获取集合的元素数量
   *
   * @param key redis的键
   * @return
   */
  public Long zZCard(String key) {
    return redisTemplate.opsForZSet().zCard(key);
  }
  /*******6.5 其他操作结束******/
}

接下来，我们做一个 Redis操作的一个具体的实例。

文章标签：
云数据库 Tair（兼容 Redis）
Java
NoSQL
Windows
Redis
mybatis
数据库
数据库连接
关键词：
springboot云数据库 Tair（兼容 Redis）
云数据库 Tair（兼容 Redis）Springboot
springboot Redis
spring boot整合redis
springboot整合Redis
相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务，基于高可靠双机热备架构及可无缝扩展的集群架构，满足高读写性能场景及容量需弹性变配的业务需求。 产品详情：https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验：数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引，您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接，领取免费ECS&amp;RDS资源，30分钟完成数据库上云实战！https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
两个蝴蝶飞
目录
相关文章
蓝易云
|
1月前
|
NoSQL Java API
springboot项目Redis统计在线用户
通过本文的介绍，您可以在Spring Boot项目中使用Redis实现在线用户统计。通过合理配置Redis和实现用户登录、注销及统计逻辑，您可以高效地管理在线用户。希望本文的详细解释和代码示例能帮助您在实际项目中成功应用这一技术。
蓝易云
37 4
蓝易云
|
1月前
|
消息中间件 NoSQL Java
Spring Boot整合Redis
通过Spring Boot整合Redis，可以显著提升应用的性能和响应速度。在本文中，我们详细介绍了如何配置和使用Redis，包括基本的CRUD操作和具有过期时间的值设置方法。希望本文能帮助你在实际项目中高效地整合和使用Redis。
蓝易云
53 2
nanshaws
|
2月前
|
NoSQL Java Redis
redis的基本命令，并用netty操作redis（不使用springboot或者spring框架）就单纯的用netty搞。
这篇文章介绍了Redis的基本命令，并展示了如何使用Netty框架直接与Redis服务器进行通信，包括设置Netty客户端、编写处理程序以及初始化Channel的完整示例代码。
nanshaws
67 1
redis的基本命令，并用netty操作redis（不使用springboot或者spring框架）就单纯的用netty搞。
nanshaws
|
2月前
|
缓存 NoSQL Java
springboot的缓存和redis缓存，入门级别教程
本文介绍了Spring Boot中的缓存机制，包括使用默认的JVM缓存和集成Redis缓存，以及如何配置和使用缓存来提高应用程序性能。
nanshaws
127 1
springboot的缓存和redis缓存，入门级别教程
东方睿赢
|
2月前
|
缓存 NoSQL Java
Spring Boot与Redis：整合与实战
【10月更文挑战第15天】本文介绍了如何在Spring Boot项目中整合Redis，通过一个电商商品推荐系统的案例，详细展示了从添加依赖、配置连接信息到创建配置类的具体步骤。实战部分演示了如何利用Redis缓存提高系统响应速度，减少数据库访问压力，从而提升用户体验。
东方睿赢
123 2
明弟有理想
|
2月前
|
JSON NoSQL Java
springBoot:jwt&redis&文件操作&常见请求错误代码&参数注解 (九)
该文档涵盖JWT（JSON Web Token）的组成、依赖、工具类创建及拦截器配置，并介绍了Redis的依赖配置与文件操作相关功能，包括文件上传、下载、删除及批量删除的方法。同时，文档还列举了常见的HTTP请求错误代码及其含义，并详细解释了@RequestParam与@PathVariable等参数注解的区别与用法。
明弟有理想
31 2
java冯坚持
|
2月前
|
NoSQL Java Redis
shiro学习四：使用springboot整合shiro，正常的企业级后端开发shiro认证鉴权流程。使用redis做token的过滤。md5做密码的加密。
这篇文章介绍了如何使用Spring Boot整合Apache Shiro框架进行后端开发，包括认证和授权流程，并使用Redis存储Token以及MD5加密用户密码。
java冯坚持
39 0
shiro学习四：使用springboot整合shiro，正常的企业级后端开发shiro认证鉴权流程。使用redis做token的过滤。md5做密码的加密。
刘大猫.
|
1月前
|
JavaScript NoSQL Java
CC-ADMIN后台简介一个基于 Spring Boot 2.1.3 、SpringBootMybatis plus、JWT、Shiro、Redis、Vue quasar 的前后端分离的后台管理系统
CC-ADMIN后台简介一个基于 Spring Boot 2.1.3 、SpringBootMybatis plus、JWT、Shiro、Redis、Vue quasar 的前后端分离的后台管理系统
刘大猫.
45 0
蓝易云
|
2月前
|
缓存 NoSQL Java
Springboot自定义注解+aop实现redis自动清除缓存功能
通过上述步骤，我们不仅实现了一个高度灵活的缓存管理机制，还保证了代码的整洁与可维护性。自定义注解与AOP的结合，让缓存清除逻辑与业务逻辑分离，便于未来的扩展和修改。这种设计模式非常适合需要频繁更新缓存的应用场景，大大提高了开发效率和系统的响应速度。
蓝易云
83 2
蓝易云
|
2月前
|
存储 NoSQL Java
Spring Boot项目中使用Redis实现接口幂等性的方案
通过上述方法，可以有效地在Spring Boot项目中利用Redis实现接口幂等性，既保证了接口操作的安全性，又提高了系统的可靠性。
蓝易云
56 0

热门文章

最新文章

  • 1
    Spring-boot+Dubbo应用启停源码分析
  • 2
    SpringMvc+Spring+MyBatis 基于注解整合
  • 3
    Spring(二)之入门示例
  • 4
    spring入门
  • 5
    spring 拦截器
  • 6
    Reactive Spring实战——响应式MySql交互
  • 7
    Dubbo之——改造Dubbo，使其能够兼容Spring 4注解配置
  • 8
    Spring Cloud 统一配置
  • 9
    [Spring]支持注解的Spring调度器
  • 10
    Spring Aware容器感知技术
  • 1
    Redis经典问题：数据并发竞争
    502
  • 2
    Redis经典问题：数据不一致
    624
  • 3
    Redis经典问题：缓存击穿
    644
  • 4
    Redis数据结构精讲：选择与应用实战指南
    1333
  • 5
    Redis内存分析工具RDR
    1770
  • 6
    Redis基础命令集详解
    58
  • 7
    Mac上轻松几步搞定Docker与Redis安装：从下载安装到容器运行实测全程指南
    967
  • 8
    Redis哨兵&分片集群
    97
  • 9
    Redis多级缓存
    58
  • 10
    Redis持久化&Redis主从
    52

    • 相关课程

    更多
  • 大数据实战项目：反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第一阶段
  • 大数据实战项目：反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第三阶段
  • 大数据实战项目 - 反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第六阶段
  • Redis入门实战演练
  • 云数据库 Redis 版使用教程
  • Redis数据库入门

    • 相关电子书

    更多
  • Redis在唯品会的应用实践——架构演进与功能定制
  • 微博的Redis定制之路
  • 云数据库Redis版的开源之路

    • 相关实验场景

    更多
  • Spring-cloud-stream-binder-rocketmq入门与实践
  • Rocketmq-spring入门与实践
  • 如何通过数据库Redis内网访问
  • Tair for Redis数据闪回：任意时间点数据恢复
  • 如何开通Redis的专属集群
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    阿里云oss存储简介和如何使用