06.`spring boot`集成`redis`

作者: 风安峻_ | 来源:发表于2020-09-15 00:54 被阅读0次

1. 依赖

依赖

<!-- redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!-- redis-pool -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

说明
1. spring boot已经集成，无需声明版本号
2. commons-pool2为redis的连接池

2.主配置文件

哨兵模式

spring:
  redis:
    lettuce:
      pool:
        max-active: 10
        min-idle: 5
    # 主的密码
    password: passsword
    sentinel:
      # 主的地址，如果是 docker-compose，则为容器名
      master: redis-master
      # sentinel 的地址，也可为容器名的地址
      nodes: sentinel1:26379,sentinel2:26379,sentinel3:26379

集群模式

spring:
  redis:
    lettuce:
      pool:
        max-active: 10
        min-idle: 5
    # 集群的密码，密码要一致
    password: passsword
    cluster:
      # 也可以逗号 , 分开
      nodes:
        - 172.29.0.2:6379
        - 172.29.0.3:6379
        - 172.29.0.4:6379
        - 172.29.0.5:6379
        - 172.29.0.6:6379
        - 172.29.0.7:6379
      # 执行命令时的最大重定向次数
      max-redirects: 3

单机模式

spring:
  redis:
    host: 120.25.207.44
    port: 6379
    password: password
    database: 1
    lettuce:
      pool:
        min-idle: 5
        max-active: 10

3. `RedisConfig`配置类

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.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * 说明：
 *
 * @author sheng
 */
@Configuration
public class RedisConfig {
    /**
     * 将 RedisTemplate 对象注册到容器中
     *
     * @param factory RedisConnectionFactory 工厂
     * @return RedisTemplate 对象
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 对 key 进行序列化
        // StringRedisSerializer 当需要存储 String 类型的 key 时序列化使用
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // 对 String 的 key 进行序列化
        redisTemplate.setKeySerializer(stringRedisSerializer);
        // 对 Hash 的 key 进行序列化
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        // 也可以使用 FastJsonRedisSerializer 来序列化，需要引入 fastjson 依赖
        // 对值进行序列化
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        // 注入到 factory 工厂中
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }

    /**
     * 将操作 string redis 类型的 ValueOperations 对象注册到容器
     *
     * @param redisTemplate RedisTemplate 对象
     * @return ValueOperations 对象
     */
    @Bean
    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    /**
     * 将操作 list redis 类型的 ListOperations 对象注册到容器
     *
     * @param redisTemplate RedisTemplate 对象
     * @return ListOperations 对象
     */
    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    /**
     * 将操作 set redis 类型的 SetOperations 对象注册到容器
     *
     * @param redisTemplate RedisTemplate 对象
     * @return SetOperations 对象
     */
    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    /**
     * 将操作 zSet redis 类型的 ZSetOperations 对象注册到容器
     *
     * @param redisTemplate RedisTemplate 对象
     * @return ZSetOperations 对象
     */
    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }

    /**
     * 将操作 hash redis 类型的 ZSetOperations 对象注册到容器
     *
     * @param redisTemplate RedisTemplate 对象
     * @return HashOperations 对象
     */
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }
}

4. redis-dmo 源码

5. 工具类

service接口

import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.ZSetOperations;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * 说明：操作 redis 的工具类
 *
 * @author sheng
 */
public interface RedisService {
    // key 的操作

    /**
     * 删除 key
     *
     * @param key 要删除的 key
     * @return 成功返回 true
     */
    Boolean delete(String key);

    /**
     * 批量删除 key
     *
     * @param keys 要删除的 key 的 Collection<String>集合
     * @return 删除成功数
     */
    Long delete(Collection<String> keys);

    /**
     * 序列化 key
     *
     * @param key 要序列化的 key
     * @return byte[] 数组
     */
    byte[] dump(String key);

    /**
     * key 是否存在
     *
     * @param key key
     * @return 存在则 true，否则 false
     */
    Boolean hasKey(String key);

    /**
     * 设置过期时间
     *
     * @param key      设置过期时间的 key
     * @param timeout  过期时间
     * @param timeUnit TimeUnit 枚举类对象，单位
     * @return 成功返回 true
     */
    Boolean expire(String key, long timeout, TimeUnit timeUnit);

    /**
     * 设置过期时间
     *
     * @param key  设置过期时间的 key
     * @param date 过期时间的日期，Date 对象
     * @return 成功返回 true
     */
    Boolean expireAt(String key, Date date);

    /**
     * 查找匹配的 key
     *
     * @param pattern 条件
     * @return Set<String>
     */
    Set<String> keys(String pattern);

    /**
     * 将当前数据库的 key 移动到给定的数据库 db 当中
     *
     * @param key     移动的 key
     * @param dbIndex 目标数据库
     * @return 成功返回 true
     */
    Boolean move(String key, int dbIndex);

    /**
     * 移除 key 的过期时间，key 将持久保持
     *
     * @param key 移除的 key
     * @return 成功返回 true
     */
    Boolean persist(String key);

    /**
     * 返回 key 的剩余的过期时间
     *
     * @param key      查看的 key
     * @param timeUnit TimeUnit 枚举类，单位
     * @return 返回时间
     */
    Long getExpire(String key, TimeUnit timeUnit);

    /**
     * 返回 key 的剩余的过期时间
     *
     * @param key key
     * @return 剩余过期时间
     */
    Long getExpire(String key);

    /**
     * 从当前数据库中随机返回一个 key
     *
     * @return 返回的 key
     */
    String randomKey();

    /**
     * 修改 key 的名称
     *
     * @param oldKey key 原来的名称
     * @param newKey 新的名称
     */
    void rename(String oldKey, String newKey);

    /**
     * 仅当 newKey 不存在时，将 oldKey 改名为 newKey
     *
     * @param oldKey key 原来的名称
     * @param newKey 新的名称
     * @return 成功返回 true
     */
    Boolean renameIfAbsent(String oldKey, String newKey);

    /**
     * 返回 key 所储存的值的类型
     *
     * @param key key
     * @return key 的类型
     */
    DataType type(String key);

    // string 相关操作

    /**
     * 设置指定 key 的值
     *
     * @param key   key
     * @param value 值
     */
    void set(String key, Object value);

    /**
     * 获取指定 key 的值
     *
     * @param key key
     * @return key 的值
     */
    Object get(String key);

    /**
     * 返回 key 中字符串值的子字符
     *
     * @param key   key
     * @param start 截取的初始索引
     * @param end   截取的末索引
     * @return 子字符串
     */
    Object get(String key, long start, long end);

    /**
     * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)
     *
     * @param key   key
     * @param value 要设定的新值
     * @return key 原来的值
     */
    Object getAndSet(String key, String value);

    /**
     * 对 key 所储存的字符串值，获取指定偏移量上的位(bit)
     *
     * @param key    key
     * @param offset 偏移量
     * @return 成功返回 true
     */
    Boolean getBit(String key, long offset);

    /**
     * 批量获取
     *
     * @param keys key 集合
     * @return key 对应的值的集合
     */
    List<Object> multiGet(Collection<String> keys);

    /**
     * 设置 ASCII 码, 字符串'a'的ASCII码是97, 转为二进制是'01100001', 此方法是将二进制第 offset 位值变为value
     *
     * @param key    key
     * @param offset 位置，二进制的位数
     * @param value  值，true为 1，false为 0
     * @return 成功返回 true
     */
    Boolean setBit(String key, long offset, boolean value);

    /**
     * 将值 value 关联到 key ，并将 key 的过期时间设为 timeout
     *
     * @param key      key
     * @param value    值
     * @param timeout  过期时间
     * @param timeUnit 时间单位, 天:TimeUnit.DAYS 小时:TimeUnit.HOURS 分钟:TimeUnit.MINUTES
     *                 秒:TimeUnit.SECONDS 毫秒:TimeUnit.MILLISECONDS
     */
    void set(String key, String value, long timeout, TimeUnit timeUnit);

    /**
     * 只有在 key 不存在时设置 key 的值
     *
     * @param key   key
     * @param value 值
     * @return 之前已经存在返回false, 不存在返回true
     */
    Boolean setIfAbsent(String key, String value);

    /**
     * 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始
     *
     * @param key    key
     * @param value  复写的参数值
     * @param offset 从指定位置开始覆写
     */
    void set(String key, String value, long offset);

    /**
     * 获取字符串的长度
     *
     * @param key key
     * @return key对应值的长度
     */
    Long size(String key);

    /**
     * 批量添加
     *
     * @param maps 添加的字符串的 map
     */
    void multiSet(Map<String, String> maps);

    /**
     * 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在
     *
     * @param maps 添加的字符串的 map
     * @return 之前已经存在返回 false, 不存在返回 true
     */
    Boolean multiSetIfAbsent(Map<String, String> maps);

    /**
     * 增加(自增长), 负数则为自减
     *
     * @param key       key
     * @param increment 整型，自增的 值
     * @return 自增后的值
     */
    Long incrBy(String key, long increment);

    /**
     * 增加(自增长), 负数则为自减
     *
     * @param key       key
     * @param increment double，自增的值
     * @return 自增后的值
     */
    Double incrByDouble(String key, double increment);

    /**
     * 追加到末尾
     *
     * @param key   key
     * @param value 追加的值
     * @return key 的长度
     */
    Integer append(String key, String value);

    // hash相关操作

    /**
     * 获取存储在哈希表中指定字段的值
     *
     * @param key   key
     * @param field hash的键
     * @return 键对应的值
     */
    Object hGet(String key, String field);

    /**
     * 获取所有给定 key hash 的值
     *
     * @param key key
     * @return key 对应的所有的键值对 map
     */
    Map<String, Object> hGetAll(String key);

    /**
     * 获取所有给定字段的值
     *
     * @param key    key
     * @param fields key 对应的键的集合
     * @return 键对应的值的集合
     */
    List<Object> hMultiGet(String key, List<String> fields);

    /**
     * 给名为 key 的 hash 增加 hashKey-value 键值对
     *
     * @param key     key
     * @param hashKey hash对应的键
     * @param value   键对应的值
     */
    void hPut(String key, String hashKey, Object value);

    /**
     * 给名为 key 的 hash 增加 maps 所有的键值对
     *
     * @param key  键
     * @param maps 要增加的 map
     */
    void hPutAll(String key, Map<String, String> maps);

    /**
     * 仅当 hashKey不存在时才设置
     *
     * @param key     key hash
     * @param hashKey hash 对应的键
     * @param value   设置的值
     * @return 成功返回 true
     */
    Boolean hPutIfAbsent(String key, String hashKey, Object value);

    /**
     * 删除一个或多个哈希表字段
     *
     * @param key    hash
     * @param fields 删除的键
     * @return 删除的个数
     */
    Long hDelete(String key, Object... fields);

    /**
     * 查看哈希表 key 中，指定的字段是否存在
     *
     * @param key   hash
     * @param field 要判断的键
     * @return 存在返回 true
     */
    boolean hHasKey(String key, String field);

    /**
     * 为哈希表 key 中的指定字段的整数值加上增量 increment
     *
     * @param key       hash
     * @param field     hash 对应的键
     * @param increment 自增的值，负数为减
     * @return 增加后的值
     */
    Long hIncrBy(String key, String field, long increment);

    /**
     * 为哈希表 key 中的指定字段的整数值加上增量 increment
     *
     * @param key       hash
     * @param field     hash 对应的键
     * @param increment 自增的值，负数为减
     * @return 增加后的值
     */
    Double hIncrByDouble(String key, String field, Double increment);

    /**
     * 获取所有哈希表中的字段
     *
     * @param key hash
     * @return hash 所有的键的 Set 集合
     */
    Set<String> hKeys(String key);

    /**
     * 获取哈希表中字段的数量
     *
     * @param key key
     * @return 键的数量
     */
    Long hSize(String key);

    /**
     * 获取哈希表中所有值
     *
     * @param key hash
     * @return hash 所有的值的 List 集合
     */
    List<Object> hValues(String key);

    /**
     * 迭代哈希表中的键值对
     *
     * @param key     hash
     * @param options 迭代的条件
     * @return 连接，如果报错，可以手动关闭，调用 .close()
     */
    Cursor<Map.Entry<String, Object>> hScan(String key, ScanOptions options);

    // list相关操作

    /**
     * 通过索引获取列表中的元素
     *
     * @param key   list 对应的 key
     * @param index 索引
     * @return 对应的值
     */
    Object lIndex(String key, long index);

    /**
     * 获取列表指定范围内的元素
     *
     * @param key   key
     * @param start 开始位置, 0是开始位置
     * @param end   结束位置, -1返回所有
     * @return 元素的 集合
     */
    List<Object> lRange(String key, long start, long end);

    /**
     * 存储在list头部
     *
     * @param key   key
     * @param value 值
     * @return 集合的长度
     */
    Long lLeftPush(String key, Object value);

    /**
     * 将值全部存储在头部
     *
     * @param key   key
     * @param value 值
     * @return 集合的长度
     */
    Long lLeftPushAll(String key, Object... value);

    /**
     * 将集合里面的值全部存储在头部
     *
     * @param key   key
     * @param value Collection<String>集合
     * @return 集合的长度
     */
    Long lLeftPushAll(String key, Collection<Object> value);

    /**
     * 当list存在的时候才加入
     *
     * @param key   key
     * @param value 值
     * @return 集合的长度
     */
    Long lLeftPushIfPresent(String key, Object value);

    /**
     * 如果 pivot存在,再 pivot前面添加
     *
     * @param key   key
     * @param pivot 是否存在的值
     * @param value pivot 存在则在其前面添加的值
     * @return 集合的长度，失败返回 -1
     */
    Long lLeftPush(String key, Object pivot, Object value);

    /**
     * list 尾部添加
     *
     * @param key   key
     * @param value 值
     * @return 集合的长度
     */
    Long lRightPush(String key, Object value);

    /**
     * 尾部添加所有
     *
     * @param key   key
     * @param value 添加的值
     * @return 集合的长度
     */
    Long lRightPushAll(String key, Object... value);

    /**
     * 尾部添加所有
     *
     * @param key   list key
     * @param value 要添加的 Collection<String> 集合
     * @return 集合的长度
     */
    Long lRightPushAll(String key, Collection<Object> value);

    /**
     * 为已存在的 list 列表添加值
     *
     * @param key   key
     * @param value 要添加的值
     * @return 集合的长度
     */
    Long lRightPushIfPresent(String key, Object value);

    /**
     * 在 pivot 元素的右边添加值
     *
     * @param key   list
     * @param pivot list 存在的元素，在其右边添加
     * @param value 添加的值
     * @return 集合的长度
     */
    Long lRightPush(String key, Object pivot, Object value);

    /**
     * 通过索引设置列表元素的值
     *
     * @param key   list
     * @param index 位置
     * @param value 添加的值
     */
    void lSet(String key, long index, String value);

    /**
     * 移出并获取列表的第一个元素
     *
     * @param key key
     * @return 删除的元素
     */
    Object lLeftPop(String key);

    /**
     * 移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
     *
     * @param key      key
     * @param timeout  等待时间
     * @param timeUnit 时间单位
     * @return 移除的元素
     */
    Object lLeftPop(String key, long timeout, TimeUnit timeUnit);

    /**
     * 移除并获取列表最后一个元素
     *
     * @param key key
     * @return 删除的元素
     */
    Object lRightPop(String key);

    /**
     * 移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
     *
     * @param key      key
     * @param timeout  等待时间
     * @param timeUnit 时间单位
     * @return 移除的元素
     */
    Object lRightPop(String key, long timeout, TimeUnit timeUnit);

    /**
     * 移除列表的最后一个元素，并将该元素添加到另一个列表并返回
     *
     * @param sourceKey      源 list
     * @param destinationKey 目标 list
     * @return 源 list 移除的元素
     */
    Object lRightPopAndLeftPush(String sourceKey, String destinationKey);

    /**
     * 从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
     *
     * @param sourceKey      源 list
     * @param destinationKey 目标 list
     * @param timeout        超时时间
     * @param timeUnit       TimeUnit 枚举类对象，单位
     * @return 源 list 移除的元素
     */
    Object lRightPopAndLeftPush(String sourceKey, String destinationKey, long timeout, TimeUnit timeUnit);

    /**
     * 删除集合中值等于value得元素
     *
     * @param key   key
     * @param index index=0, 删除所有值等于value的元素; index>0, 从头部开始删除第一个值等于value的元素;
     *              index<0, 从尾部开始删除第一个值等于value的元素;
     * @param value 要删除的值
     * @return 删除的个数
     */
    Long lRemove(String key, long index, String value);

    /**
     * 裁剪list
     *
     * @param key   key
     * @param start 裁剪的起始索引
     * @param end   裁剪的末尾索引
     */
    void lTrim(String key, long start, long end);

    /**
     * 获取列表长度
     *
     * @param key key
     * @return list 长度
     */
    Long lSize(String key);

    // set相关操作

    /**
     * set添加元素
     *
     * @param key    key
     * @param values 添加的元素
     * @return 成功个数
     */
    Long sAdd(String key, Object... values);

    /**
     * set移除元素
     *
     * @param key    key
     * @param values 删除的元素
     * @return 删除成功个数
     */
    Long sRemove(String key, Object... values);

    /**
     * 移除并返回集合的一个随机元素
     *
     * @param key set 集合 key
     * @return 移除的元素
     */
    Object sPop(String key);

    /**
     * 将元素value从一个集合移到另一个集合
     *
     * @param key     源 set
     * @param value   移动的 值
     * @param destKey 目标 set
     * @return 成功返回 true
     */
    Boolean sMove(String key, String value, String destKey);

    /**
     * 获取集合的大小
     *
     * @param key set 集合
     * @return 集合大小
     */
    Long sSize(String key);

    /**
     * 判断集合是否包含value
     *
     * @param key   set 集合
     * @param value 是否包含的值
     * @return 存在返回 true
     */
    Boolean sIsMember(String key, Object value);

    /**
     * 获取两个集合的交集
     *
     * @param key      集合
     * @param otherKey 集合
     * @return 两个集合的交集
     */
    Set<Object> sIntersect(String key, String otherKey);

    /**
     * 获取key集合与多个集合的交集
     *
     * @param key       集合
     * @param otherKeys 包含多个集合 key 的集合 Collection<String>
     * @return 交集
     */
    Set<Object> sIntersect(String key, Collection<String> otherKeys);

    /**
     * key集合与otherKey集合的交集存储到destKey集合中
     *
     * @param key      求交集的集合
     * @param otherKey 求交集的集合
     * @param destKey  交集存储的目标集合
     * @return 交集元素个数
     */
    Long sIntersectAndStore(String key, String otherKey, String destKey);

    /**
     * key集合与多个集合的交集存储到destKey集合中
     *
     * @param key       集合 key
     * @param otherKeys 包含多个集合 key 的集合 Collection<String>
     * @param destKey   交集存储的目标集合
     * @return 添加到 destKey 交集的个数
     */
    Long sIntersectAndStore(String key, Collection<String> otherKeys, String destKey);

    /**
     * 获取两个集合的并集
     *
     * @param key       集合
     * @param otherKeys 集合
     * @return 并集
     */
    Set<Object> sUnion(String key, String otherKeys);

    /**
     * 获取key集合与多个集合的并集
     *
     * @param key       集合
     * @param otherKeys 包含多个集合 key 的集合 Collection<String>
     * @return 并集
     */
    Set<Object> sUnion(String key, Collection<String> otherKeys);

    /**
     * key集合与otherKey集合的并集存储到destKey中
     *
     * @param key      求并集的集合
     * @param otherKey 求并集的集合
     * @param destKey  并集添加到的目标集合
     * @return 添加到目标集合的值的个数
     */
    Long sUnionAndStore(String key, String otherKey, String destKey);

    /**
     * key集合与多个集合的并集存储到destKey中
     *
     * @param key       集合
     * @param otherKeys 包含多个集合 key 的集合 Collection<String>
     * @param destKey   并集添加到的目标集合
     * @return 添加到目标集合的值的个数
     */
    Long sUnionAndStore(String key, Collection<String> otherKeys,
                        String destKey);

    /**
     * 获取两个集合的差集
     *
     * @param key      集合
     * @param otherKey 集合
     * @return 差集
     */
    Set<Object> sDifference(String key, String otherKey);

    /**
     * 获取key集合与多个集合的差集
     *
     * @param key       集合
     * @param otherKeys 包含多个集合 key 的集合 Collection<String>
     * @return 差集
     */
    Set<Object> sDifference(String key, Collection<String> otherKeys);

    /**
     * key集合与otherKey集合的差集存储到destKey中
     *
     * @param key      求差集的集合
     * @param otherKey 求差集的集合
     * @param destKey  差集添加到的目标集合
     * @return 添加到目标集合的值的个数
     */
    Long sDifference(String key, String otherKey, String destKey);

    /**
     * key集合与多个集合的差集存储到destKey中
     *
     * @param key       求差集的集合
     * @param otherKeys 包含多个集合 key 的集合 Collection<String>
     * @param destKey   差集添加到的目标集合
     * @return 添加到目标集合的值的个数
     */
    Long sDifference(String key, Collection<String> otherKeys,
                     String destKey);

    /**
     * 获取集合所有元素
     *
     * @param key 集合
     * @return 集合的所有元素
     */
    Set<Object> sMembers(String key);

    /**
     * 随机获取集合中的一个元素
     *
     * @param key 集合
     * @return 随机返回的元素
     */
    Object sRandomMember(String key);

    /**
     * 随机获取集合中count个元素，可能获取同一个元素多次
     *
     * @param key   集合
     * @param count 获取的个数
     * @return 获取到的元素的集合
     */
    List<Object> sRandomMembers(String key, long count);

    /**
     * 随机获取集合中count个元素并且去除重复的
     *
     * @param key   集合
     * @param count 随机获取的元素个数
     * @return 元素的集合
     */
    Set<Object> sDistinctRandomMembers(String key, long count);

    /**
     * 迭代 set 集合
     *
     * @param key     要迭代的集合
     * @param options 迭代的条件
     * @return 连接，如果报错，可以手动关闭，调用 .close()
     */
    Cursor<Object> sScan(String key, ScanOptions options);

    // zSet相关操作

    /**
     * 添加元素,有序集合是按照元素的score值由小到大排列
     *
     * @param key   集合
     * @param value 添加的元素
     * @param score 元素对应的分数
     * @return 成功返回 true
     */
    Boolean zAdd(String key, Object value, double score);

    /**
     * 将 values 集合的元素添加的 key 集合
     *
     * @param key    集合 key
     * @param values Set<ZSetOperations.TypedTuple<Object>> 集合
     * @return 添加的个数
     */
    Long zAdd(String key, Set<ZSetOperations.TypedTuple<Object>> values);

    /**
     * 删除元素
     *
     * @param key    集合
     * @param values 要删除的元素，可变参数
     * @return 删除的个数
     */
    Long zRemove(String key, Object... values);

    /**
     * 增加元素的score值，并返回增加后的值
     *
     * @param key   集合
     * @param value 要添加 score 值的元素
     * @param delta 添加的 score 的值
     * @return 增加后的值
     */
    Double zIncrementScore(String key, Object value, double delta);

    /**
     * 返回元素在集合的排名,有序集合是按照元素的score值由小到大排列
     *
     * @param key   集合
     * @param value 要返回排名的值
     * @return 0表示第一位
     */
    Long zRank(String key, Object value);

    /**
     * 返回元素在集合的排名,按元素的score值由大到小排列
     *
     * @param key   集合
     * @param value 要返回排名的值
     * @return 0表示第一位
     */
    Long zReverseRank(String key, Object value);

    /**
     * 获取集合的元素, 从小到大排序
     *
     * @param key   集合
     * @param start 开始位置
     * @param end   结束位置, -1查询所有
     * @return 元素的集合
     */
    Set<Object> zRange(String key, long start, long end);

    /**
     * 获取集合元素, 并且把score值也获取
     *
     * @param key   集合
     * @param start 开始位置
     * @param end   结束位置, -1查询所有
     * @return 元素的集合
     */
    Set<ZSetOperations.TypedTuple<Object>> zRangeWithScores(String key, long start, long end);

    /**
     * 根据Score值查询集合元素
     *
     * @param key 集合
     * @param min 最小值
     * @param max 最大值
     * @return 元素的集合
     */
    Set<Object> zRangeByScore(String key, double min, double max);

    /**
     * 根据Score值查询集合元素, 从小到大排序
     *
     * @param key 集合
     * @param min 最小值
     * @param max 最大值
     * @return 元素的集合
     */
    Set<ZSetOperations.TypedTuple<Object>> zRangeByScoreWithScores(String key, double min, double max);

    /**
     * 获取key集合中索引在 [start, end] 的分数在 [min, max] 范围内的所有元素及其分数
     *
     * @param key   集合
     * @param min   score 最小值
     * @param max   score 最大值
     * @param start 开始位置
     * @param end   结束位置, -1查询所有
     * @return 获取到的元素集合
     */
    Set<ZSetOperations.TypedTuple<Object>> zRangeByScoreWithScores(String key, double min,
                                                                   double max, long start, long end);

    /**
     * 获取集合的元素, 从大到小排序
     *
     * @param key   集合
     * @param start 开始位置
     * @param end   结束位置, -1查询所有
     * @return 获取到的元素集合
     */
    Set<Object> zReverseRange(String key, long start, long end);

    /**
     * 获取集合的元素, 从大到小排序, 并返回score值
     *
     * @param key   集合
     * @param start 开始位置
     * @param end   结束位置, -1查询所有
     * @return 元素的集合
     */
    Set<ZSetOperations.TypedTuple<Object>> zReverseRangeWithScores(String key, long start, long end);

    /**
     * 根据Score值查询集合元素, 从大到小排序
     *
     * @param key 集合
     * @param min score 最小值
     * @param max score 最大值
     * @return 元素集合
     */
    Set<Object> zReverseRangeByScore(String key, double min, double max);

    /**
     * 根据Score值查询集合元素及其分数, 从大到小排序
     *
     * @param key 集合
     * @param min score 最小值
     * @param max score 最大值
     * @return 元素集合
     */
    Set<ZSetOperations.TypedTuple<Object>> zReverseRangeByScoreWithScores(String key, double min, double max);

    /**
     * 获取key集合中索引在 [start, end] 的分数在 [min, max] 范围内的所有元素
     *
     * @param key   key 集合
     * @param min   score 最小值
     * @param max   score 最大值
     * @param start 起始位置
     * @param end   末尾位置
     * @return 元素集合
     */
    Set<Object> zReverseRangeByScore(String key, double min, double max, long start, long end);

    /**
     * 根据score值获取集合元素个数
     *
     * @param key 集合
     * @param min score 最小值
     * @param max score 最大值
     * @return 元素个数
     */
    Long zCount(String key, double min, double max);

    /**
     * 获取集合大小
     *
     * @param key 集合
     * @return 包含的元素的个数
     */
    Long zSize(String key);

    /**
     * 获取集合大小
     *
     * @param key 集合
     * @return 集合大小
     */
    Long zCard(String key);

    /**
     * 获取集合中value元素的score值
     *
     * @param key   集合
     * @param value 要获取 score 值的元素
     * @return score 值
     */
    Double zScore(String key, Object value);

    /**
     * 移除指定索引位置的成员
     *
     * @param key   集合
     * @param start 起始位置
     * @param end   结束位置
     * @return 移除的个数
     */
    Long zRemoveRange(String key, long start, long end);

    /**
     * 根据指定的score值的范围来移除成员
     *
     * @param key 集合
     * @param min score 最小值
     * @param max score 最大值
     * @return 移除的个数
     */
    Long zRemoveRangeByScore(String key, double min, double max);

    /**
     * 获取 key和 otherKey的并集并存储在destKey中
     *
     * @param key      求并集的集合
     * @param otherKey 求并集的集合
     * @param destKey  并集存储的目标集合
     * @return 添加到目标集合的个数
     */
    Long zUnionAndStore(String key, String otherKey, String destKey);

    /**
     * 获取 key和 otherKey 的并集并存储在destKey中
     *
     * @param key       集合 key
     * @param otherKeys 多个集合 key 的 Collection<String> 集合
     * @param destKey   并集添加到的目标集合
     * @return 添加到目标集合的元素个数
     */
    Long zUnionAndStore(String key, Collection<String> otherKeys, String destKey);

    /**
     * 获取 key和 otherKey 的交集并存储在destKey中
     *
     * @param key      集合
     * @param otherKey 集合
     * @param destKey  交集添加到的目标集合
     * @return 添加到目标集合的元素个数
     */
    Long zIntersectAndStore(String key, String otherKey, String destKey);

    /**
     * 获取 key和 otherKey 的交集并存储在destKey中
     *
     * @param key       求交集的集合
     * @param otherKeys 求交集的集合
     * @param destKey   交集添加到的目标集合
     * @return 添加到目标集合的元素个数
     */
    Long zIntersectAndStore(String key, Collection<String> otherKeys, String destKey);

    /**
     * 迭代集合
     *
     * @param key     要迭代的集合
     * @param options 迭代的条件
     * @return 连接，如果报错，调用 .close() 方法关闭
     */
    Cursor<ZSetOperations.TypedTuple<Object>> zScan(String key, ScanOptions options);

}

RedisServiceImpl实现

import com.sheng.boot.redis.service.RedisService;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * 说明：
 *
 * @author sheng
 */
@Service
public class RedisServiceImpl implements RedisService {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    @Resource
    private ValueOperations<String, Object> valueOperations;
    @Resource
    private HashOperations<String, String, Object> hashOperations;
    @Resource
    private ListOperations<String, Object> listOperations;
    @Resource
    private SetOperations<String, Object> setOperations;
    @Resource
    private ZSetOperations<String, Object> zSetOperations;

    @Override
    public Boolean delete(String key) {
        return redisTemplate.delete(key);
    }

    @Override
    public Long delete(Collection<String> keys) {
        return redisTemplate.delete(keys);
    }

    @Override
    public byte[] dump(String key) {
        return redisTemplate.dump(key);
    }

    @Override
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    @Override
    public Boolean expire(String key, long timeout, TimeUnit timeUnit) {
        return redisTemplate.expire(key, timeout, timeUnit);
    }

    @Override
    public Boolean expireAt(String key, Date date) {
        return redisTemplate.expireAt(key, date);
    }

    @Override
    public Set<String> keys(String pattern) {
        return redisTemplate.keys(pattern);
    }

    @Override
    public Boolean move(String key, int dbIndex) {
        return redisTemplate.move(key, dbIndex);
    }

    @Override
    public Boolean persist(String key) {
        return redisTemplate.persist(key);
    }

    @Override
    public Long getExpire(String key, TimeUnit timeUnit) {
        return redisTemplate.getExpire(key, timeUnit);
    }

    @Override
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key);
    }

    @Override
    public String randomKey() {
        return redisTemplate.randomKey();
    }

    @Override
    public void rename(String oldKey, String newKey) {
        redisTemplate.rename(oldKey, newKey);
    }

    @Override
    public Boolean renameIfAbsent(String oldKey, String newKey) {
        return redisTemplate.renameIfAbsent(oldKey, newKey);
    }

    @Override
    public DataType type(String key) {
        return redisTemplate.type(key);
    }

    @Override
    public void set(String key, Object value) {
        valueOperations.set(key, value);
    }

    @Override
    public Object get(String key) {
        return valueOperations.get(key);
    }

    @Override
    public Object get(String key, long start, long end) {
        return valueOperations.get(key, start, end);
    }

    @Override
    public Object getAndSet(String key, String value) {
        return valueOperations.getAndSet(key, value);
    }

    @Override
    public Boolean getBit(String key, long offset) {
        return valueOperations.getBit(key, offset);
    }

    @Override
    public List<Object> multiGet(Collection<String> keys) {
        return valueOperations.multiGet(keys);
    }

    @Override
    public Boolean setBit(String key, long offset, boolean value) {
        return valueOperations.setBit(key, offset, value);
    }

    @Override
    public void set(String key, String value, long timeout, TimeUnit timeUnit) {
        valueOperations.set(key, value, timeout, timeUnit);
    }

    @Override
    public Boolean setIfAbsent(String key, String value) {
        return valueOperations.setIfAbsent(key, value);
    }

    @Override
    public void set(String key, String value, long offset) {
        valueOperations.set(key, value, offset);
    }

    @Override
    public Long size(String key) {
        return valueOperations.size(key);
    }

    @Override
    public void multiSet(Map<String, String> maps) {
        valueOperations.multiSet(maps);
    }

    @Override
    public Boolean multiSetIfAbsent(Map<String, String> maps) {
        return valueOperations.multiSetIfAbsent(maps);
    }

    @Override
    public Long incrBy(String key, long increment) {
        return valueOperations.increment(key, increment);
    }

    @Override
    public Double incrByDouble(String key, double increment) {
        return valueOperations.increment(key, increment);
    }

    @Override
    public Integer append(String key, String value) {
        return valueOperations.append(key, value);
    }

    @Override
    public Object hGet(String key, String field) {
        return hashOperations.get(key, field);
    }

    @Override
    public Map<String, Object> hGetAll(String key) {
        return hashOperations.entries(key);
    }

    @Override
    public List<Object> hMultiGet(String key, List<String> fields) {
        return hashOperations.multiGet(key, fields);
    }

    @Override
    public void hPut(String key, String hashKey, Object value) {
        hashOperations.put(key, hashKey, value);
    }

    @Override
    public void hPutAll(String key, Map<String, String> maps) {
        hashOperations.putAll(key, maps);
    }

    @Override
    public Boolean hPutIfAbsent(String key, String hashKey, Object value) {
        return hashOperations.putIfAbsent(key, hashKey, value);
    }

    @Override
    public Long hDelete(String key, Object... fields) {
        return hashOperations.delete(key, fields);
    }

    @Override
    public boolean hHasKey(String key, String field) {
        return hashOperations.hasKey(key, field);
    }

    @Override
    public Long hIncrBy(String key, String field, long increment) {
        return hashOperations.increment(key, field, increment);
    }

    @Override
    public Double hIncrByDouble(String key, String field, Double increment) {
        return hashOperations.increment(key, field, increment);
    }

    @Override
    public Set<String> hKeys(String key) {
        return hashOperations.keys(key);
    }

    @Override
    public Long hSize(String key) {
        return hashOperations.size(key);
    }

    @Override
    public List<Object> hValues(String key) {
        return hashOperations.values(key);
    }

    @Override
    public Cursor<Map.Entry<String, Object>> hScan(String key, ScanOptions options) {
        return hashOperations.scan(key, options);
    }

    @Override
    public Object lIndex(String key, long index) {
        return listOperations.index(key, index);
    }

    @Override
    public List<Object> lRange(String key, long start, long end) {
        return listOperations.range(key, start, end);
    }

    @Override
    public Long lLeftPush(String key, Object value) {
        return listOperations.leftPush(key, value);
    }

    @Override
    public Long lLeftPushAll(String key, Object... value) {
        return listOperations.leftPushAll(key, value);
    }

    @Override
    public Long lLeftPushAll(String key, Collection<Object> value) {
        return listOperations.leftPushAll(key, value);
    }

    @Override
    public Long lLeftPushIfPresent(String key, Object value) {
        return listOperations.leftPushIfPresent(key, value);
    }

    @Override
    public Long lLeftPush(String key, Object pivot, Object value) {
        return listOperations.leftPush(key, pivot, value);
    }

    @Override
    public Long lRightPush(String key, Object value) {
        return listOperations.rightPush(key, value);
    }

    @Override
    public Long lRightPushAll(String key, Object... value) {
        return listOperations.rightPushAll(key, value);
    }

    @Override
    public Long lRightPushAll(String key, Collection<Object> value) {
        return listOperations.rightPushAll(key, value);
    }

    @Override
    public Long lRightPushIfPresent(String key, Object value) {
        return listOperations.rightPushIfPresent(key, value);
    }

    @Override
    public Long lRightPush(String key, Object pivot, Object value) {
        return listOperations.rightPush(key, pivot, value);
    }

    @Override
    public void lSet(String key, long index, String value) {
        listOperations.set(key, index, value);
    }

    @Override
    public Object lLeftPop(String key) {
        return listOperations.leftPop(key);
    }

    @Override
    public Object lLeftPop(String key, long timeout, TimeUnit timeUnit) {
        return listOperations.leftPop(key, timeout, timeUnit);
    }

    @Override
    public Object lRightPop(String key) {
        return listOperations.rightPop(key);
    }

    @Override
    public Object lRightPop(String key, long timeout, TimeUnit timeUnit) {
        return listOperations.rightPop(key, timeout, timeUnit);
    }

    @Override
    public Object lRightPopAndLeftPush(String sourceKey, String destinationKey) {
        return listOperations.rightPopAndLeftPush(sourceKey, destinationKey);
    }

    @Override
    public Object lRightPopAndLeftPush(String sourceKey, String destinationKey, long timeout, TimeUnit timeUnit) {
        return listOperations.rightPopAndLeftPush(sourceKey, destinationKey, timeout, timeUnit);
    }

    @Override
    public Long lRemove(String key, long index, String value) {
        return listOperations.remove(key, index, value);
    }

    @Override
    public void lTrim(String key, long start, long end) {
        listOperations.trim(key, start, end);
    }

    @Override
    public Long lSize(String key) {
        return listOperations.size(key);
    }

    @Override
    public Long sAdd(String key, Object... values) {
        return setOperations.add(key, values);
    }

    @Override
    public Long sRemove(String key, Object... values) {
        return setOperations.remove(key, values);
    }

    @Override
    public Object sPop(String key) {
        return setOperations.pop(key);
    }

    @Override
    public Boolean sMove(String key, String value, String destKey) {
        return setOperations.move(key, value, destKey);
    }

    @Override
    public Long sSize(String key) {
        return setOperations.size(key);
    }

    @Override
    public Boolean sIsMember(String key, Object value) {
        return setOperations.isMember(key, value);
    }

    @Override
    public Set<Object> sIntersect(String key, String otherKey) {
        return setOperations.intersect(key, otherKey);
    }

    @Override
    public Set<Object> sIntersect(String key, Collection<String> otherKeys) {
        return setOperations.intersect(key, otherKeys);
    }

    @Override
    public Long sIntersectAndStore(String key, String otherKey, String destKey) {
        return setOperations.intersectAndStore(key, otherKey, destKey);
    }

    @Override
    public Long sIntersectAndStore(String key, Collection<String> otherKeys, String destKey) {
        return setOperations.intersectAndStore(key, otherKeys, destKey);
    }

    @Override
    public Set<Object> sUnion(String key, String otherKeys) {
        return setOperations.union(key, otherKeys);
    }

    @Override
    public Set<Object> sUnion(String key, Collection<String> otherKeys) {
        return setOperations.union(key, otherKeys);
    }

    @Override
    public Long sUnionAndStore(String key, String otherKey, String destKey) {
        return setOperations.unionAndStore(key, otherKey, destKey);
    }

    @Override
    public Long sUnionAndStore(String key, Collection<String> otherKeys, String destKey) {
        return setOperations.unionAndStore(key, otherKeys, destKey);
    }

    @Override
    public Set<Object> sDifference(String key, String otherKey) {
        return setOperations.difference(key, otherKey);
    }

    @Override
    public Set<Object> sDifference(String key, Collection<String> otherKeys) {
        return setOperations.difference(key, otherKeys);
    }

    @Override
    public Long sDifference(String key, String otherKey, String destKey) {
        return setOperations.differenceAndStore(key, otherKey, destKey);
    }

    @Override
    public Long sDifference(String key, Collection<String> otherKeys, String destKey) {
        return setOperations.differenceAndStore(key, otherKeys, destKey);
    }

    @Override
    public Set<Object> sMembers(String key) {
        return setOperations.members(key);
    }

    @Override
    public Object sRandomMember(String key) {
        return setOperations.randomMember(key);
    }

    @Override
    public List<Object> sRandomMembers(String key, long count) {
        return setOperations.randomMembers(key, count);
    }

    @Override
    public Set<Object> sDistinctRandomMembers(String key, long count) {
        return setOperations.distinctRandomMembers(key, count);
    }

    @Override
    public Cursor<Object> sScan(String key, ScanOptions options) {
        return setOperations.scan(key, options);
    }

    @Override
    public Boolean zAdd(String key, Object value, double score) {
        return zSetOperations.add(key, value, score);
    }

    @Override
    public Long zAdd(String key, Set<ZSetOperations.TypedTuple<Object>> values) {
        return zSetOperations.add(key, values);
    }

    @Override
    public Long zRemove(String key, Object... values) {
        return zSetOperations.remove(key, values);
    }

    @Override
    public Double zIncrementScore(String key, Object value, double delta) {
        return zSetOperations.incrementScore(key, value, delta);
    }

    @Override
    public Long zRank(String key, Object value) {
        return zSetOperations.rank(key, value);
    }

    @Override
    public Long zReverseRank(String key, Object value) {
        return zSetOperations.reverseRank(key, value);
    }

    @Override
    public Set<Object> zRange(String key, long start, long end) {
        return zSetOperations.range(key, start, end);
    }

    @Override
    public Set<ZSetOperations.TypedTuple<Object>> zRangeWithScores(String key, long start, long end) {
        return zSetOperations.rangeWithScores(key, start, end);
    }

    @Override
    public Set<Object> zRangeByScore(String key, double min, double max) {
        return zSetOperations.rangeByScore(key, min, max);
    }

    @Override
    public Set<ZSetOperations.TypedTuple<Object>> zRangeByScoreWithScores(String key, double min, double max) {
        return zSetOperations.rangeByScoreWithScores(key, min, max);
    }

    @Override
    public Set<ZSetOperations.TypedTuple<Object>> zRangeByScoreWithScores(String key, double min, double max, long start, long end) {
        return zSetOperations.rangeByScoreWithScores(key, min, max, start, end);
    }

    @Override
    public Set<Object> zReverseRange(String key, long start, long end) {
        return zSetOperations.reverseRange(key, start, end);
    }

    @Override
    public Set<ZSetOperations.TypedTuple<Object>> zReverseRangeWithScores(String key, long start, long end) {
        return zSetOperations.reverseRangeWithScores(key, start, end);
    }

    @Override
    public Set<Object> zReverseRangeByScore(String key, double min, double max) {
        return zSetOperations.reverseRangeByScore(key, min, max);
    }

    @Override
    public Set<ZSetOperations.TypedTuple<Object>> zReverseRangeByScoreWithScores(String key, double min, double max) {
        return zSetOperations.reverseRangeByScoreWithScores(key, min, max);
    }

    @Override
    public Set<Object> zReverseRangeByScore(String key, double min, double max, long start, long end) {
        return zSetOperations.reverseRangeByScore(key, min, max, start, end);
    }

    @Override
    public Long zCount(String key, double min, double max) {
        return zSetOperations.count(key, min, max);
    }

    @Override
    public Long zSize(String key) {
        return zSetOperations.size(key);
    }

    @Override
    public Long zCard(String key) {
        return zSetOperations.zCard(key);
    }

    @Override
    public Double zScore(String key, Object value) {
        return zSetOperations.score(key, value);
    }

    @Override
    public Long zRemoveRange(String key, long start, long end) {
        return zSetOperations.removeRange(key, start, end);
    }

    @Override
    public Long zRemoveRangeByScore(String key, double min, double max) {
        return zSetOperations.removeRangeByScore(key, min, max);
    }

    @Override
    public Long zUnionAndStore(String key, String otherKey, String destKey) {
        return zSetOperations.unionAndStore(key, otherKey, destKey);
    }

    @Override
    public Long zUnionAndStore(String key, Collection<String> otherKeys, String destKey) {
        return zSetOperations.unionAndStore(key, otherKeys, destKey);
    }

    @Override
    public Long zIntersectAndStore(String key, String otherKey, String destKey) {
        return zSetOperations.intersectAndStore(key, otherKey, destKey);
    }

    @Override
    public Long zIntersectAndStore(String key, Collection<String> otherKeys, String destKey) {
        return zSetOperations.intersectAndStore(key, otherKeys, destKey);
    }

    @Override
    public Cursor<ZSetOperations.TypedTuple<Object>> zScan(String key, ScanOptions options) {
        return zSetOperations.scan(key, options);
    }
}

06.`spring boot`集成`redis`

1. 依赖

2.主配置文件

3. `RedisConfig`配置类

4. redis-dmo 源码

5. 工具类

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

06.`spring boot`集成`redis`

1. 依赖

2.主配置文件

3. RedisConfig配置类

4. redis-dmo 源码

5. 工具类

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

3. `RedisConfig`配置类