package com.hdkj.lt.utils.cache;

import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.dao.DataAccessException;
import org.springframework.data.geo.*;
import org.springframework.data.redis.connection.*;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;

import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @Description: redis基本操作，可扩展
 * @Author: wenhao
 * @Create: 2024/04/03 10:37
 * @Version: 1.0
 */
@Slf4j
@Component
@AllArgsConstructor
public class RedisRepository {

    /**
     * Spring Redis Template
     */
    private final RedisTemplate<String, Object> redisTemplate;

    // ===============================Common Start=================================

    /**
     * 获取链接工厂
     */
    public RedisConnectionFactory getConnectionFactory() {
        return this.redisTemplate.getConnectionFactory();
    }

    /**
     * 获取RedisTemplate对象
     */
    public RedisTemplate<String, Object> getRedisTemplate() {
        return redisTemplate;
    }

    /**
     * 指定缓存过期时间
     *
     * @param key      redis主键
     * @param time     过期时间
     * @param timeUnit 过期时间单位
     * @return
     */
    public Boolean expire(final String key, final long time, TimeUnit timeUnit) {
        if (time > 0) {
            return redisTemplate.expire(key, time, timeUnit);
        }
        return Boolean.TRUE;
    }

    /**
     * 指定缓存失效时间（默认单位：秒）
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(final String key, final long time) {
        return expire(key, time, TimeUnit.SECONDS);
    }

    /**
     * 添加到带有过期时间的缓存
     *
     * @param key   redis主键
     * @param value 值
     * @param time  过期时间(单位秒)
     */
    public void setExpire(final byte[] key, final byte[] value, final long time) {
        redisTemplate.execute((RedisCallback<Long>) connection -> {
            connection.setEx(key, time, value);
            return 1L;
        });
    }

    /**
     * 集合数量
     *
     * @return the long
     */
    public Long dbSize() {
        return redisTemplate.execute(RedisServerCommands::dbSize);
    }

    /**
     * 清空redis存储的数据
     *
     * @return the string
     */
    public Boolean flushDb() {
        return redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            connection.flushDb();
            return Boolean.TRUE;
        });
    }

    /**
     * 清空DB
     *
     * @param node redis节点
     */
    public void flushDb(RedisClusterNode node) {
        this.redisTemplate.opsForCluster().flushDb(node);
    }

    /**
     * 添加到带有过期时间的缓存
     *
     * @param key      redis主键
     * @param value    值
     * @param time     过期时间
     * @param timeUnit 过期时间单位
     */
    public void setExpire(final String key, final Object value, final long time, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, time, timeUnit);
    }

    public void setExpire(final String key, final Object value, final long time) {
        setExpire(key, value, time, TimeUnit.SECONDS);
    }

    public void setExpire(final String key, final Object value, final long time, final TimeUnit timeUnit, RedisSerializer<Object> valueSerializer) {
        byte[] rawKey = rawKey(key);
        byte[] rawValue = rawValue(value, valueSerializer);
        redisTemplate.execute(new RedisCallback<Object>() {
            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                potentiallyUsePsetEx(connection);
                return null;
            }

            public void potentiallyUsePsetEx(RedisConnection connection) {
                if (!TimeUnit.MILLISECONDS.equals(timeUnit) || !failsafeInvokePsetEx(connection)) {
                    connection.setEx(rawKey, TimeoutUtils.toSeconds(time, timeUnit), rawValue);
                }
            }

            private boolean failsafeInvokePsetEx(RedisConnection connection) {
                boolean failed = false;
                try {
                    connection.pSetEx(rawKey, time, rawValue);
                } catch (UnsupportedOperationException e) {
                    failed = true;
                }
                return !failed;
            }
        }, true);
    }

    /**
     * 一次性添加数组到带有过期时间的缓存，不用多次连接，节省开销
     *
     * @param keys   redis主键数组
     * @param values 值数组
     * @param time   过期时间(单位秒)
     */
    public void setExpire(final String[] keys, final Object[] values, final long time) {
        for (int i = 0; i < keys.length; i++) {
            redisTemplate.opsForValue().set(keys[i], values[i], time, TimeUnit.SECONDS);
        }
    }

    /**
     * 根据key获取过期时间
     *
     * @param key redis主键
     * @return 时间(秒) 返回0代表为永久有效
     */
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }
    // ===============================Common End=================================

    // ===============================String Start=================================

    /**
     * 一次性添加数组到没有过期时间的缓存，不用多次连接，节省开销
     *
     * @param keys   the keys
     * @param values the values
     */
    public void set(final String[] keys, final Object[] values) {
        for (int i = 0; i < keys.length; i++) {
            redisTemplate.opsForValue().set(keys[i], values[i]);
        }
    }

    /**
     * 添加到缓存
     *
     * @param key   the key
     * @param value the value
     */
    public void set(final String key, final Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 查询在以keyPatten的所有key
     *
     * @param keyPatten the key patten
     * @return the set
     */
    public Set<String> keys(final String keyPatten) {
        return redisTemplate.keys(keyPatten + "*");
    }

    /**
     * 根据key获取对象
     *
     * @param key the key
     * @return the byte[]
     */
    public byte[] get(final byte[] key) {
        return redisTemplate.execute((RedisCallback<byte[]>) connection -> connection.get(key));
    }

    /**
     * 根据key获取对象
     *
     * @param key the key
     * @return the string
     */
    public Object get(final String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 获取原来key键对应的值并重新赋新值。
     *
     * @param key
     * @param value
     * @return
     */
    public String getAndSet(final String key, String value) {
        String result = null;
        if (StringUtils.isEmpty(key)) {
            log.error("非法入参");
            return null;
        }
        try {
            Object object = redisTemplate.opsForValue().getAndSet(key, value);
            if (Objects.nonNull(object)) {
                result = object.toString();
            }
        } catch (Exception e) {
            log.error("redisTemplate操作异常", e);
        }
        return result;
    }

    /**
     * 根据key获取对象
     *
     * @param key             the key
     * @param valueSerializer 序列化
     * @return the string
     */
    public Object get(final String key, RedisSerializer<Object> valueSerializer) {
        byte[] rawKey = rawKey(key);
        return redisTemplate.execute(connection -> deserializeValue(connection.get(rawKey), valueSerializer), true);
    }
    // ===============================String End=================================

    // ===============================Hash Start=================================

    /**
     * Ops for hash operations.
     *
     * @return the hash operations
     */
    public HashOperations<String, String, Object> opsForHash() {
        return redisTemplate.opsForHash();
    }

    /**
     * 对HashMap操作
     *
     * @param key       redis主键
     * @param hashKey   项
     * @param hashValue 值
     */
    public void putHashValue(String key, String hashKey, Object hashValue) {
        putHashValue(key, hashKey, hashValue, -1);
    }

    /**
     * 对HashMap操作，并设置过期时间
     *
     * @param key       redis主键
     * @param hashKey   项
     * @param hashValue 值
     * @param time      过期时间（秒），注意:如果已存在的hash表有时间，这里将会替换原有的时间
     */
    public void putHashValue(String key, String hashKey, Object hashValue, long time) {
        putHashValue(key, hashKey, hashValue, time, TimeUnit.SECONDS);
    }

    /**
     * 对HashMap操作，并设置过期时间
     *
     * @param key       redis主键
     * @param hashKey   项
     * @param hashValue 值
     * @param time      过期时间（秒），注意:如果已存在的hash表有时间，这里将会替换原有的时间
     * @param timeUnit  过期时间单位
     */
    public void putHashValue(String key, String hashKey, Object hashValue, long time, TimeUnit timeUnit) {
        opsForHash().put(key, hashKey, hashValue);
        if (time > 0) {
            expire(key, time, timeUnit);
        }
    }

    /**
     * 判断hash表中是否有该项的值
     *
     * @param key     redis主键
     * @param hashKey 项
     * @return true存在/false不存在
     */
    public Object hasHashKey(String key, String hashKey) {
        return opsForHash().hasKey(key, hashKey);
    }

    /**
     * 获取单个field对应的值
     *
     * @param key     the key
     * @param hashKey the hash key
     * @return the hash values
     */
    public Object getHashValues(String key, String hashKey) {
        return opsForHash().get(key, hashKey);
    }

    /**
     * 根据key值删除
     *
     * @param key      the key
     * @param hashKeys the hash keys
     */
    public void delHashValues(String key, Object... hashKeys) {
        opsForHash().delete(key, hashKeys);
    }

    /**
     * key只匹配map
     *
     * @param key the key
     * @return the hash value
     */
    public Map<String, Object> getHashValue(String key) {
        return opsForHash().entries(key);
    }

    /**
     * 批量添加
     *
     * @param key the key
     * @param map the map
     */
    public void putHashValues(String key, Map<String, Object> map) {
        putHashValues(key, map, -1);
    }

    /**
     * 批量添加，并设置过期时间
     *
     * @param key  redis主键
     * @param map  对应多个键值
     * @param time 过期时间
     */
    public void putHashValues(String key, Map<String, Object> map, long time) {
        putHashValues(key, map, time, TimeUnit.SECONDS);
    }

    /**
     * 批量添加，并设置过期时间
     *
     * @param key      redis主键
     * @param map      对应多个键值
     * @param time     过期时间
     * @param timeUnit 过期时间单位
     */
    public void putHashValues(String key, Map<String, Object> map, long time, TimeUnit timeUnit) {
        opsForHash().putAll(key, map);
        if (time > 0) {
            expire(key, time, timeUnit);
        }
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key     redis主键
     * @param hashKey 项
     * @param delta   要递增增几(正数)
     * @return
     */
    public long incrHash(String key, String hashKey, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return opsForHash().increment(key, hashKey, delta);
    }

    /**
     * hash递减
     *
     * @param key     redis主键
     * @param hashKey 项
     * @param delta   要递减几(正数)
     * @return
     */
    public double decrHash(String key, String hashKey, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return opsForHash().increment(key, hashKey, -delta);
    }
    // ===============================Hash End=================================

    // ===============================Set Start=================================

    /**
     * Ops for set operations.
     *
     * @return the set operations
     */
    public SetOperations<String, Object> opsForSet() {
        return redisTemplate.opsForSet();
    }

    /**
     * 根据key获取Set中的所有值
     *
     * @param key redis主键
     * @return
     */
    public Set<Object> getSetValues(String key) {
        return opsForSet().members(key);
    }

    /**
     * 根据value从一个set中查询，是否存在
     *
     * @param key
     * @param value
     * @return
     */
    public Boolean hasSetValue(String key, Object value) {
        return opsForSet().isMember(key, value);
    }

    /**
     * 将数据放入set缓存
     *
     * @param key    redis主键
     * @param values 值，可以是多个
     * @return 成功个数
     */
    public long addSet(String key, Object... values) {
        return addSet(key, -1, values);
    }

    /**
     * 将数据放入set缓存，并设置过期时间
     *
     * @param key    redis主键
     * @param time   过期时间（秒）
     * @param values 值，可以是多个
     * @return 成功个数
     */
    public long addSet(String key, long time, Object... values) {
        return addSet(key, time, TimeUnit.SECONDS, values);
    }

    /**
     * 将数据放入set缓存，并设置过期时间
     *
     * @param key      redis主键
     * @param time     过期时间
     * @param timeUnit 过期时间单位
     * @param values   值，可以是多个
     * @return 成功个数
     */
    public long addSet(String key, long time, TimeUnit timeUnit, Object... values) {
        Long count = opsForSet().add(key, values);
        if (time > 0) {
            expire(key, time, timeUnit);
        }
        return count;
    }

    /**
     * 获取set缓存的长度
     *
     * @param key redis主键
     * @return
     */
    public Long getSetSize(String key) {
        return opsForSet().size(key);
    }

    /**
     * 移除值为value的
     *
     * @param key    redis主键
     * @param values 值，可以是多个
     * @return 移除的个数
     */
    public Long setRemove(String key, Object... values) {
        return opsForSet().remove(key, values);
    }
    // ===============================Set End=================================

    // ===============================List Start=================================

    /**
     * 判断某个主键是否存在
     *
     * @param key the key
     * @return the boolean
     */
    public Boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 删除key
     *
     * @param keys the keys
     * @return the long
     */
    public Boolean del(final String... keys) {
        Boolean result = Boolean.FALSE;
        if (ArrayUtils.isNotEmpty(keys)) {
            for (String key : keys) {
                result = redisTemplate.delete(key);
            }
        }
        return result;
    }

    /**
     * 对某个主键对应的值递增，value值必须是全数字的字符串
     *
     * @param key the key
     * @return the long
     */
    public Long incr(final String key) {
        return redisTemplate.opsForValue().increment(key);
    }

    /**
     * 对某个主键对应的值递增，value值必须是全数字的字符串
     *
     * @param key   the key
     * @param delta 要递增几(大于0)
     * @return the long
     */
    public Long incr(final String key, final long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 对某个主键对应的值递减，value值必须是全数字的字符串
     *
     * @param key   the key
     * @param delta 要递减几(大于0)
     * @return the long
     */
    public Long decr(final String key, final long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    // ===============================List Start=================================

    /**
     * redis List 引擎
     *
     * @return the list operations
     */
    public ListOperations<String, Object> opsForList() {
        return redisTemplate.opsForList();
    }

    /**
     * redis List数据结构 : 将一个值 value 插入到列表 key 的表头(最左边)。
     *
     * @param key   redis主键
     * @param value 值
     * @return the long
     */
    public Long leftPush(String key, Object value) {
        return leftPush(key, value, -1);
    }

    /**
     * redis List数据结构 : 将一个值 value 插入到列表 key 的表头(最左边)，并设置过期时间（单位默认：秒）
     *
     * @param key   redis主键
     * @param value 值
     * @param time  过期时间（秒）
     * @return the long
     */
    public Long leftPush(String key, Object value, long time) {
        return leftPush(key, value, time, TimeUnit.SECONDS);
    }

    /**
     * redis List数据结构 : 将一个值 value 插入到列表 key 的表头(最左边)，并设置过期时间，需指定过期时间单位
     *
     * @param key      redis主键
     * @param value    值
     * @param time     过期时间
     * @param timeUnit 过期时间单位
     * @return the long
     */
    public Long leftPush(String key, Object value, long time, TimeUnit timeUnit) {
        Long count = opsForList().leftPush(key, value);
        if (time > 0) {
            expire(key, time, timeUnit);
        }
        return count;
    }

    /**
     * redis List数据结构 : 移除并返回列表 key 的头元素
     *
     * @param key redis主键
     * @return 列表 key 对应的头元素
     */
    public Object leftPop(String key) {
        return opsForList().leftPop(key);
    }

    /**
     * redis List数据结构 :将一个值 value 插入到列表 key 的表尾(最右边)。
     *
     * @param key   redis主键
     * @param value 值
     * @return the long
     */
    public Long rightPush(String key, Object value) {
        return leftPush(key, value, -1);
    }

    /**
     * redis List数据结构 :将一个值 value 插入到列表 key 的表尾(最右边)，并设置过期时间（单位默认：秒）
     *
     * @param key   redis主键
     * @param value 值
     * @param time  过期时间（秒）
     * @return the long
     */
    public Long rightPush(String key, Object value, long time) {
        return leftPush(key, value, time, TimeUnit.SECONDS);
    }

    /**
     * redis List数据结构 :将一个值 value 插入到列表 key 的表尾(最右边)，并设置过期时间，需指定过期时间单位
     *
     * @param key      redis主键
     * @param value    值
     * @param time     过期时间
     * @param timeUnit 过期时间单位
     * @return the long
     */
    public Long rightPush(String key, Object value, long time, TimeUnit timeUnit) {
        Long count = opsForList().rightPush(key, value);
        if (time > 0) {
            expire(key, time, timeUnit);
        }
        return count;
    }

    /**
     * redis List数据结构 : 移除并返回列表 key 的末尾元素
     *
     * @param key redis主键
     * @return 列表 key 对应的末尾元素
     */
    public Object rightPop(String key) {
        return opsForList().rightPop(key);
    }

    /**
     * redis List数据结构 : 返回列表 key 的长度 ; 如果 key 不存在，则 key 被解释为一个空列表，返回 0 ; 如果 key 不是列表类型，返回一个错误。
     *
     * @param key the key
     * @return the long
     */
    public Long length(String key) {
        return opsForList().size(key);
    }

    /**
     * redis List数据结构 : 获取下标为 index 的元素的值
     *
     * @param key   redis主键
     * @param index 索引
     * @return 下标为 index 的元素的值
     */
    public Object getByIndex(String key, long index) {
        return opsForList().index(key, index);
    }

    /**
     * redis List数据结构 : 根据参数 index 的值，移除列表中与参数 value 相等的元素
     *
     * @param key   redis主键
     * @param index 索引
     * @param value 值
     */
    public void delByIndex(String key, long index, Object value) {
        opsForList().remove(key, index, value);
    }

    /**
     * redis List数据结构 : 将列表 key 下标为 index 的元素的值设置为 value
     *
     * @param key   redis主键
     * @param index 索引
     * @param value 值
     */
    public void setToIndex(String key, long index, Object value) {
        opsForList().set(key, index, value);
    }

    /**
     * redis List数据结构 : 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 end 指定。
     *
     * @param key   redis主键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     * @return the list
     */
    public List<Object> getList(String key, int start, int end) {
        return opsForList().range(key, start, end);
    }

    /**
     * redis List数据结构 : 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 end 指定。
     *
     * @param key             the key
     * @param start           the start
     * @param end             the end
     * @param valueSerializer 序列化
     * @return the list
     */
    public List<Object> getList(String key, int start, int end, RedisSerializer<Object> valueSerializer) {
        byte[] rawKey = rawKey(key);
        return redisTemplate.execute(connection -> deserializeValues(connection.lRange(rawKey, start, end), valueSerializer), true);
    }

    /**
     * redis List数据结构 : 批量存储
     *
     * @param key  redis主键
     * @param list 数据集合
     * @return 成功个数
     */
    public Long leftPushAll(String key, List<String> list) {
        return leftPushAll(key, list, -1);
    }

    /**
     * redis List数据结构 : 批量存储，并设置过期时间（单位默认：秒）
     *
     * @param key  redis主键
     * @param list 数据集合
     * @param time 过期时间（秒）
     * @return 成功个数
     */
    public Long leftPushAll(String key, List<String> list, long time) {
        return leftPushAll(key, list, time, TimeUnit.SECONDS);
    }

    /**
     * redis List数据结构 : 批量存储，并设置过期时间，需要指定过期时间单位
     *
     * @param key      redis主键
     * @param list     数据集合
     * @param time     过期时间
     * @param timeUnit 过期时间单位
     * @return 成功个数
     */
    public Long leftPushAll(String key, List<String> list, long time, TimeUnit timeUnit) {
        Long count = opsForList().leftPushAll(key, list);
        if (time > 0) {
            expire(key, time, timeUnit);
        }
        return count;
    }

    /**
     * redis List数据结构 : 批量存储
     *
     * @param key  redis主键
     * @param list 数据集合
     * @return 成功个数
     */
    public Long rightPushAll(String key, List<String> list) {
        return rightPushAll(key, list, -1);
    }

    /**
     * redis List数据结构 : 批量存储，并设置过期时间（单位默认：秒）
     *
     * @param key  redis主键
     * @param list 数据集合
     * @param time 过期时间（秒）
     * @return 成功个数
     */
    public Long rightPushAll(String key, List<String> list, long time) {
        return rightPushAll(key, list, time, TimeUnit.SECONDS);
    }

    /**
     * redis List数据结构 : 批量存储，并设置过期时间，需要指定过期时间单位
     *
     * @param key      redis主键
     * @param list     数据集合
     * @param time     过期时间
     * @param timeUnit 过期时间单位
     * @return 成功个数
     */
    public Long rightPushAll(String key, List<String> list, long time, TimeUnit timeUnit) {
        Long count = opsForList().rightPushAll(key, list);
        if (time > 0) {
            expire(key, time, timeUnit);
        }
        return count;
    }
    // ===============================List End=================================

    // ===============================Geo Start=================================

    /**
     * redis Geo 引擎
     *
     * @return the geo operations
     */
    public GeoOperations<String, Object> opsForGeo() {
        return redisTemplate.opsForGeo();
    }

    /**
     * 添加经纬度信息,时间复杂度为O(log(N))
     * redis 命令：geoadd cityGeo 116.405285 39.904989 "北京"
     *
     * @param k
     * @param point
     * @param m
     */
    public Long addGeoPoin(Object k, Point point, Object m) {
        return opsForGeo().geoAdd((String) k, point, m);
    }

    /**
     * 查找指定key的经纬度信息，可以指定多个key，批量返回
     * redis命令：geopos cityGeo 北京
     *
     * @param k
     * @param m
     */
    public List<Point> geoGet(Object k, Object... m) {
        return opsForGeo().geoPos((String) k, m);
    }

    /**
     * 返回两个地方的距离，可以指定单位，比如米m，千米km，英里mi，英尺ft
     * redis命令：geodist cityGeo 北京 上海
     *
     * @param k
     * @param mk1
     * @param mk2
     * @param metric
     * @return
     */
    public Distance geoDist(Object k, Object mk1, Object mk2, Metric metric) {
        return opsForGeo().geoDist((String) k, mk1, mk2, metric);
    }

    /**
     * 根据给定的经纬度，返回半径不超过指定距离的元素,时间复杂度为O(N+log(M))，N为指定半径范围内的元素个数，M为要返回的个数
     * redis命令：georadius cityGeo 116.405285 39.904989 100 km WITHDIST WITHCOORD ASC COUNT 5
     *
     * @param k
     * @param circle
     * @param args
     */
    public GeoResults<RedisGeoCommands.GeoLocation<Object>> nearByXY(Object k, Circle circle, RedisGeoCommands.GeoRadiusCommandArgs args) {
        return opsForGeo().geoRadius((String) k, circle, args);
    }

    /**
     * 根据指定的地点查询半径在指定范围内的位置,时间复杂度为O(log(N)+M)，N为指定半径范围内的元素个数，M为要返回的个数
     * redis命令：georadiusbymember cityGeo 北京 100 km WITHDIST WITHCOORD ASC COUNT 5
     *
     * @param k
     * @param mk
     * @param distance
     * @param args
     * @return
     */
    public GeoResults<RedisGeoCommands.GeoLocation<Object>> nearByPlace(Object k, Object mk, Distance distance, RedisGeoCommands.GeoRadiusCommandArgs args) {
        return opsForGeo().geoRadiusByMember((String) k, mk, distance, args);
    }

    /**
     * 返回的是geohash值,查找一个位置的时间复杂度为O(log(N))
     * redis命令：geohash cityGeo 北京
     *
     * @param k
     * @param mks
     * @return
     */
    public List<String> geoHash(Object k, Object... mks) {
        return opsForGeo().geoHash((String) k, mks);
    }
    // ===============================Geo End=================================

    private byte[] rawKey(Object key) {
        Assert.notNull(key, "non null key required");
        if (key instanceof byte[]) {
            return (byte[]) key;
        }
        RedisSerializer<Object> redisSerializer = (RedisSerializer<Object>) redisTemplate.getKeySerializer();
        return redisSerializer.serialize(key);
    }

    private byte[] rawValue(Object value, RedisSerializer valueSerializer) {
        if (value instanceof byte[]) {
            return (byte[]) value;
        }
        return valueSerializer.serialize(value);
    }

    private List deserializeValues(List<byte[]> rawValues, RedisSerializer<Object> valueSerializer) {
        if (Objects.isNull(valueSerializer)) {
            return rawValues;
        }
        return SerializationUtils.deserialize(rawValues, valueSerializer);
    }

    private Object deserializeValue(byte[] value, RedisSerializer<Object> valueSerializer) {
        if (Objects.isNull(valueSerializer)) {
            return value;
        }
        return valueSerializer.deserialize(value);
    }

    /**
     * 发布订阅模式发送消息
     *
     * @param channel 消息通道名称
     * @param message 消息体
     */
    public void convertAndSend(String channel, Object message) {
        redisTemplate.convertAndSend(channel, message);
    }

}
