SpringBoot RedisTemplate 工具类

package com.just.common.util;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

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

/**
 * @author liuguozhen
 * @date 2019/08/12 14:46
 * @description redis工具
 */
@Component
public class RedisUtil {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    // =============================common============================

    /**
     * 为给定的key设定过期时间
     *
     * @param key  键
     * @param time 过期时间
     * @param unit 单位（纳秒，微秒，毫秒，秒，分钟，小时，天）
     * @return true成功 false失败
     */
    public Boolean expire(String key, long time, TimeUnit unit) {
        return redisTemplate.expire(key, time, unit);
    }

    /**
     * 为给定的key设置到期日期时间戳
     *
     * @param key  键
     * @param date 到期日期时间戳
     * @return true成功 false失败
     */
    public Boolean expireAt(String key, Date date) {
        return redisTemplate.expireAt(key, date);
    }

    /**
     * 根据key 获取过期时间
     *
     * @param key 键
     * @return -1是不过期 -2关键字不存在 其他为过期时间
     */
    public Long getExpire(String key) {
        // -2表示key不存在或者已过期
        // -1表示key永久存在
        return redisTemplate.getExpire(key);
    }

    /**
     * 获取key的过期时间并根据unit转换
     *
     * @param key  键
     * @param unit 单位
     * @return 转换后的时间
     */
    public Long getExpire(String key, TimeUnit unit) {
        return redisTemplate.getExpire(key, unit);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true存在 false不存在
     */
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 删除缓存
     *
     * @param key 键
     * @return true成功 false失败
     */
    public Boolean delete(String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 批量删除缓存
     *
     * @param keys 键（可以多个）
     * @return 成功数量
     */
    public Long delete(String... keys) {
        List<String> keyList = Arrays.asList(keys);
        return redisTemplate.delete(keyList);
    }

    // ============================String=============================

    /**
     * 追加到已存在key的value值后，如果key不存在，新增
     *
     * @param key   键
     * @param value 值
     * @return 追加/新增后的长度
     */
    public Integer append(String key, String value) {
        return redisTemplate.opsForValue().append(key, value);
    }

    /**
     * 存储值递减1
     *
     * @param key 键
     * @return 递减后的数值
     */
    public Long decrement(String key) {
        return redisTemplate.opsForValue().decrement(key);
    }

    /**
     * 存储值递减delta
     *
     * @param key   键
     * @param delta 递减值
     * @return 递减后的数值
     */
    public Long decrement(String key, long delta) {
        return redisTemplate.opsForValue().decrement(key, delta);
    }

    /**
     * 获取key对应value的开始位到结束位的子字符串
     *
     * @param key   键
     * @param start 开始位
     * @param end   结束位
     * @return 对应value的子字符串
     */
    public String get(String key, long start, long end) {
        return redisTemplate.opsForValue().get(key, start, end);
    }

    /**
     * 获取key对应value值
     *
     * @param key 键
     * @return 对应value
     */
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 存储值递增1
     *
     * @param key 键
     * @return 递增后的值
     */
    public Long increment(String key) {
        return redisTemplate.opsForValue().increment(key);
    }

    /**
     * 存储浮点型值递增delta
     *
     * @param key   键
     * @param delta 浮点型递增值
     * @return 递增后浮点型的值
     */
    public Double increment(String key, double delta) {
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 存储值递增delta
     *
     * @param key   键
     * @param delta 递增值
     * @return 递增后的值
     */
    public Long increment(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 存储key
     *
     * @param key   键
     * @param value 值
     */
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * key对应value的长度
     *
     * @param key 键
     * @return value的长度
     */
    public Long size(String key) {
        return redisTemplate.opsForValue().size(key);
    }

    // ================================Map=================================

    /**
     * 删除key对应map中的hashKeys的值
     *
     * @param key      键
     * @param hashKeys map键
     * @return 成功数量
     */
    public Long delete(String key, Object... hashKeys) {
        return redisTemplate.opsForHash().delete(key, hashKeys);
    }

    /**
     * 获取key对应的map
     *
     * @param key 键
     * @return 对应map
     */
    public Map<Object, Object> entries(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 判断key对应的map是否含有hashKey
     *
     * @param key     键
     * @param hashKey map键
     * @return true存在 false不存在
     */
    public Boolean hasKey(String key, Object hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    /**
     * key对应map的hashKey浮点型递增
     *
     * @param key     键
     * @param hashKey map键
     * @param delta   递增浮点型的值
     * @return 递增浮点型后的值
     */
    public Double increment(String key, Object hashKey, double delta) {
        return redisTemplate.opsForHash().increment(key, hashKey, delta);
    }

    /**
     * 对应keymap的hashKey递增
     *
     * @param key     键
     * @param hashKey map键
     * @param delta   递增的值
     * @return 递增浮后的值
     */
    public Long increment(String key, Object hashKey, long delta) {
        return redisTemplate.opsForHash().increment(key, hashKey, delta);
    }


    /**
     * key对应map的hashKey值的长度
     *
     * @param key     键
     * @param hashKey map的键
     * @return map的键的长度
     */
    public Long lengthOfValue(String key, Object hashKey) {
        return redisTemplate.opsForHash().lengthOfValue(key, hashKey);
    }

    /**
     * 添加/覆盖key对应map的hashKey的值
     *
     * @param key     键
     * @param hashKey map的键
     * @param value   存储的值
     */
    public void put(String key, Object hashKey, Object value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }

    /**
     * 存储一个map
     *
     * @param key 键
     * @param map 存储的map
     */
    public void putAll(String key, Map<Object, Object> map) {
        redisTemplate.opsForHash().putAll(key, map);
    }

    /**
     * key对应map的长度
     *
     * @param key 键
     * @return map的长度
     */
    public Long hSize(String key) {
        return redisTemplate.opsForHash().size(key);
    }

    //  ============================set=============================

    /**
     * 添加key对应的set值
     *
     * @param key    键
     * @param values 值（可以多个）
     * @return 成功的数量
     */
    public Long add(String key, Object... values) {
        return redisTemplate.opsForSet().add(key, values);
    }


    /**
     * key和otherKeys set的差集
     *
     * @param key       键
     * @param otherKeys 其他的键 （可以多个）
     * @return 差集
     */
    public Set<Object> difference(String key, String... otherKeys) {
        List<String> keyList = Arrays.asList(otherKeys);
        return redisTemplate.opsForSet().difference(key, keyList);
    }

    /**
     * key和otherKey set的差集
     *
     * @param key      键
     * @param otherKey 其他的键
     * @return 差集
     */
    public Set<Object> difference(String key, String otherKey) {
        return redisTemplate.opsForSet().difference(key, otherKey);
    }

    /**
     * key和otherKeys set的差集，如果有差集就用存储键保存
     *
     * @param key       键
     * @param destKey   存储键，可以是不存在的，也可以是已经存在的
     * @param otherKeys 其他的键（可以多个）
     * @return 差集的数量
     */
    public Long differenceAndStore(String key, String destKey, String... otherKeys) {
        List<String> keyList = Arrays.asList(otherKeys);
        return redisTemplate.opsForSet().differenceAndStore(key, keyList, destKey);
    }

    /**
     * key和otherKey set的差集，如果有差集就用存储键保存
     *
     * @param key      键
     * @param otherKey 其他的键
     * @param destKey  存储键，可以是不存在的，也可以是已经存在的
     * @return 差集合的数量
     */
    public Long differenceAndStore(String key, String otherKey, String destKey) {
        return redisTemplate.opsForSet().differenceAndStore(key, otherKey, destKey);
    }

    /**
     * 取出key对应set count数量的值打乱
     *
     * @param key   键
     * @param count 取出数量
     * @return 打乱的集合
     */
    public Set<Object> distinctRandomMembers(String key, long count) {
        return redisTemplate.opsForSet().distinctRandomMembers(key, count);
    }

    /**
     * key和otherKeys set的交集
     *
     * @param key       键
     * @param otherKeys 其他的键（可以多个）
     * @return 交集合
     */
    public Set<Object> intersect(String key, String... otherKeys) {
        List<String> keyList = Arrays.asList(otherKeys);
        return redisTemplate.opsForSet().intersect(key, keyList);
    }

    /**
     * key和otherKey set的交集
     *
     * @param key      键
     * @param otherKey 其他的键
     * @return 交集合
     */
    public Set<Object> intersect(String key, String otherKey) {
        return redisTemplate.opsForSet().intersect(key, otherKey);
    }

    /**
     * key和otherKeys set的交集，如果有交集就用存储键保存
     *
     * @param key       键
     * @param destKey   存储键，可以是不存在的，也可以是已经存在的
     * @param otherKeys 其他的键（可以多个）
     * @return 交集合的数量
     */
    public Long intersectAndStore(String key, String destKey, String... otherKeys) {
        List<String> keyList = Arrays.asList(otherKeys);
        return redisTemplate.opsForSet().intersectAndStore(key, keyList, destKey);
    }

    /**
     * key和otherKey set的交集，如果有交集就用存储键保存
     *
     * @param key      键
     * @param otherKey 其他的键
     * @param destKey  存储键，可以是不存在的，也可以是已经存在的
     * @return 交集合的数量
     */
    public Long intersectAndStore(String key, String otherKey, String destKey) {
        return redisTemplate.opsForSet().intersectAndStore(key, otherKey, destKey);
    }

    /**
     * key对应set是否含有value
     *
     * @param key   键
     * @param value 值
     * @return true含有 false不含有
     */
    public Boolean isMember(String key, Object value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }

    /**
     * 取出key对应的set
     *
     * @param key 键
     * @return 对应的值
     */
    public Set<Object> members(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 移除key中value值到destKey中
     *
     * @param key     键
     * @param value   值
     * @param destKey 其他键，可以是不存在的，也可以是已经存在的
     * @return true成功 false失败
     */
    public Boolean move(String key, Object value, String destKey) {
        return redisTemplate.opsForSet().move(key, value, destKey);
    }


    /**
     * 移除key对应set的随机元素
     *
     * @param key 键
     * @return 移除的值
     */
    public Object pop(String key) {
        return redisTemplate.opsForSet().pop(key);
    }

    /**
     * 移除key对应set的随机元素，小于等于count
     *
     * @param key   键
     * @param count 移除的数量
     * @return 移除的值（list）
     */
    public List<Object> pop(String key, long count) {
        return redisTemplate.opsForSet().pop(key, count);
    }

    /**
     * 随机获取key对应set中的值
     *
     * @param key 键
     * @return key中的value
     */
    public Object randomMember(String key) {
        return redisTemplate.opsForSet().randomMember(key);
    }

    /**
     * 随机获取key对应set中的值，小于等于count
     *
     * @param key   键
     * @param count 取的数量
     * @return 取出的值（list）
     */
    public List<Object> randomMember(String key, long count) {
        return redisTemplate.opsForSet().randomMembers(key, count);
    }

    /**
     * 移除key对应set中的values
     *
     * @param key    键
     * @param values 移除的值
     * @return 移除成功的数量
     */
    public Long remove(String key, Object... values) {
        return redisTemplate.opsForSet().remove(key, values);
    }

    /**
     * 获取key对应set的长度
     *
     * @param key 键
     * @return set的长度
     */
    public Long sSize(String key) {
        return redisTemplate.opsForSet().size(key);
    }

    /**
     * key和otherKeys set的并集
     *
     * @param key       键
     * @param otherKeys 其他键（可以多个）
     * @return 并集
     */
    public Set<Object> union(String key, String... otherKeys) {
        List<String> keyList = Arrays.asList(otherKeys);
        return redisTemplate.opsForSet().union(key, keyList);
    }

    /**
     * key和otherKey set的并集
     *
     * @param key      键
     * @param otherKey 其他键
     * @return 并集
     */
    public Set<Object> union(String key, String otherKey) {
        return redisTemplate.opsForSet().union(key, otherKey);
    }

    /**
     * key和otherKeys set的并集，添加到destKey
     *
     * @param key       键
     * @param destKey   存储键，可以是不存在的，也可以是已经存在的
     * @param otherKeys 其他键（可以多个）
     * @return 并集的数量
     */
    public Long unionAndStore(String key, String destKey, String... otherKeys) {
        List<String> keyList = Arrays.asList(otherKeys);
        return redisTemplate.opsForSet().unionAndStore(key, keyList, destKey);
    }

    /**
     * key和otherKey set的并集，添加到destKey
     *
     * @param key      键
     * @param otherKey 其他键
     * @param destKey  存储键，可以是不存在的，也可以是已经存在的
     * @return 并集的数量
     */
    public Long unionAndStore(String key, String otherKey, String destKey) {
        return redisTemplate.opsForSet().unionAndStore(key, otherKey, destKey);
    }

    // ===============================list=================================

    /**
     * 获取key对应list（开始位到结束位，结束位为-1时，取出所有元素）
     *
     * @param key   键
     * @param start 开始位
     * @param end   结束位
     * @return 对应的list
     */
    public List<Object> range(String key, long start, long end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

    /**
     * 清除key对应的list元素（保留开始位到结束位的元素，删除其他元素）
     *
     * @param key   键
     * @param start 开始位
     * @param end   结束位
     */
    public void trim(String key, long start, long end) {
        redisTemplate.opsForList().trim(key, start, end);
    }

    /**
     * 获取key对应list的长度
     *
     * @param key 键
     * @return list的长度
     */
    public Long lSize(String key) {
        return redisTemplate.opsForList().size(key);
    }


    /**
     * 从头部添加元素
     *
     * @param key   键
     * @param value 值
     * @return 添加后list的长度
     */
    public Long leftPush(String key, Object value) {
        return redisTemplate.opsForList().leftPush(key, value);
    }

    /**
     * 从头部添加全部元素
     *
     * @param key    键
     * @param values 值（可以多个）
     * @return 添加后list的长度
     */
    public Long leftPushAll(String key, Object... values) {
        return redisTemplate.opsForList().leftPushAll(key, values);
    }

    /**
     * 从头部添加全部元素
     *
     * @param key    键
     * @param values 值（可以多个）
     * @return 添加后list的长度
     */
    public Long leftPushAll(String key, Collection<Object> values) {
        return redisTemplate.opsForList().leftPushAll(key, values);
    }

    /**
     * 从头部添加元素（仅当key值对应list存在添加成功）
     *
     * @param key   键
     * @param value 值
     * @return 添加后list的长度，0代表失败
     */
    public Long leftPushIfPresent(String key, Object value) {
        return redisTemplate.opsForList().leftPushIfPresent(key, value);
    }

    /**
     * 从头部出发，首先出现的pivot值前添加value
     *
     * @param key   键
     * @param pivot 目标
     * @param value 值
     * @return 添加后list的长度
     */
    public Long leftPush(String key, Object pivot, Object value) {
        return redisTemplate.opsForList().leftPush(key, pivot, value);
    }

    /**
     * 从尾部添加一个元素
     *
     * @param key   键
     * @param value 值
     * @return 添加后list的长度
     */
    public Long rightPush(String key, Object value) {
        return redisTemplate.opsForList().rightPush(key, value);
    }

    /**
     * 从尾部添加全部元素
     *
     * @param key    键
     * @param values 值（可以多个）
     * @return 添加后list的长度
     */
    public Long rightPushAll(String key, Object... values) {
        return redisTemplate.opsForList().rightPushAll(key, values);
    }

    /**
     * 从尾部添加全部元素
     *
     * @param key    键
     * @param values 值（可以多个）
     * @return 添加后list的长度
     */
    public Long rightPushAll(String key, Collection<Object> values) {
        return redisTemplate.opsForList().rightPushAll(key, values);
    }

    /**
     * 从尾部添加元素（仅当key值对应list存在添加成功）
     *
     * @param key   键
     * @param value 值
     * @return 添加后list的长度
     */
    public Long rightPushIfPresent(String key, Object value) {
        return redisTemplate.opsForList().rightPushIfPresent(key, value);
    }

    /**
     * 从尾部出发，首先出现的pivot值前添加value
     *
     * @param key   键
     * @param pivot 目标
     * @param value 值
     * @return 添加后list的长度
     */
    public Long rightPush(String key, Object pivot, Object value) {
        return redisTemplate.opsForList().rightPush(key, pivot, value);
    }

    /**
     * 替换key对应list的index索引位上的值为value
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     */
    public void set(String key, long index, Object value) {
        redisTemplate.opsForList().set(key, index, value);
    }

    /**
     * 从头部开始移除key对应list中的value值，小于等于count
     *
     * @param key   键
     * @param count 次数
     * @param value 值
     * @return 1成功 0失败
     */
    public Long remove(String key, long count, Object value) {
        return redisTemplate.opsForList().remove(key, count, value);
    }

    /**
     * 从头部开始，取出key对应list中index索引位的值
     *
     * @param key   键
     * @param index 索引
     * @return list索引处的值
     */
    public Object index(String key, long index) {
        return redisTemplate.opsForList().index(key, index);
    }

    /**
     * 从头部开始移除一位
     *
     * @param key 键
     * @return 移除的值
     */
    public Object leftPop(String key) {
        return redisTemplate.opsForList().leftPop(key);
    }

    /**
     * 从尾部开始移除一位
     *
     * @param key 键
     * @return 移除的值
     */
    public Object rightPop(String key) {
        return redisTemplate.opsForList().rightPop(key);
    }

    /**
     * 从sourceKey尾部移除一个值删除，然后插入destinationKey的左侧
     *
     * @param sourceKey      移除键
     * @param destinationKey 保存键
     * @return 移除的值
     */
    public Object rightPopAndLeftPush(String sourceKey, String destinationKey) {
        return redisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey);
    }


}