• Home
• top.isopen.commons
• commons-springboot
• 1.2.7
• source code
• RedisHelper.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.

top.isopen.commons.springboot.helper.RedisHelper Maven / Gradle / Ivy

package top.isopen.commons.springboot.helper;

import com.alibaba.fastjson.JSON;
import org.springframework.data.redis.RedisSystemException;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.connection.ReturnType;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.data.redis.core.types.Expiration;
import top.isopen.commons.logging.Log;
import top.isopen.commons.logging.LogFactory;
import top.isopen.commons.springboot.enums.BaseErrorEnum;

import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * Redis 工具类
 *
 * @author TimeChaser
 * @version 1.0
 * @since 2023/7/7 17:36
 */
@SuppressWarnings("unused")
public class RedisHelper {

    /**
     * 分布式锁默认（最大）存活时长
     */
    public final long DEFAULT_LOCK_TIMEOUT = 3;
    /**
     * DEFAULT_LOCK_TIMEOUT的单位
     */
    public final TimeUnit DEFAULT_TIMEOUT_UNIT = TimeUnit.SECONDS;
    private final Log log = LogFactory.getLog(RedisHelper.class);

    /**
     * 使用 StringRedisTemplate（其是 RedisTemplate 的定制化升级）
     */
    private final RedisTemplate redisTemplate;
    /**
     * lua 脚本, 保证 释放锁脚本 的原子性（以避免, 并发场景下, 释放了别人的锁）
     */
    private final String RELEASE_LOCK_LUA;

    {
        // 不论 lua 中 0 是否代表失败; 对于 java 的 Boolean 而言, 返回 0, 则会被解析为 false
        RELEASE_LOCK_LUA = "if redis.call('get',KEYS[1]) == ARGV[1] " + "then " + "    return redis.call('del',KEYS[1]) " + "else " + "    return 0 " + "end ";
    }

    public RedisHelper(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    // ====================== key 相关操作 ======================

    /**
     * 根据 key, 删除 redis 中的对应 key-value
     * 

     * 注：若删除失败, 则返回 false。
     * 

     * 若 redis 中，不存在该 key, 那么返回的也是 false。
     * 所以，不能因为返回了 false,就认为 redis 中一定还存
     * 在该 key 对应的 key-value。
     *
     * @param key 要删除的 key
     * @return 删除是否成功
     * @since 2020/3/7 17:15:02
     */
    public boolean delete(String key) {
        Boolean result = redisTemplate.delete(key);
        if (log.isDebugEnabled()) {
            log.debug("delete(...) => key -> {}", key);
            log.debug("delete(...) => result -> {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 根据 keys, 批量删除 key-value
     * 

     * 注：若 redis 中，不存在对应的 key, 那么计数不会加 1, 即:
     * redis 中存在的 key-value 里，有名为 a1、a2 的 key，
     * 删除时，传的集合是 a1、a2、a3，那么返回结果为 2。
     *
     * @param keys 要删除的 key 集合
     * @return 删除了的 key-value 个数
     * @since 2020/3/7 17:48:04
     */
    public long delete(Collection keys) {
        Long count = redisTemplate.delete(keys);
        if (log.isDebugEnabled()) {
            log.debug("delete(...) => keys -> {}", keys);
            log.debug("delete(...) => count -> {}", count);
        }
        if (count == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return count;
    }

    /**
     * 将 key 对应的 value 值进行序列化，并返回序列化后的 value 值。
     * 

     * 注：若不存在对应的 key, 则返回 null。
     * 注：dump 时，并不会删除 redis 中的对应 key-value。
     * 注：dump 功能与 restore 相反。
     *
     * @param key 要序列化的 value 的 key
     * @return 序列化后的 value 值
     * @since 2020/3/8 11:34:13
     */
    public byte[] dump(String key) {
        byte[] result = redisTemplate.dump(key);
        if (log.isDebugEnabled()) {
            log.debug("dump(...) => key -> {}", key);
            log.debug("dump(...) => result -> {}", Arrays.toString(result));
        }
        return result;
    }

    /**
     * 将给定的 value 值，反序列化到 redis 中, 形成新的 key-value。
     *
     * @param key        value 对应的 key
     * @param value      要反序列的 value 值。
     *                   注：这个值可以由 {@link #dump(String)} 获得
     * @param timeToLive 反序列化后的 key-value 的存活时长
     * @param unit       timeToLive 的单位
     * @throws RedisSystemException 如果 redis 中已存在同样的 key 时，抛出此异常
     * @since 2020/3/8 11:36:45
     */
    public void restore(String key, byte[] value, long timeToLive, TimeUnit unit) {
        restore(key, value, timeToLive, unit, false);
    }

    /**
     * 将给定的 value 值，反序列化到 redis 中, 形成新的 key-value。
     *
     * @param key        value 对应的 key
     * @param value      要反序列的 value 值。
     *                   注：这个值可以由 {@link #dump(String)} 获得
     * @param timeToLive 反序列化后的 key-value 的存活时长
     * @param unit       timeToLive 的单位
     * @param replace    若 redis 中已经存在了相同的 key, 是否替代原来的 key-value
     * @throws RedisSystemException 如果 redis 中已存在同样的key, 且 replace 为 false 时，抛出此异常
     * @since 2020/3/8 11:36:45
     */
    public void restore(String key, byte[] value, long timeToLive, TimeUnit unit, boolean replace) {
        if (log.isDebugEnabled()) {
            log.debug("restore(...) => key -> {}, value -> {}, timeToLive -> {}, unit -> {}, replace -> {}", key, value, timeToLive, unit, replace);
        }
        redisTemplate.restore(key, value, timeToLive, unit, replace);
    }

    /**
     * redis 中是否存在,指定 key 的 key-value
     *
     * @param key 指定的 key
     * @return 是否存在对应的 key-value
     * @since 2020/3/8 12:16:46
     */
    public boolean hasKey(String key) {
        Boolean result = redisTemplate.hasKey(key);
        if (log.isDebugEnabled()) {
            log.debug("hasKey(...) => key -> {}", key);
            log.debug("hasKey(...) => result -> {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 给指定的 key 对应的 key-value 设置：多久过时
     * 

     * 注：过时后，redis 会自动删除对应的 key-value。
     * 注：若 key 不存在，那么也会返回 false。
     *
     * @param key        指定的 key
     * @param timeToLive 过时时间
     * @param unit       timeout 的单位
     * @return 操作是否成功
     * @since 2020/3/8 12:18:58
     */
    public boolean expire(String key, long timeToLive, TimeUnit unit) {
        Boolean result = redisTemplate.expire(key, timeToLive, unit);
        if (log.isDebugEnabled()) {
            log.debug("expire(...) => key -> {}, timeToLive -> {}, unit -> {}", key, timeToLive, unit);
            log.debug("expire(...) => result -> {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 给指定的 key 对应的 key-value 设置：什么时候过时
     * 

     * 注：过时后，redis 会自动删除对应的 key-value。
     * 注：若 key 不存在，那么也会返回 false。
     *
     * @param key  指定的 key
     * @param date 啥时候过时
     * @return 操作是否成功
     * @since 2020/3/8 12:19:29
     */
    public boolean expireAt(String key, Date date) {
        Boolean result = redisTemplate.expireAt(key, date);
        if (log.isDebugEnabled()) {
            log.debug("expireAt(...) => key -> {}, date -> {}", key, date);
            log.debug("expireAt(...) => result -> {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 找到所有匹配 pattern 的 key,并返回该 key 的集合.
     * 

     * 提示：若 redis 中键值对较多，此方法耗时相对较长，慎用！慎用！慎用！
     *
     * @param pattern 匹配模板。
     *                注：常用的通配符有：
     *                ?    有且只有一个;
     *                *     >=0 哥;
     * @return 匹配 pattern 的 key 的集合。 可能为 null。
     * @since 2020/3/8 12:38:38
     */
    public Set keys(String pattern) {
        Set keys = redisTemplate.keys(pattern);
        if (log.isDebugEnabled()) {
            log.debug("keys(...) => pattern -> {}", pattern);
            log.debug("keys(...) => keys -> {}", keys);
        }
        return keys;
    }

    /**
     * 将当前数据库中的 key 对应的 key-value,移动到对应位置的数据库中。
     * 

     * 注：单机版的 redis,默认将存储分为 16 个 db, index 为 0 到 15。
     * 注：同一个 db 下，key 唯一； 但是在不同 db 中，key 可以相同。
     * 注：若目标 db 下，已存在相同的 key, 那么 move 会失败，返回 false。
     *
     * @param key     定位要移动的 key-value 的 key
     * @param dbIndex 要移动到哪个 db
     * @return 移动是否成功。
     * 注：若目标 db 下，已存在相同的 key, 那么 move 会失败，返回 false。
     * @since 2020/3/8 13:01:00
     */
    public boolean move(String key, int dbIndex) {
        Boolean result = redisTemplate.move(key, dbIndex);
        if (log.isDebugEnabled()) {
            log.debug("move(...) => key  -> {}, dbIndex -> {}", key, dbIndex);
            log.debug("move(...) => result -> {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 移除 key 对应的 key-value 的过期时间, 使该 key-value 一直存在
     * 

     * 注：若 key 对应的 key-value，本身就是一直存在（无过期时间的）， 那么 persist 方法会返回 false;
     * 若没有 key 对应的 key-value 存在，本那么 persist 方法会返回 false;
     *
     * @param key 定位 key-value 的 key
     * @return 操作是否成功
     * @since 2020/3/8 13:10:02
     */
    public boolean persist(String key) {
        Boolean result = redisTemplate.persist(key);
        if (log.isDebugEnabled()) {
            log.debug("persist(...) => key -> {}", key);
            log.debug("persist(...) => result -> {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 获取 key 对应的 key-value 的过期时间
     * 

     * 注：若 key-value 永不过期， 那么返回的为 -1。
     * 注：若不存在 key 对应的 key-value， 那么返回的为 -2
     * 注：若存在零碎时间不足 1 SECONDS，则（大体上）四舍五入到 SECONDS 级别。
     *
     * @param key 定位 key-value 的 key
     * @return 过期时间（单位s）
     * @since 2020/3/8 13:17:35
     */
    public long getExpire(String key) {
        return getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 获取 key 对应的 key-value 的过期时间
     * 

     * 注：若 key-value 永不过期， 那么返回的为 -1。
     * 注：若不存在 key 对应的 key-value，那么返回的为 -2
     * 注：若存在零碎时间不足 1 unit，则（大体上）四舍五入到 unit 别。
     *
     * @param key 定位 key-value 的 key
     * @return 过期时间（单位 unit）
     * @since 2020/3/8 13:17:35
     */
    public long getExpire(String key, TimeUnit unit) {
        Long result = redisTemplate.getExpire(key, unit);
        if (log.isDebugEnabled()) {
            log.debug("getExpire(...) => key -> {}, unit is -> {}", key, unit);
            log.debug("getExpire(...) => result ->  {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 从 redis 的所有 key 中，随机获取一个 key
     * 

     * 注：若 redis 中不存在任何 key-value，那么这里返回 null
     *
     * @return 随机获取到的一个 key
     * @since 2020/3/8 14:11:43
     */
    public String randomKey() {
        String result = redisTemplate.randomKey();
        if (log.isDebugEnabled()) {
            log.debug("randomKey(...) => result -> {}", result);
        }
        return result;
    }

    /**
     * 重命名对应的 oldKey 为新的 newKey
     * 

     * 注：若 oldKey 不存在， 则会抛出异常.
     * 注：若 redis 中已存在与 newKey 一样的 key,
     * 那么原 key-value 会被丢弃，
     * 只留下新的 key，以及原来的 value
     * 示例说明：假设 redis 中已有（keyAlpha, valueAlpha）和（keyBeta, valueBeat）,
     * 在使用 rename（keyAlpha, keyBeta）替换后, redis 中只会剩下（keyBeta, valueAlpha）
     *
     * @param oldKey 旧的 key
     * @param newKey 新的 key
     * @throws RedisSystemException 若 oldKey 不存在时， 抛出此异常
     * @since 2020/3/8 14:14:17
     */
    public void rename(String oldKey, String newKey) {
        if (log.isDebugEnabled()) {
            log.debug("rename(...) => oldKey -> {}, newKey -> {}", oldKey, newKey);
        }
        redisTemplate.rename(oldKey, newKey);
    }

    /**
     * 当 redis 中不存在 newKey 时, 重命名对应的 oldKey 为新的 newKey。
     * 否者不进行重命名操作。
     * 

     * 注：若 oldKey 不存在， 则会抛出异常.
     *
     * @param oldKey 旧的 key
     * @param newKey 新的 key
     * @throws RedisSystemException 若 oldKey 不存在时， 抛出此异常
     * @since 2020/3/8 14:14:17
     */
    public boolean renameIfAbsent(String oldKey, String newKey) {
        Boolean result = redisTemplate.renameIfAbsent(oldKey, newKey);
        if (log.isDebugEnabled()) {
            log.debug("renameIfAbsent(...) => oldKey -> {}, newKey -> {}", oldKey, newKey);
            log.debug("renameIfAbsent(...) => result -> {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 获取 key 对应的 value 的数据类型
     * 

     * 注：若 redis 中不存在该 key 对应的 key-value， 那么这里返回 NONE。
     *
     * @param key 用于定位的 key
     * @return key 对应的 value 的数据类型的枚举
     * @since 2020/3/8 14:40:16
     */
    public DataType type(String key) {
        DataType result = redisTemplate.type(key);
        if (log.isDebugEnabled()) {
            log.debug("type(...) => key -> {}", key);
            log.debug("type(...) => result -> {}", result);
        }
        return result;
    }

    // ====================== string 相关操作 ======================

    /**
     * 设置 key-value
     * 

     * 注：若已存在相同的 key, 那么原来的 key-value 会被丢弃。
     *
     * @param key   key
     * @param value key 对应的 value
     * @since 2020/3/8 15:40:59
     */
    public void set(String key, Object value) {
        if (log.isDebugEnabled()) {
            log.debug("set(...) => key -> {}, value -> {}", key, value);
        }
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 处理 redis 中 key 对应的 value 值, 将第 offset 位的值, 设置为 1 或 0。
     * 

     * 说明：在 redis 中，存储的字符串都是以二级制的进行存在的；如存储的 key-value 里，值为 abc，实际上，
     * 在 redis 里面存储的是 011000010110001001100011，前 8 位对应 a，中间 8 位对应 b，后面 8 位对应 c。
     * 示例：这里如果 setBit(key, 6, true) 的话，就是将索引位置 6 的那个数，设置值为 1，值就变成
     * 了 011000110110001001100011
     * 追注：offset 即 index，从 0 开始。
     * 

     * 注：参数 value 为 true，则设置为 1；参数 value 为 false，则设置为 0。
     * 

     * 注：若 redis 中不存在对应的 key，那么会自动创建新的。
     * 注：offset 可以超过 value 在二进制下的索引长度。
     *
     * @param key    定位 value 的 key
     * @param offset 要改变的 bit 的索引
     * @param value  改为 1 或 0，true - 改为 1，false - 改为 0
     * @return set 是否成功
     * @since 2020/3/8 16:30:37
     */
    public boolean setBit(String key, long offset, boolean value) {
        Boolean result = redisTemplate.opsForValue().setBit(key, offset, value);
        if (log.isDebugEnabled()) {
            log.debug("setBit(...) => key -> {}, offset -> {}, value -> {}", key, offset, value);
            log.debug("setBit(...) => result -> {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 设置 key-value
     * 

     * 注：若已存在相同的 key，那么原来的 key-value 会被丢弃
     * 

     * 注：原子操作
     *
     * @param key        key
     * @param value      key 对应的 value
     * @param timeToLive 过时时长
     * @param unit       timeToLive 的单位
     * @since 2020/3/8 15:40:59
     */
    public void setEx(String key, Object value, long timeToLive, TimeUnit unit) {
        if (log.isDebugEnabled()) {
            log.debug("setEx(...) => key -> {}, value -> {}, timeToLive -> {}, unit -> {}", key, value, timeToLive, unit);
        }
        redisTemplate.opsForValue().set(key, value, timeToLive, unit);
    }

    /**
     * 若不存在 key 时，向 redis 中添加 key-value, 返回成功/失败。
     * 若存在，则不作任何操作，返回 false。
     *
     * @param key   key
     * @param value key 对应的 value
     * @return set 是否成功
     * @since 2020/3/8 16:51:36
     */
    public boolean setIfAbsent(String key, Object value) {
        Boolean result = redisTemplate.opsForValue().setIfAbsent(key, value);
        if (log.isDebugEnabled()) {
            log.debug("setIfAbsent(...) => key -> {}, value -> {}", key, value);
            log.debug("setIfAbsent(...) => result -> {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 若不存在 key 时, 向 redis 中添加一个（具有超时时长的）key-value, 返回成功/失败。
     * 若存在，则不作任何操作，返回 false。
     *
     * @param key        key
     * @param value      key 对应的 value
     * @param timeToLive 超时时长
     * @param unit       timeToLive 的单位
     * @return set 是否成功
     * @since 2020/3/8 16:51:36
     */
    public boolean setIfAbsent(String key, Object value, long timeToLive, TimeUnit unit) {
        Boolean result = redisTemplate.opsForValue().setIfAbsent(key, value, timeToLive, unit);
        if (log.isDebugEnabled()) {
            log.debug("setIfAbsent(...) => key -> {}, value -> {}, timeToLive -> {}, unit -> {}", key, value, timeToLive, unit);
            log.debug("setIfAbsent(...) => result -> {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 从（redis 中 key 对应的）value 的 offset 位置起（包含该位置），用 replaceValue 替换对应长度的值。
     * 

     * 举例说明：
     * 1. 假设 redis 中存在 key-value("ds", "0123456789"); 调
     * 用 setRange("ds", "abcdefghijk", 3)后，redis 中该 value 值就变为了 [012abcdefghijk]
     * 

     * 2. 假设 redis 中存在 key-value("jd", "0123456789"); 调
     * 用 setRange("jd", "xyz", 3)后，redis 中该 value 值就变为了 [012xyz6789]
     * 

     * 3. 假设 redis 中存在 key-value("ey", "0123456789"); 调
     * 用 setRange("ey", "qwer", 15)后，redis 中该 value 值就变为了 [0123456789     qwer]
     * 注：case3 比较特殊，offset 超过了原 value 的长度了。中间就会有一些空格来填充，但是如果在程序
     * 中直接输出的话，中间那部分空格可能会出现乱码。
     *
     * @param key          定位 key-value 的 key
     * @param replaceValue 要替换的值
     * @param offset       起始位置
     * @since 2020/3/8 17:04:31
     */
    public void setRange(String key, String replaceValue, long offset) {
        if (log.isDebugEnabled()) {
            log.debug("setRange(...) => key -> {}, replaceValue -> {}, offset -> {}", key, replaceValue, offset);
        }
        redisTemplate.opsForValue().set(key, replaceValue, offset);
    }

    /**
     * 获取到 key 对应的 value 的长度。
     * 

     * 注：长度等于 {@link String#length}。
     * 注：若 redis 中不存在对应的 key-value，则返回值为 0.
     *
     * @param key 定位 value 的 key
     * @return value 的长度
     * @since 2020/3/8 17:14:30
     */
    public long size(String key) {
        Long result = redisTemplate.opsForValue().size(key);
        if (log.isDebugEnabled()) {
            log.debug("size(...) => key -> {}", key);
            log.debug("size(...) => result -> {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 批量设置 key-value
     * 

     * 注：若存在相同的 key, 则原来的 key-value会 被丢弃。
     *
     * @param maps key-value 集
     * @since 2020/3/8 17:21:19
     */
    public void multiSet(Map maps) {
        if (log.isDebugEnabled()) {
            log.debug("multiSet(...) => maps -> {}", maps);
        }
        redisTemplate.opsForValue().multiSet(maps);
    }

    /**
     * 当 redis 中，不存在任何一个 keys 时，才批量设置 key-value，并返回成功/失败。
     * 否者，不进行任何操作，并返回 false。
     * 

     * 即：假设调用此方法时传入的参数 map 是这样的：{k1=v1, k2=v2, k3=v3}
     * 那么 redis 中，k1、k2、k3 都不存在时，才会批量设置 key-value；
     * 否则不会设置任何 key-value。
     * 

     * 注：若存在相同的 key，则原来的 key-value 会被丢弃。
     *
     * @param maps key-value 集
     * @return 操作是否成功
     * @since 2020/3/8 17:21:19
     */
    public boolean multiSetIfAbsent(Map maps) {
        Boolean result = redisTemplate.opsForValue().multiSetIfAbsent(maps);
        if (log.isDebugEnabled()) {
            log.debug("multiSetIfAbsent(...) => maps -> {}", maps);
            log.debug("multiSetIfAbsent(...) => result -> {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 增/减 整数
     * 

     * 注：负数则为减。
     * 

     * 注：若 key 对应的 value 值不支持增/减操作（即：value不是数字），那么会
     * 抛出 org.springframework.data.redis.RedisSystemException
     *
     * @param key       用于定位 value 的 key
     * @param increment 增加多少
     * @return 增加后的总值。
     * @throws RedisSystemException key 对应的 value 值不支持增/减操作时
     * @since 2020/3/8 17:45:51
     */
    public long incrBy(String key, long increment) {
        Long result = redisTemplate.opsForValue().increment(key, increment);
        if (log.isDebugEnabled()) {
            log.debug("incrBy(...) => key -> {}, increment -> {}", key, increment);
            log.debug("incrBy(...) => result -> {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 增/减 浮点数
     * 

     * 注：慎用浮点数，会有精度问题。
     * 

     * 如: 先 RedisHelper.StringOps.set("ds", "123");
     * 然后再 RedisUtil.StringOps.incrByFloat("ds", 100.6);
     * 就会看到精度问题。
     * 

     * 注：负数则为减。
     * 

     * 注：若 key 对应的 value 值不支持增/减操作（即：value不是数字），那么会
     * 抛出 org.springframework.data.redis.RedisSystemException
     *
     * @param key       用于定位value的key
     * @param increment 增加多少
     * @return 增加后的总值。
     * @throws RedisSystemException key对应的value值不支持增/减操作时
     * @since 2020/3/8 17:45:51
     */
    public double incrByFloat(String key, double increment) {
        Double result = redisTemplate.opsForValue().increment(key, increment);
        if (log.isDebugEnabled()) {
            log.debug("incrByFloat(...) => key -> {}, increment -> {}", key, increment);
            log.debug("incrByFloat(...) => result -> {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 追加值到末尾
     * 

     * 注: 当 redis 中原本不存在 key 时，那么（从效果上来看）此方法就等价于 {@link #set(String, Object)}
     *
     * @param key   定位 value 的 key
     * @param value 要追加的 value 值
     * @return 追加后，整个 value 的长度
     * @since 2020/3/8 17:59:21
     */
    public int append(String key, String value) {
        Integer result = redisTemplate.opsForValue().append(key, value);
        if (log.isDebugEnabled()) {
            log.debug("append(...) => key -> {}, value -> {}", key, value);
            log.debug("append(...) => result -> {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 根据 key，获取到对应的 value 值
     *
     * @param key key-value 对应的 key
     * @return 该 key 对应的值。
     * 注: 若 key 不存在， 则返回 null。
     * @since 2020/3/8 16:27:41
     */
    public Object get(String key) {
        Object result = redisTemplate.opsForValue().get(key);
        if (log.isDebugEnabled()) {
            log.debug("get(...) => key -> {}", key);
            log.debug("get(...) => result -> {} ", result);
        }
        return result;
    }

    /**
     * 对（key 对应的）value 进行截取, 截取范围为 [start, end]
     * 

     * 注：若 [start, end] 的范围不在 value 的范围中，那么返回的是空字符串 ""
     * 

     * 注：若 value 只有一部分在 [start, end] 的范围中，那么返回的是 value 对应部分的内容（即：不足的地方，并不会以空来填充）
     *
     * @param key   定位 value 的 key
     * @param start 起始位置（从0开始）
     * @param end   结尾位置（从0开始）
     * @return 截取后的字符串
     * @since 2020/3/8 18:08:45
     */
    public String getRange(String key, long start, long end) {
        String result = redisTemplate.opsForValue().get(key, start, end);
        if (log.isDebugEnabled()) {
            log.debug("getRange(...) => key -> {}", key);
            log.debug("getRange(...) => result -> {} ", result);
        }
        return result;
    }

    /**
     * 给指定 key 设置新的 value，并返回旧的 value
     * 

     * 注: 若 redis 中不存在 key，那么此操作仍然可以成功，不过返回的旧值是 null
     *
     * @param key      定位 value 的 key
     * @param newValue 要为该 key 设置的新的 value 值
     * @return 旧的 value 值
     * @since 2020/3/8 18:14:24
     */
    public Object getAndSet(String key, Object newValue) {
        Object oldValue = redisTemplate.opsForValue().getAndSet(key, newValue);
        if (log.isDebugEnabled()) {
            log.debug("getAndSet(...) => key -> {}, value -> {}", key, newValue);
            log.debug("getAndSet(...) => oldValue -> {}", oldValue);
        }
        return oldValue;
    }

    /**
     * 获取（key对应的）value 在二进制下，offset 位置的 bit 值。
     * 

     * 注：当 offset 的值在（二进制下的 value 的）索引范围外时，返回的也是 false。
     * 

     * 示例：
     * RedisHelper.StringOps.set("akey", "a");
     * 字符串 a，转换为二进制为 01100001
     * 那么 getBit("akey", 6) 获取到的结果为 false。
     *
     * @param key    定位 value 的 key
     * @param offset 定位 bit 的索引
     * @return offset 位置对应的 bit 的值（true - 1, false - 0）
     * @since 2020/3/8 18:21:10
     */
    public boolean getBit(String key, long offset) {
        Boolean result = redisTemplate.opsForValue().getBit(key, offset);
        if (log.isDebugEnabled()) {
            log.debug("getBit(...) => key -> {}, offset -> {}", key, offset);
            log.debug("getBit(...) => result -> {}", result);
        }
        if (result == null) {
            BaseErrorEnum.INVALID_REDIS_RESULT_ERROR.throwException();
        }
        return result;
    }

    /**
     * 批量获取 value 值
     * 

     * 注：若 redis 中，对应的 key 不存在，那么该 key 对应的返回的 value 值为 null
     *
     * @param keys key 集
     * @return value 值集合
     * @since 2020/3/8 18:26:33
     */
    public List