• Home
• cn.acyou
• leo-framework-commons
• 1.6.0.RELEASE
• source code
• RedisUtils.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

cn.acyou.leo.framework.util.redis.RedisUtils Maven / Gradle / Ivy

package cn.acyou.leo.framework.util.redis;

import cn.acyou.leo.framework.constant.CommonErrorEnum;
import cn.acyou.leo.framework.exception.ConcurrentException;
import cn.acyou.leo.framework.exception.ServiceException;
import cn.acyou.leo.framework.util.function.CallTask;
import cn.acyou.leo.framework.util.function.Task;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.connection.RedisZSetCommands;
import org.springframework.data.redis.connection.SortParameters;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.core.query.SortQuery;
import org.springframework.data.redis.core.query.SortQueryBuilder;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.time.Duration;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

/**
 * Redis 命令参考
 * http://doc.redisfans.com/
 *
 * @author fangyou
 * @version [1.0.0, 2021-08-25 13:50]
 */
@Component
public class RedisUtils {
    private static final Logger log = LoggerFactory.getLogger(RedisUtils.class);
    /**
     * 默认锁 前缀标识
     */
    private static final String LOCK_KEY_PREFIX = "REDIS_LOCK:";
    /**
     * 默认锁 Loop等待时间 120S
     */
    public static final int DEFAULT_LOCK_WAIT_TIME_OUT = 2 * 60 * 1000;
    /**
     * 默认锁 超时时间 60S
     */
    public static final int DEFAULT_LOCK_TIME_OUT = 60 * 1000;
    /**
     * 默认 getAndCache 超时时间 {@link #getAndCache(String, Function)}
     */
    private static final int DEFAULT_CACHE_SECONDS = 60;
    @Autowired(required = false)
    private StringRedisTemplate redisTemplate;
    @Autowired(required = false)
    private RedisTemplate redisObjTemplate;

    //私有化构造方法，无法通过new创建。而不影响Spring通过反射创建Bean
    private RedisUtils() {
        log.info("RedisUtils 初始化完成。");
    }

    /**
     * ZSet 类型操作
     */
    public ZSetOperations opsForZset() {
        return redisTemplate.opsForZSet();
    }

    /**
     * String 类型操作
     */
    public ValueOperations opsForValue() {
        return redisTemplate.opsForValue();
    }

    /**
     * Hash 类型操作
     */
    public HashOperations opsForHash() {
        return redisTemplate.opsForHash();
    }

    /**
     * List 类型操作
     */
    public ListOperations opsForList() {
        return redisTemplate.opsForList();
    }

    /**
     * Set 类型操作
     */
    public SetOperations opsForSet() {
        return redisTemplate.opsForSet();
    }

    /**
     * Geo 类型操作 (经纬度)
     */
    public GeoOperations opsForGeo() {
        return redisTemplate.opsForGeo();
    }


    /**
     * 从当前数据库中随机返回(不删除)一个 key 。
     *
     * @return 当数据库不为空时，返回一个 key 。
     * 当数据库为空时，返回 nil 。
     */
    public String randomKey() {
        return redisTemplate.randomKey();
    }

    /**
     * 统计存在的键
     *
     * @param keys 键
     * @return 存在的键的数量
     */
    public Long countExistingKeys(Collection keys) {
        return redisTemplate.countExistingKeys(keys);
    }

    /**
     * 删除
     *
     * @param keys 键
     * @return 删除的数量
     */
    public Long delete(Collection keys) {
        return redisTemplate.delete(keys);
    }

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

    /**
     * 包含键
     *
     * @param key 键
     * @return 是/否
     */
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 为键设置过期时间
     *
     * @param key     关键
     * @param timeout 超时
     * @return 成功/失败
     */
    public Boolean expire(String key, Duration timeout) {
        return redisTemplate.expire(key, timeout);
    }

    /**
     * 为键设置过期时间
     *
     * @param key     关键
     * @param timeout 时间
     * @param unit    单位
     * @return 成功/失败
     */
    public Boolean expire(String key, long timeout, TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 为键设置过期时间
     *
     * @param key  关键
     * @param date 日期
     * @return 成功/失败
     */
    public Boolean expireAt(String key, Date date) {
        return redisTemplate.expireAt(key, date);
    }

    /**
     * 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
     *
     * @param key 关键
     * @return 当 key 不存在时，返回 -2 。
     * 当 key 存在但没有设置剩余生存时间时，返回 -1 。
     * 否则，以秒为单位，返回 key 的剩余生存时间。
     */
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key);
    }

    /**
     * 返回给定 key 的剩余生存时间(TTL, time to live)。
     *
     * @param key  关键
     * @param unit 单位
     * @return 过期时间
     */
    public Long getExpire(String key, TimeUnit unit) {
        return redisTemplate.getExpire(key, unit);
    }

    /**
     * 查找所有符合给定模式 pattern 的 key 。
     * 
     * KEYS * 匹配数据库中所有 key 。
     * KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
     * KEYS h*llo 匹配 hllo 和 heeeeello 等。
     * KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。
     * 特殊符号用 \ 隔开
     * 
     *
     * @param pattern 模式
     * @return 符合给定模式的 key 列表。
     */
    public Set keys(String pattern) {
        return redisTemplate.keys(pattern);
    }

    /**
     * 移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )。
     *
     * @param key 关键
     * @return 
当生存时间移除成功时，返回 1 .
     * 
如果 key 不存在或 key 没有设置生存时间，返回 0 。
     */
    public Boolean persist(String key) {
        return redisTemplate.persist(key);
    }


    /**
     * 将 key 改名为 newkey 。
     * 当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。
     * 当 newkey 已经存在时， RENAME 命令将覆盖旧值。
     * 

     * 改名成功时提示 OK ，失败时候返回一个错误。
     *
     * @param oldKey 旧的关键
     * @param newKey 新的密钥
     */
    public void rename(String oldKey, String newKey) {
        redisTemplate.rename(oldKey, newKey);
    }

    /**
     * 当且仅当 newkey 不存在时，将 key 改名为 newkey 。
     *
     * @param oldKey 旧的关键
     * @param newKey 新的密钥
     * @return 修改成功时，返回 1 。
     * 如果 newkey 已经存在，返回 0 。
     */
    public Boolean renameIfAbsent(String oldKey, String newKey) {
        return redisTemplate.renameIfAbsent(oldKey, newKey);
    }


    /**
     * 排序
     *
     * @param key      关键
     * @param order    排序
     * @param pageNum  页码
     * @param pageSize 页面大小
     * @return 元素
     */
    public List sort(String key, SortParameters.Order order, long pageNum, long pageSize) {
        long offset = (pageNum - 1) * pageSize;
        SortQuery sortQuery = SortQueryBuilder.sort(key).order(order).limit(offset, pageSize).build();
        return redisTemplate.sort(sortQuery);
    }

    /**
     * 返回 key 所储存的值的类型。
     *
     * @param key 关键
     * @return 类型
     */
    public DataType type(String key) {
        return redisTemplate.type(key);
    }

    /**
     * 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
     * 

     * 如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。
     *
     * @param key   键
     * @param value 值
     * @return 追加 value 之后， key 中字符串的长度。
     */
    public Integer append(String key, String value) {
        return redisTemplate.opsForValue().append(key, value);
    }

    /**
     * 将 key 中储存的数字值减一。
     * 

     * 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
     *
     * @param key 关键
     * @return 执行 DECR 命令之后 key 的值。
     */
    public Long decrement(String key) {
        return redisTemplate.opsForValue().decrement(key);
    }

    /**
     * 将 key 所储存的值减去减量 decrement 。
     *
     * @param key  关键
     * @param deal 减量
     * @return 减去 decrement 之后， key 的值。
     */
    public Long decrement(String key, long deal) {
        return redisTemplate.opsForValue().decrement(key, deal);
    }

    /**
     * 将 key 中储存的数字值增一。
     * 

     * 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
     *
     * @param key 关键
     * @return 执行 INCR 命令之后 key 的值。
     */
    public Long increment(String key) {
        return redisTemplate.opsForValue().increment(key);
    }

    /**
     * 将 key 所储存的值加上增量 increment 。
     * 

     * 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCRBY 命令。
     *
     * @param key  键
     * @param deal 增量
     * @return 加上 increment 之后， key 的值。
     */
    public Long increment(String key, long deal) {
        return redisTemplate.opsForValue().increment(key, deal);
    }
    /**
     * 自增 / 自减 并在初始时设置过期时间
     * 保证原子性：初始化值为1的时候必设置过期时间。
     * @param key   key
     * @param delta 1自增1 -1减少1
     * @param timeOut 超时时间（单位秒）
     * @return 执行 INCR 命令之后 key 的值。
     */
    public Long increment(String key, long delta, long timeOut) {
        SessionCallback sessionCallback = new SessionCallback() {
            @Override
            public Long execute(RedisOperations operations) throws DataAccessException {
                operations.multi();
                redisTemplate.opsForValue().increment(key, delta);
                List exec = operations.exec();
                Long incValue = (Long) exec.get(0);
                if (incValue != null && incValue == 1){
                    redisTemplate.expire(key, timeOut, TimeUnit.SECONDS);
                }
                return incValue;
            }
        };
        return redisTemplate.execute(sessionCallback);
    }

    /**
     * 返回 key 所关联的字符串值。
     *
     * @param key 关键
     * @return 当 key 不存在时，返回 nil ，否则，返回 key 的值。
     * 如果 key 不是字符串类型，那么返回一个错误。
     */
    public String get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 返回 key 所关联的 Object 值。
     *
     * @param key 关键
     * @return 当 key 不存在时，返回 nil ，否则，返回 key 的值。
     * 如果 key 不是字符串类型，那么返回一个错误。
     */
    @SuppressWarnings("unchecked")
    public  T getObject(String key) {
        return (T) redisObjTemplate.opsForValue().get(key);
    }

    /**
     * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
     *
     * @param key   键
     * @param value 值
     * @return 返回给定 key 的旧值。
     */
    public String getAndSet(String key, String value) {
        return redisTemplate.opsForValue().getAndSet(key, value);
    }

    /**
     * 返回所有(一个或多个)给定 key 的值。
     *
     * @param keys 键
     * @return 一个包含所有给定 key 的值的列表。
     */
    public List multiGet(Collection keys) {
        return redisTemplate.opsForValue().multiGet(keys);
    }

    /**
     * 同时设置一个或多个 key-value 对。
     *
     * @param keyValues 键值
     */
    public void multiSet(Map keyValues) {
        redisTemplate.opsForValue().multiSet(keyValues);
    }

    /**
     * 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。
     *
     * @param keyValues 键值
     * @return 成功/失败
     */
    public Boolean multiSetIfAbsent(Map keyValues) {
        return redisTemplate.opsForValue().multiSetIfAbsent(keyValues);
    }

    /**
     * 将字符串值 value 关联到 key 。
     * 

     * 如果 key 已经持有其他值， SET 就覆写旧值，无视类型。
     * 

     * 对于某个原本带有生存时间（TTL）的键来说， 当 SET 命令成功在这个键上执行时， 这个键原有的 TTL 将被清除。
     *
     * @param key   关键
     * @param value 价值
     */
    public void set(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 将 Object 值 value 关联到 key 。
     * 

     * 如果 key 已经持有其他值， SET 就覆写旧值，无视类型。
     * 

     * 对于某个原本带有生存时间（TTL）的键来说， 当 SET 命令成功在这个键上执行时， 这个键原有的 TTL 将被清除。
     *
     * @param key   关键
     * @param value 价值
     */
    public void setObject(String key, Object value) {
        redisObjTemplate.opsForValue().set(key, value);
    }

    /**
     * 将值 value 关联到 key ，并设置 key 的生存时间。
     *
     * @param key     键
     * @param value   值
     * @param timeout 超时
     * @param unit    单位
     */
    public void set(String key, String value, long timeout, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, timeout, unit);
    }

    /**
     * 将 key 的值设为 value ，当且仅当 key 不存在。
     *
     * @param key   关键
     * @param value 价值
     */
    public Boolean setIfAbsent(String key, String value) {
        return redisTemplate.opsForValue().setIfAbsent(key, value);
    }

    /**
     * 将 key 的值设为 value ，当且仅当 key 不存在。并设置 key 的生存时间。
     *
     * @param key     关键
     * @param value   价值
     * @param timeout 超时
     * @param unit    单位
     */
    public Boolean setIfAbsent(String key, String value, long timeout, TimeUnit unit) {
        return redisTemplate.opsForValue().setIfAbsent(key, value, timeout, unit);
    }

    /**
     * 如果存在设置
     *
     * @param key   关键
     * @param value 价值
     */
    public Boolean setIfPresent(String key, String value) {
        return redisTemplate.opsForValue().setIfPresent(key, value);
    }

    /**
     * 如果存在设置，并设置 key 的生存时间。
     *
     * @param key     关键
     * @param value   价值
     * @param timeout 超时
     * @param unit    单位
     */
    public Boolean setIfPresent(String key, String value, long timeout, TimeUnit unit) {
        return redisTemplate.opsForValue().setIfPresent(key, value, timeout, unit);
    }

    /**
     * 获取值的长度：STRLEN
     *
     * @param key 关键
     * @return 值的长度
     */
    public Long size(String key) {
        return redisTemplate.opsForValue().size(key);
    }

    /*
     * ——————————————————————————Hash——————————————————————————————
     */


    /**
     * 散列的大小
     *
     * @param key 关键
     * @return 所有hash键的数量
     */
    public Long hashSize(String key) {
        return redisTemplate.opsForHash().size(key);
    }

    /**
     * 散列删除
     *
     * @param key      关键
     * @param hashKeys 散列键
     * @return 已删除的数量
     */
    public Long hashDelete(String key, Object... hashKeys) {
        return redisTemplate.opsForHash().delete(key, hashKeys);
    }

    /**
     * 散列有关键
     *
     * @param key      关键
     * @param hashKeys 散列键
     * @return 是/否
     */
    public Boolean hashHasKey(String key, Object hashKeys) {
        return redisTemplate.opsForHash().hasKey(key, hashKeys);
    }

    /**
     * 哈希得到
     *
     * @param key      关键
     * @param hashKeys 散列键
     * @return 哈希值
     */
    public Object hashGet(String key, Object hashKeys) {
        return redisTemplate.opsForHash().get(key, hashKeys);
    }

    /**
     * 散列多得到
     *
     * @param key      关键
     * @param hashKeys 散列键
     * @return 哈希值列表
     */
    public List