java

    SpringBoot 操作 Redis 详解

    系统环境：

    • Redis 版本：5.0.7
    • SpringBoot 版本：2.2.2.RELEASE

    参考地址：

    一、Redis 介绍

    1、什么是 Redis

    Redis 是一个高性能的 Key-Value 数据库，它是完全开源免费的，而且 Redis 是一个 NoSQL 类型数据库，是为了解决 高并发、高扩展，大数据存储 等一系列的问题而产生的数据库解决方案，是一个非关系型的数据库。但是，它也是不能替代关系型数据库，只能作为特定环境下的扩充。

    2、redis的优势和特点

    • redis 数据读写速度非常快，因为它把数据都读取到内存当中操作，而且 redis 是用 C 语言编写的，是最“接近“”操作系统的语言，所以执行速度相对较快。
    • redis 虽然数据的读取都存在内存当中，但是最终它是支持数据持久化到磁盘当中。
    • redis 提供了丰富的数据结构。
    • redis 的所有操作都是原子性，支持事务，所谓的原子性就是对数据的更改要么全部执行，要么全部不执行。
    • redis 支持主从复制，主机会自动将数据同步到从机，可以进行读写分离。

    3、Redis 支持的数据结构类型包括：

    集合（set）：

    set 是 string 类型的无序集合，不同于 list，set 中的元素不可以重复。

    哈希表（hash）：

    hash 类似于 java 中的 map，是一个键值对集合，在 redis 中可以用来存储对象。

    列表（list）：

    list 是一个链表结构，主要功能是 push、pop 获取一个范围的所有值等等。操作中 key 理解为链表的名字。

    有序集合（zset）：

    zset 和 set 一样，也是 string 类型的元素的集合，不同的是ZSET中的每个元素都会关联一个 double 类型的分数，zset 中的成员都是唯一的，但是所关联的分数可以重复。

    字符串（string）：

    string 是 redis 中最基本的数据类型，redis 中的 string 类型是二进制安全的，即它可以包含任何数据，比如一个序列化的对象甚至一个图片（注意的是 redis 中的字符串大小上限是 512M）。

    4、Redis 的应用场景

    • 排行榜
    • 计数器
    • 限速器
    • 分布式锁
    • 分布式会话
    • 热点数据缓存

    5、Redis 与其它 Key-Value 的区别

    • Redis 支持数据的备份，即 master - slave 模式的数据备份。
    • Redis 支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
    • Redis 不仅仅支持简单的 key - value 类型的数据，同时还提供 list、set、zset、hash 等数据结构的存储。

    二、SpringBoot 操作 Redis

    1、Maven 引入相关依赖

    引入 SpringBoot 和 Redis 依赖，由于 SpringBoot 2.x + 版本后是用 lettuce 作为连接池，所以需要引入 commons-pool2 依赖。

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    

        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.4.RELEASE</version>
        </parent>
    

        <groupId>mydlq.club</groupId>
        <artifactId>springboot-redis-example</artifactId>
        <version>0.0.1</version>
        <name>springboot-redis-example</name>
        <description>Demo project for Spring Boot Redis</description>
    

        <properties>
            <java.version>1.8</java.version>
        </properties>
    

        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-pool2</artifactId>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
        </dependencies>
    

        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    

    </project>

    2、配置文件中添加相关参数

    Redis 有多重部署方式，所以连接 Redis 又有多种方式，下面介绍下如何配置 单机、哨兵、集群 的连接参数，需要将这些参数配置到 SpringBoot 的 application 配置文件中。

    • Redis 单机配置：
    spring:
      redis:
        database: 0             #数据库
        ssl: false              #是否开启ssl
        timeout: 1000           #超时时间，单位为毫秒
        host: 127.0.0.1         #Reids主机地址
        port: 6379              #Redis端口号
        lettuce:                #使用 lettuce 连接池
          pool:
            max-active: 20      #连接池最大连接数（使用负值表示没有限制）
            max-wait: -1        #连接池最大阻塞等待时间（使用负值表示没有限制）
            min-idle: 0         #连接池中的最大空闲连接
            max-idle: 10        #连接池中的最小空闲连接
    • Redis 哨兵配置：
    spring:
      redis:
        sentinel:                 #哨兵配置
          master: my-master       #Redis服务器名称
          nodes:                  #Redis哨兵地址
            - 192.168.2.11:6379
            - 192.168.2.12:6379
            - 192.168.2.13:6379
        database: 0               #Redis 索引（0~15，默认为0）
        timeout: 1000             #Redis 连接的超时时间
        password: 123456          #Redis 密码，如果没有就默认不配置此参数
        lettuce:                  #使用 lettuce 连接池
          pool:
            max-active: 20        #连接池最大连接数（使用负值表示没有限制）
            max-wait: -1          #连接池最大阻塞等待时间（使用负值表示没有限制）
            min-idle: 0           #连接池中的最大空闲连接
            max-idle: 10          #连接池中的最小空闲连接
    • Redis 集群配置：
    spring:
      redis:
        database: 0               #Redis 索引（0~15，默认为0）
        timeout: 1000             #Redis 连接的超时时间
        password: 123456          #Redis 密码，如果没有就默认不配置此参数
        cluster:                  #Redis 集群配置
          max-redirects: 5        #Redis 命令执行时最多转发次数
          nodes:                  #Redis 集群地址
            - 192.168.2.11:6379
            - 192.168.2.12:6379
            - 192.168.2.13:6379
            - 192.168.2.11:6380
            - 192.168.2.12:6380
            - 192.168.2.13:6380
        lettuce:                  #使用 lettuce 连接池
          pool:
            max-active: 20        #连接池最大连接数（使用负值表示没有限制）
            max-wait: -1          #连接池最大阻塞等待时间（使用负值表示没有限制）
            min-idle: 0           #连接池中的最大空闲连接
            max-idle: 10          #连接池中的最小空闲连接

    3、配置 RedisTemplate 中序列化参数

    在 RedisTemplate 默认是使用的 Java 字符串序列化，该序列化存入 Redis 并不能够提供可读性，比较流行的做法是替换成 Jackson 序列化，以 JSON 方式进行存储。

    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.*;
    

    /**
     * Redis 配置
     *
     * @author mydlq
     */
    @Configuration
    public class RedisConfig {
    

        /**
         * Redis 序列化配置
         */
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(connectionFactory);
            // 使用GenericJackson2JsonRedisSerializer替换默认序列化
            GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
            // 设置 Key 和 Value 的序列化规则
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
            // 初始化 RedisTemplate 序列化完成
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
    

    }

    4、使用 RedisTemplate 操作 Redis

    (1)、Redis 基本操作

    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.connection.DataType;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Service;
    import java.util.Arrays;
    import java.util.concurrent.TimeUnit;
    

    @Slf4j
    @Service
    public class RedisBase {
    

        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    

        /**
         * 指定 key 的过期时间
         *
         * @param key  键
         * @param time 时间(秒)
         */
        public void expire(String key, long time) {
            redisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
    

        /**
         * 根据 key 获取过期时间（-1 即为永不过期）
         *
         * @param key 键
         * @return 过期时间
         */
        public Long ttl(String key) {
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
    

    

        /**
         * 判断 key 是否存在
         *
         * @param key 键
         * @return 如果存在 key 则返回 true，否则返回 false
         */
        public Boolean exists(String key) {
            return redisTemplate.hasKey(key);
        }
    

        /**
         * 删除 key
         *
         * @param key 键
         */
        public Long del(String... key) {
            if (key == null || key.length < 1) {
                return 0L;
            }
            return redisTemplate.delete(Arrays.asList(key));
        }
    

        /**
         * 获取 Key 的类型
         *
         * @param key 键
         */
        public String type(String key) {
            DataType dataType = redisTemplate.type(key);
            assert dataType != null;
            return dataType.code();
        }
    

    }

    (2)、Redis 批量操作

    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Service;
    import java.util.List;
    import java.util.Map;
    

    @Slf4j
    @Service
    public class RedisBatch {
    

        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    

        /**
         * 批量设置值
         *
         * @param map 要插入的 key value 集合
         */
        public void barchSet(Map<String, Object> map) {
            redisTemplate.opsForValue().multiSet(map);
        }
    

        /**
         * 批量获取值
         *
         * @param list 查询的 Key 列表
         * @return value 列表
         */
        public List<Object> batchGet(List<String> list) {
            return redisTemplate.opsForValue().multiGet(list);
        }
    

    }

    (3)、Redis 字符串操作

    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Service;
    import java.util.Collection;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.TimeUnit;
    

    @Slf4j
    @Service
    public class RedisString {
    

        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    

        /**
         * 获取指定 key 的值
         *
         * @param key 键
         * @return 返回 key 的值
         */
        public Object get(String key) {
            return redisTemplate.opsForValue().get(key);
        }
    

        /**
         * 获取所有一个或多个给定 key 的值
         *
         * @param list Key 集合
         * @return 值集合
         */
        public List<Object> mGet(Collection<String> list) {
            return redisTemplate.opsForValue().multiGet(list);
        }
    

        /**
         * 设置给定 key 的值（如果 key 已经存在就覆写旧值）
         *
         * @param key   键
         * @param value 值
         */
        public void set(String key, Object value) {
            redisTemplate.opsForValue().set(key, value);
        }
    

        /**
         * 同时设置一个或多个 key-value 对
         *
         * @param map 键值集合
         */
        public void set(Map<String, Object> map) {
            redisTemplate.opsForValue().multiSet(map);
        }
    

        /**
         * 设置给定 key 的值，并设置过期时间
         *
         * @param key   键
         * @param value 值
         * @param time  过期时间(秒)
         */
        public void set(String key, Object value, long time) {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
        }
    

        /**
         * 递增
         *
         * @param key   键
         * @param delta 要增加几(大于0)
         * @return 递增后的值
         */
        public Long incr(String key, long delta) {
            if (delta > 0) {
                throw new IllegalArgumentException("递减因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, delta);
        }
    

        /**
         * 递减
         *
         * @param key   键
         * @param delta 要减少几(小于0)
         * @return 递减后的值
         */
        public Long decr(String key, long delta) {
            if (delta < 0) {
                throw new IllegalArgumentException("递减因子必须小于0");
            }
            return redisTemplate.opsForValue().increment(key, -delta);
        }
    

    }

    (4)、Redis 哈希操作

    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Service;
    import java.util.Map;
    

    @Slf4j
    @Service
    public class RedisHash {
    

        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    

        @Autowired
        private RedisBase redisBase;
    

        /**
         * 获取存储在哈希表中指定字段的值
         *
         * @param key  键
         * @param item 项
         * @return 值
         */
        public Object hGet(String key, String item) {
            return redisTemplate.opsForHash().get(key, item);
        }
    

        /**
         * 将哈希表 key 中的字段 field 的值设为 value（如果不存在将创建）
         *
         * @param key   键
         * @param item  项
         * @param value 值
         */
        public void hSet(String key, String item, Object value) {
            redisTemplate.opsForHash().put(key, item, value);
        }
    

        /**
         * 将哈希表 key 中的字段 field 的值设为 value，并设置过期时间
         * （如果不存在将创建，且如果已存在的hash表有时间,这里将会替换原有的时间）
         *
         * @param key   键
         * @param item  项
         * @param value 值
         * @param time  时间（秒）
         */
        public void hSet(String key, String item, Object value, long time) {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                redisBase.expire(key, time);
            }
        }
    

        /**
         * 获取所有给定字段的值
         *
         * @param key 键
         * @return 一个包含多个给定字段关联值的表，表值的排列顺序和指定字段的请求顺序一样
         */
        public Map<Object, Object> hmGet(String key) {
            return redisTemplate.opsForHash().entries(key);
        }
    

        /**
         * 同时将多个“域-值”对设置到哈希表 key 中
         *
         * @param key 键
         * @param map 对应多个键值
         */
        public void hmSet(String key, Map<String, Object> map) {
            redisTemplate.opsForHash().putAll(key, map);
        }
    

        /**
         * 同时将多个“域-值”对设置到哈希表 key 中，并设置过期时间
         *
         * @param key  键
         * @param map  对应多个键值
         * @param time 时间（秒）
         */
        public void hmSet(String key, Map<String, Object> map, long time) {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                redisBase.expire(key, time);
            }
        }
    

        /**
         * 删除一个或多个哈希表字段
         *
         * @param key  键
         * @param item 项（可以使多个）
         * @return 成功删除字段的数量
         */
        public Long hDel(String key, Object... item) {
            return redisTemplate.opsForHash().delete(key, item);
        }
    

        /**
         * 查看哈希表 key 中，指定的字段是否存在
         *
         * @param key  键 不能为null
         * @param item 项 不能为null
         * @return 如果存在则返回 true，不存在则返回 false
         */
        public Boolean hExists(String key, String item) {
            return redisTemplate.opsForHash().hasKey(key, item);
        }
    

        /**
         * 哈希证书递增或递减数（正数递增、负数递减），如果不存在,就会创建一个，并把新增后的值返回
         *
         * @param key  键
         * @param item 项
         * @param by   增加或减少的数
         * @return 执行操作后，哈希表中字段的值
         */
        public Double hIncrby(String key, String item, double by) {
            return redisTemplate.opsForHash().increment(key, item, by);
        }
    

    }

    (5)、Redis 列表操作

    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Service;
    import java.util.List;
    

    @Slf4j
    @Service
    public class RedisList {
    

        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    

        @Autowired
        private RedisBase redisBase;
    

        /**
         * 获取列表指定范围内的元素，正数则表示正向查找，负数则倒叙查找
         *
         * @param key   键
         * @param start 开始
         * @param end   结束
         * @return boolean
         * @see <a href="https://redis.io/commands/lrange">Redis Documentation: LRANGE</a>
         */
        public List<Object> lRange(String key, long start, long end) {
            return redisTemplate.opsForList().range(key, start, end);
        }
    

        /**
         * 获取列表长度
         *
         * @param key 键
         * @return 列表长度
         */
        public Long lLen(String key) {
            return redisTemplate.opsForList().size(key);
        }
    

        /**
         * 通过索引获取列表中的元素
         *
         * @param key   键
         * @param index 索引（index>=0时，0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推）
         * @return 列表中的元素
         */
        public Object lIndex(String key, long index) {
            return redisTemplate.opsForList().index(key, index);
        }
    

        /**
         * 在列表前端添加一个值
         *
         * @param key   键
         * @param value 值
         * @return 返回列表当前长度
         */
        public Long lPush(String key, Object value) {
            return redisTemplate.opsForList().rightPush(key, value);
        }
    

        /**
         * 在列表前端添加一个值，并设置过期时间
         *
         * @param key   键
         * @param value 值
         * @param time  时间（秒）
         * @return 返回列表当前长度
         */
        public Long lPush(String key, Object value, long time) {
            Long size = redisTemplate.opsForList().leftPush(key, value);
            if (time > 0) {
                redisBase.expire(key, time);
            }
            return size;
        }
    

        /**
         * 在列表前端添加多个值
         *
         * @param key   键
         * @param value 值
         * @return 返回列表当前长度
         */
        public Long lPush(String key, List<Object> value) {
            return redisTemplate.opsForList().leftPushAll(key, value);
        }
    

        /**
         * 在列表前端添加多个值，并设置过期时间
         *
         * @param key   键
         * @param value 值
         * @param time  时间（秒）
         * @return 返回列表当前长度
         */
        public Long lPush(String key, List<Object> value, long time) {
            Long size = redisTemplate.opsForList().leftPushAll(key, value);
            if (time > 0) {
                redisBase.expire(key, time);
            }
            return size;
        }
    

        /**
         * 在列末尾端添加一个值
         *
         * @param key   键
         * @param value 值
         * @return 返回列表当前长度
         */
        public Long rPush(String key, Object value) {
            return redisTemplate.opsForList().rightPush(key, value);
        }
    

        /**
         * 在列表末尾添加一个值，并设置过期时间
         *
         * @param key   键
         * @param value 值
         * @param time  时间（秒）
         * @return 返回列表当前长度
         */
        public Long rPush(String key, Object value, long time) {
            Long size = redisTemplate.opsForList().leftPush(key, value);
            if (time > 0) {
                redisBase.expire(key, time);
            }
            return size;
        }
    

        /**
         * 在列表末尾添加多个值
         *
         * @param key   键
         * @param value 值
         * @return 返回列表当前长度
         */
        public Long rPush(String key, List<Object> value) {
            return redisTemplate.opsForList().rightPushAll(key, value);
        }
    

        /**
         * 在列表末尾添加多个值，并设置过期时间
         *
         * @param key   键
         * @param value 值
         * @param time  时间（秒）
         * @return 返回列表当前长度
         */
        public Long rPush(String key, List<Object> value, long time) {
            Long size = redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                redisBase.expire(key, time);
            }
            return size;
        }
    

        /**
         * 通过索引设置列表元素的值
         *
         * @param key   键
         * @param index 索引
         * @param value 值
         */
        public void lSet(String key, long index, Object value) {
            redisTemplate.opsForList().set(key, index, value);
        }
    

        /**
         * 移除列表元素
         *
         * @param key   键
         * @param count 移除数量（"负数"则从列表倒叙查找删除 count 个对应的值; "整数"则从列表正序查找删除 count 个对应的值;）
         * @param value 值
         * @return 成功移除的个数
         */
        public Long lRem(String key, long count, Object value) {
            return redisTemplate.opsForList().remove(key, count, value);
        }
    

    }

    (6)、Redis 集合操作

    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Service;
    import java.util.Set;
    

    @Slf4j
    @Service
    public class RedisSet {
    

        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    

        @Autowired
        private RedisBase redisBase;
    

        /**
         * 返回集合中的所有成员
         *
         * @param key 键
         * @return 集合中的所有成员
         */
        public Set<Object> sMembers(String key) {
            return redisTemplate.opsForSet().members(key);
        }
    

        /**
         * 判断 member 元素是否是集合 key 的成员
         *
         * @param key   键
         * @param value 值
         * @return 如果存在则返回 true 否则返回 false
         */
        public Boolean sisMember(String key, Object value) {
            return redisTemplate.opsForSet().isMember(key, value);
        }
    

        /**
         * 向集合添加一个或多个成员
         *
         * @param key    键
         * @param values 值
         * @return 添加成功元素的个数
         */
        public Long sAdd(String key, Object... values) {
            return redisTemplate.opsForSet().add(key, values);
        }
    

        /**
         * 向集合添加一个或多个成员，并设置过期时间
         *
         * @param key    键
         * @param time   时间（秒）
         * @param values 值（可以是多个）
         * @return 添加成功元素的个数
         */
        public Long sAdd(String key, long time, Object... values) {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0) {
                redisBase.expire(key, time);
            }
            return count;
        }
    

        /**
         * 获取集合的成员数
         *
         * @param key 键
         * @return 返回集合中元素的数量
         */
        public Long sCard(String key) {
            return redisTemplate.opsForSet().size(key);
        }
    

        /**
         * 移除集合中一个或多个成员
         *
         * @param key    键
         * @param values 值 可以是多个
         * @return 移除的个数
         */
        public Long sRem(String key, Object... values) {
            return redisTemplate.opsForSet().remove(key, values);
        }
    

    }

    (7)、Redis 有序集合操作

    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.ZSetOperations;
    import org.springframework.stereotype.Service;
    import java.util.Set;
    

    @Slf4j
    @Service
    public class RedisSortSet {
    

        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    

        /**
         * 向有序集合添加成员
         *
         * @param key   键
         * @param value 值
         * @param score 分数
         * @return 添加成功元素的个数
         */
        public Boolean zAdd(String key, Object value, double score) {
            return redisTemplate.opsForZSet().add(key, value, score);
        }
    

        /**
         * 向有序集合添加多个成员
         *
         * @param key 键
         * @param set 值
         * @return 添加成功元素的个数
         */
        public Long zAdd(String key, Set<ZSetOperations.TypedTuple<Object>> set) {
            return redisTemplate.opsForZSet().add(key, set);
        }
    

        /**
         * 移除有序集合中的一个或多个成员
         *
         * @param key    键
         * @param values 值
         */
        public Long zRem(String key, Object... values) {
            return redisTemplate.opsForZSet().remove(key, values);
        }
    

        /**
         * 有序集合操作分数的加/减
         *
         * @param key   键
         * @param value 值
         * @param score 分数
         * @return 成员的新分数值
         */
        public Double zincrby(String key, String value, double score) {
            return redisTemplate.opsForZSet().incrementScore(key, value, score);
        }
    

        /**
         * 返回有序集中，成员的分数值
         *
         * @param key   键
         * @param value 值
         * @return 成员的分数值
         */
        public Double zScore(String key, String value) {
            return redisTemplate.opsForZSet().score(key, value);
        }
    

        /**
         * 返回有序集合中指定成员的索引
         *
         * @param key   键
         * @param value 值
         * @return 成员的索引
         */
        public Long zRank(String key, String value) {
            return redisTemplate.opsForZSet().rank(key, value);
        }
    

        /**
         * 获取有序集合的成员数（集合长度）
         *
         * @param key 键
         * @return 成员总数
         */
        public Long zCard(String key) {
            return redisTemplate.opsForZSet().zCard(key);
        }
    

        /**
         * 通过索引区间返回有序集合指定区间内的成员（按分数从小到大排序）
         *
         * @param key   键
         * @param start 开始数（0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推）
         * @param end   结束数（-1 表示最后一个成员，-2 表示倒数第二个成员，以此类推）
         * @return 指定区间内，带有分数值(可选)的有序集成员的列表
         */
        public Set<Object> zrange(String key, int start, int end) {
            return redisTemplate.opsForZSet().range(key, start, end);
        }
    

        /**
         * 通过索引区间返回有序集合指定区间内的成员 & 分数
         *
         * @param key   键
         * @param start 开始数（0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推）
         * @param end   结束数（-1 表示最后一个成员，-2 表示倒数第二个成员，以此类推）
         * @return 指定区间内，带有分数值(可选)的有序集成员的列表
         */
        public Set<ZSetOperations.TypedTuple<Object>> zRange(String key, int start, int end) {
            return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
        }
    

        /**
         * 返回有序集中指定区间内的成员，通过索引，分数从高到低
         *
         * @param key   键
         * @param start 开始
         * @param end   结束
         * @return 指定区间内的成员
         */
        public Set<Object> zRevRange(String key, int start, int end) {
            return redisTemplate.opsForZSet().reverseRange(key, start, end);
        }
    

        /**
         * 通过分数返回有序集合指定区间内的成员
         *
         * @param key 键
         * @param min 最小
         * @param max 最大
         * @return 指定区间内的成员
         */
        public Set<Object> zRangeByScore(String key, int min, int max) {
            return redisTemplate.opsForZSet().rangeByScore(key, min, max);
        }
    

    }

    5、Redis 操作 Controller

    这里写个简单的 Controller 类，简单的调用 Redis 字符串服务操作，内容如下：

    import mydlq.club.example.service.RedisBatch;
    import mydlq.club.example.service.RedisString;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    

    @RestController
    public class RedisController {
    

        @Autowired
        private RedisBatch redisBatch;
    

        @Autowired
        private RedisString redisString;
    

        /**
         * 存值
         *
         * @param key   键
         * @param value 值
         * @return 存储结果
         */
        @GetMapping("/set")
        public String redisStringSet(@RequestParam String key, @RequestParam String value) {
            redisString.set(key, value);
            return "存储成功";
        }
    

        /**
         * 取值
         *
         * @param key 键
         * @return 值
         */
        @GetMapping("/get")
        public Object redisStringGet(@RequestParam String key) {
            return redisString.get(key);
        }
    

        /**
         * 批量存值
         */
        @GetMapping("/batch/set")
        public void redisBatchSet() {
            Map<String, Object> map = new HashMap<>(3);
            map.put("test1", "value1");
            map.put("test2", "value2");
            map.put("test3", "value3");
            redisBatch.barchSet(map);
        }
    

        /**
         * 批量取值
         *
         * @return 值列表
         */
        @GetMapping("/batch/get")
        public List<Object> redisBatchGet() {
            // 批量取值，如果某个 key 不存在，则值为 null
            List<String> list = new ArrayList<>(3);
            list.add("test1");
            list.add("test2");
            list.add("test3");
            return redisBatch.batchGet(list);
        }
    

    }

    6、SpringBoot 启动类

    SpringBoot 的启动类，内容如下：

    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    

    @SpringBootApplication
    public class Application {
    

        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    

    }

    ---END---

    本文作者：超级小豆丁 @ 小豆丁技术栈

    本文链接：http://www.mydlq.club/article/54/

    本文标题：SpringBoot 操作 Redis 详解

    本文版权：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！