redis 工具类

package com.sz.gcyh.crazyad.basic.redis;

import com.sz.gcyh.crazyad.utils.CloseableUtils;
import com.sz.gcyh.crazyad.utils.MapUtils;
import com.sz.gcyh.crazyad.utils.SerializeUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import redis.clients.jedis.*;

import java.util.*;

/**
 * jedis工具类
 *
 * @author wupengfei wupf86@126.com
 */
public abstract class JedisUtils {

    private static Log log = LogFactory.getLog(JedisUtils.class);
    private static JedisPool pool;
    private static JedisPoolConfig config;
    private static JedisShardInfo shardInfo;

    static {
        // 初始化池配置
        config = new JedisPoolConfig();
        config.setMaxTotal(JedisFileConfig.getIntValue("max.total"));
        config.setMaxIdle(JedisFileConfig.getIntValue("max.idle"));
        config.setMinIdle(JedisFileConfig.getIntValue("min.idle"));
        config.setMaxWaitMillis(JedisFileConfig.getIntValue("max.wait.millis"));
        config.setTestOnBorrow(JedisFileConfig.getBooleanValue("test.on.borrow"));
        config.setBlockWhenExhausted(JedisFileConfig.getBooleanValue("block.when.exhausted"));

        // 初始化jedis池
        String host = JedisFileConfig.getValue("host");
        int port = JedisFileConfig.getIntValue("port");
        int timeout = JedisFileConfig.getIntValue("connection.timeout");
        String password = JedisFileConfig.getValue("password");
        if (StringUtils.isNotBlank(password)) {
            pool = new JedisPool(config, host, port, timeout, password);
        } else {
            pool = new JedisPool(config, host, port, timeout);
        }

        // 初始化分片信息
        shardInfo = new JedisShardInfo(host, port);
        shardInfo.setConnectionTimeout(timeout);
        if (StringUtils.isNotBlank(password)) {
            shardInfo.setPassword(password);
        }
        shardInfo.setSoTimeout(timeout);
    }

    /**
     * 获取指定键的值
     *
     * @param key 键
     * @return 键值
     */
    public static String get(String key) {
        if (StringUtils.isBlank(key)) {
            return null;
        }
        return doExecute(jedis -> jedis.get(key));
    }

    /**
     * 获取指定键的值
     *
     * @param key 键
     * @return 值
     */
    @SuppressWarnings("unchecked")
    public static <T> T get(byte[] key) {
        return doExecute(jedis -> {
            byte[] data = jedis.get(key);
            return (T) SerializeUtils.unserialize(data);
        });
    }

    /**
     * 获取指定键的值
     *
     * @param key 键
     * @return 值集合
     */
    public static List<String> lrange(String key) {
        return lrange(key, 0, -1);
    }

    /**
     * 获取指定键的值
     *
     * @param key   键
     * @param start 开始索引
     * @param end   结束索引
     * @return 值集合
     */
    public static List<String> lrange(String key, long start, long end) {
        if (StringUtils.isBlank(key)) {
            return null;
        }
        return doExecute(jedis -> jedis.lrange(key, start, end));
    }

    /**
     * 获取指定键的值
     *
     * @param key 键
     * @return 值集合
     */
    public static Set<String> smembers(String key) {
        if (StringUtils.isBlank(key)) {
            return null;
        }
        return doExecute(jedis -> jedis.smembers(key));
    }

    /**
     * 获取指定键的值
     *
     * @param key 键
     * @return 值集合
     */
    public static List<String> srandmember(String key, int count) {
        return doExecute(jedis -> jedis.srandmember(key, count));
    }

    /**
     * 获取指定键的值
     *
     * @param key 键
     * @return 有序值集合
     */
    public static Set<String> zrange(String key) {
        return zrange(key, 0, -1);
    }

    /**
     * 获取指定键的值
     *
     * @param key   键
     * @param start 开始索引
     * @param end   结束索引
     * @return 有序值集合
     */
    public static Set<String> zrange(String key, long start, long end) {
        if (StringUtils.isBlank(key)) {
            return null;
        }
        return doExecute(jedis -> jedis.zrange(key, start, end));
    }

    /**
     * 合并多个有序集的值到目标键
     *
     * @param destKey   目标键
     * @param params    合并时的参数
     * @param sourceKey 源键
     * @return 目标键中值的数量
     */
    public static Long zinterstore(String destKey, ZParams params, String... sourceKey) {
        if (StringUtils.isBlank(destKey)) {
            return null;
        }
        return doExecute(jedis -> jedis.zinterstore(destKey, params, sourceKey));
    }

    /**
     * 获取有序集合中元素的倒序
     *
     * @param key    键
     * @param member 元素
     * @return 倒序
     */
    public static Long zrevrank(String key, String member) {
        if (StringUtils.isBlank(key) || StringUtils.isBlank(member)) {
            return null;
        }
        return doExecute(jedis -> {
            Long result = jedis.zrevrank(key, member);
            return result != null ? result + 1 : null;
        });
    }

    /**
     * 按分数倒序获取缓存中的值
     *
     * @param key 键
     * @return 缓存中的值
     */
    public static Set<SortedSetElement> zrevrangeByScoreWithScores(String key) {
        if (StringUtils.isBlank(key)) {
            return null;
        }
        return zrevrangeByScoreWithScores(key, Double.MAX_VALUE, Double.MIN_VALUE, 0, -1);
    }

    /**
     * 按分数倒序分页获取缓存中的值
     *
     * @param key    键
     * @param offset 起始数
     * @param count  获取的总数
     * @return 缓存中的值
     */
    public static Set<SortedSetElement> zrevrangeByScoreWithScores(String key, int offset, int count) {
        if (StringUtils.isBlank(key)) {
            return null;
        }
        return zrevrangeByScoreWithScores(key, Double.MAX_VALUE, Double.MIN_VALUE, offset, count);
    }

    /**
     * 按分数倒序分页获取缓存中的值
     *
     * @param key    键
     * @param max    分数最大值
     * @param min    分数最小值
     * @param offset 起始数
     * @param count  获取的总数
     * @return 缓存中的值
     */
    public static Set<SortedSetElement> zrevrangeByScoreWithScores(String key, Double max, Double min, int offset, int count) {
        if (StringUtils.isBlank(key)) {
            return null;
        }
        return doExecute(jedis -> {
            Set<Tuple> set = jedis.zrevrangeByScoreWithScores(key, max, min, offset, count);
            if (set != null) {
                Set<SortedSetElement> result = new LinkedHashSet<>();
                for (Tuple each : set) {
                    result.add(new SortedSetElement(each.getElement(), each.getScore()));
                }
                return result;
            }
            return null;
        });
    }

    /**
     * 获取指定键的值
     *
     * @param key 键
     * @return 值map
     */
    public static Map<String, String> hgetAll(String key) {
        if (StringUtils.isBlank(key)) {
            return null;
        }
        return doExecute(jedis -> jedis.hgetAll(key));
    }

    /**
     * 获取指定键的值
     *
     * @param key 键
     * @return 值map
     */
    @SuppressWarnings("unchecked")
    public static <T> Map<String, T> hgetAll(byte[] key) {
        if (key == null) {
            return null;
        }
        return doExecute(jedis -> {
            Map<String, T> result = null;
            Map<byte[], byte[]> map = jedis.hgetAll(key);
            if (map != null) {
                result = new HashMap<>();
                for (Map.Entry<byte[], byte[]> entry : map.entrySet()) {
                    result.put(new String(entry.getKey()), (T) SerializeUtils.unserialize(entry.getValue()));
                }
            }
            return result;
        });
    }

    /**
     * 获取指定键的值
     *
     * @param key   键
     * @param field map中的键
     * @return 值
     */
    public static String hget(String key, String field) {
        if (StringUtils.isBlank(key)) {
            return null;
        }
        return doExecute(jedis -> jedis.hget(key, field));
    }

    /**
     * 获取指定键的值
     *
     * @param key   键
     * @param field map中的键
     * @return 值
     */
    @SuppressWarnings("unchecked")
    public static <T> T hget(byte[] key, byte[] field) {
        return doExecute(jedis -> {
            byte[] result = jedis.hget(key, field);
            return (T) SerializeUtils.unserialize(result);
        });
    }

    /**
     * 是否包含指定的键
     *
     * @param key 键
     * @return 若存在则返回true
     */
    public static Boolean exists(String key) {
        if (StringUtils.isBlank(key)) {
            return false;
        }
        return doExecute(jedis -> jedis.exists(key));
    }

    /**
     * 缓存指定的键值
     *
     * @param key   键
     * @param value 值
     */
    public static Boolean set(String key, String value) {
        if (StringUtils.isBlank(key)) {
            return false;
        }
        return doExecute(jedis -> {
            String result = jedis.set(key, value);
            return isSuccess(result);
        });
    }

    /**
     * 若指定的键不存在时则缓存
     * <p><b>获取值时需用getObject方法</b></p>
     *
     * @param key   键
     * @param value 值
     * @return 若设置成功则返回true
     */
    public static boolean setObjectIfNotExist(String key, String value) {
        return setObjectIfNotExist(key, value, -1);
    }

    /**
     * 若指定的键不存在时则缓存
     * <p><b>获取值时需用getObject方法</b></p>
     *
     * @param key          键
     * @param value        值
     * @param milliseconds 缓存的时间（单位毫秒）
     * @return 若设置成功则返回true
     */
    public static boolean setObjectIfNotExist(String key, String value, int milliseconds) {
        return setObjectIfNotExist(key, (Object) value, milliseconds);
    }

    /**
     * 加锁
     * <p><b>获取值时需用getObject方法</b></p>
     *
     * @param key   键
     * @param value 值
     * @return 若加锁成功则返回true
     */
    public static boolean lockObject(String key, String value) {
        return lockObject(key, value, 0);
    }

    /**
     * 加锁
     * <p><b>获取值时需用getObject方法</b></p>
     *
     * @param key          键
     * @param value        值
     * @param milliseconds 缓存的时间（单位毫秒）
     * @return 若加锁成功则返回true
     */
    public static boolean lockObject(String key, String value, int milliseconds) {
        if (StringUtils.isBlank(key) || value == null) {
            return false;
        }
        return doExecute(jedis -> {
            String result;
            if (milliseconds > 0) {
                result = jedis.set(key.getBytes(), value.getBytes(), JedisEnum.NXXX.NX.getValue().getBytes(), JedisEnum.EXPX.PX.getValue().getBytes(), milliseconds);
            } else {
                result = jedis.set(key.getBytes(), value.getBytes(), JedisEnum.NXXX.NX.getValue().getBytes());
            }
            return isSuccess(result);
        });
    }


    /**
     * 解锁：条件值相等
     *
     * @param key   键
     * @param value 值
     * @return 若解锁成功则返回true
     */
    public static boolean unlock(String key, String value) {
        StringBuilder sb = new StringBuilder();
        sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] then").append(" ");
        sb.append("return redis.call(\"del\",KEYS[1])").append(" ");
        sb.append("else").append(" ");
        sb.append("return 0").append(" ");
        sb.append("end");
        return doExecute(jedis -> (long) jedis.eval(sb.toString(), Collections.singletonList(key), Collections.singletonList(value)) > 0);
    }

    /**
     * 若指定的键存在时则缓存
     * <p><b>获取值时需用getObject方法</b></p>
     *
     * @param key   键
     * @param value 值
     * @return 若设置成功则返回true
     */
    public static boolean setObjectIfExist(String key, String value) {
        return setObjectIfExist(key, value, 0);
    }

    /**
     * 若指定的键存在时则缓存
     * <p><b>获取值时需用getObject方法</b></p>
     *
     * @param key     键
     * @param value   值
     * @param seconds 缓存的时间（单位秒）
     * @return 若设置成功则返回true
     */
    public static boolean setObjectIfExist(String key, String value, int seconds) {
        return setObjectIfExist(key, (Object) value, seconds);
    }

    /**
     * 缓存指定的键值并放在头部
     *
     * @param key   键
     * @param value 值
     * @return 集合的大小
     */
    public static Long lpush(String key, String... value) {
        if (StringUtils.isBlank(key) || ArrayUtils.isEmpty(value)) {
            return 0L;
        }
        return doExecute(jedis -> jedis.lpush(key, value));
    }

    /**
     * 缓存指定的键值并放在尾部
     *
     * @param key   键
     * @param value 值
     * @return 集合的大小
     */
    public static Long rpush(String key, String... value) {
        if (StringUtils.isBlank(key) || ArrayUtils.isEmpty(value)) {
            return 0L;
        }
        return doExecute(jedis -> jedis.rpush(key, value));
    }

    /**
     * 从List集合头部获取元素并删除
     *
     * @param key 键
     * @return list头部的一个元素
     */
    public static String lpop(String key) {
        if (StringUtils.isBlank(key)) {
            return null;
        }
        return doExecute(jedis -> jedis.lpop(key));
    }

    /**
     * 从List集合中删除指定的值
     *
     * @param key   键
     * @param count count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 COUNT；
     *              count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 COUNT 的绝对值；
     *              count = 0 : 移除表中所有与 VALUE 相等的值。
     * @param value 删除的值
     * @return 删除的元素数量
     */
    public static Long lrem(String key, long count, String value) {
        if (StringUtils.isBlank(key)) {
            return null;
        }
        return doExecute(jedis -> jedis.lrem(key, count, value));
    }

    /**
     * 从List集合尾部获取元素并删除
     *
     * @param key 键
     * @return list尾部的一个元素
     */
    public static String rpop(String key) {
        if (StringUtils.isBlank(key)) {
            return null;
        }
        return doExecute(jedis -> jedis.rpop(key));
    }

    /**
     * 缓存指定的键值
     *
     * @param key   键
     * @param value 值
     * @return 若设置成功则返回true
     */
    public static Boolean sadd(String key, String... value) {
        if (StringUtils.isBlank(key) || ArrayUtils.isEmpty(value)) {
            return false;
        }
        return doExecute(jedis -> {
            Long result = jedis.sadd(key, value);
            return result >= 1;
        });
    }

    /**
     * 缓存指定的键值
     *
     * @param key   键
     * @param value 值
     * @param score 分数
     */
    public static Boolean zadd(String key, String value, double score) {
        if (StringUtils.isBlank(key) || value == null) {
            return false;
        }
        return doExecute(jedis -> {
            Long result = jedis.zadd(key, score, value);
            return result >= 1;
        });
    }

    /**
     * 缓存指定的键值
     *
     * @param key   键
     * @param value 格式：{值：分数}
     */
    public static Boolean zadd(String key, Map<String, Double> value) {
        if (StringUtils.isBlank(key) || MapUtils.isEmpty(value)) {
            return false;
        }
        return doExecute(jedis -> {
            Long result = jedis.zadd(key, value);
            return result >= 1;
        });
    }

    /**
     * 把sorted set里指定的成员增加分值
     *
     * @param key    键
     * @param member 成员
     * @param score  分值
     * @return 新的分值
     */
    public static Double zincrby(String key, String member, double score) {
        if (StringUtils.isBlank(key) || StringUtils.isBlank(member) || score == 0) {
            return 0D;
        }
        return doExecute(jedis -> jedis.zincrby(key, score, member));
    }

    /**
     * 从sorted set里删除元素
     *
     * @param key     键
     * @param members 删除的元素
     * @return 删除的数量
     */
    public static Long zrem(String key, String... members) {
        if (StringUtils.isBlank(key) || ArrayUtils.isEmpty(members)) {
            return 0L;
        }
        return doExecute(jedis -> jedis.zrem(key, members));
    }

    /**
     * 缓存指定的键值
     *
     * @param key   键
     * @param field map中的键
     * @param value map中的值
     */
    public static Boolean hset(String key, String field, String value) {
        if (StringUtils.isBlank(key) || StringUtils.isBlank(field)) {
            return false;
        }
        return doExecute(jedis -> {
            Long result = jedis.hset(key, field, value);
            return result >= 1;
        });
    }

    /**
     * 缓存指定的键值
     *
     * @param key   键
     * @param field map中的键
     * @param value map中的值
     */
    public static Boolean hset(String key, byte[] field, Object value) {
        if (StringUtils.isBlank(key) || ArrayUtils.isEmpty(field)) {
            return false;
        }
        return doExecute(jedis -> {
            Long result = jedis.hset(key.getBytes(), field, SerializeUtils.serialize(value));
            return result >= 1;
        });
    }

    /**
     * 缓存指定的键值
     * <p><b>获取值时需用getObject方法</b></p>
     *
     * @param key   键
     * @param value 值
     */
    public static Boolean setObject(String key, Object value) {
        if (StringUtils.isBlank(key)) {
            return false;
        }
        return doExecute(jedis -> {
            String result = jedis.set(key.getBytes(), SerializeUtils.serialize(value));
            return isSuccess(result);
        });
    }

    /**
     * 若指定的键不存在时则缓存
     * <p><b>获取值时需用getObject方法</b></p>
     *
     * @param key   键
     * @param value 值
     * @return 若设置成功则返回true
     */
    public static boolean setObjectIfNotExist(String key, Object value) {
        return setObjectIfNotExist(key, value, 0);
    }

    /**
     * 若指定的键不存在时则缓存
     * <p><b>获取值时需用getObject方法</b></p>
     *
     * @param key          键
     * @param value        值
     * @param milliseconds 缓存的时间（单位毫秒）
     * @return 若设置成功则返回true
     */
    public static Boolean setObjectIfNotExist(String key, Object value, int milliseconds) {
        if (StringUtils.isBlank(key)) {
            return false;
        }
        return doExecute(jedis -> {
            String result;
            if (milliseconds > 0) {
                result = jedis.set(key.getBytes(), SerializeUtils.serialize(value), JedisEnum.NXXX.NX.getValue().getBytes(), JedisEnum.EXPX.PX.getValue().getBytes(), milliseconds);
            } else {
                result = jedis.set(key.getBytes(), SerializeUtils.serialize(value), JedisEnum.NXXX.NX.getValue().getBytes());
            }
            return isSuccess(result);
        });
    }

    /**
     * 若指定的键存在时则缓存
     * <p><b>获取值时需用getObject方法</b></p>
     *
     * @param key   键
     * @param value 值
     * @return 若设置成功则返回true
     */
    public static boolean setObjectIfExist(String key, Object value) {
        return setObjectIfExist(key, value, 0);
    }

    /**
     * 若指定的键存在时则缓存
     * <p><b>获取值时需用getObject方法</b></p>
     *
     * @param key     键
     * @param value   值
     * @param seconds 缓存的时间（单位秒）
     * @return 若设置成功则返回true
     */
    public static Boolean setObjectIfExist(String key, Object value, int seconds) {
        if (StringUtils.isBlank(key)) {
            return false;
        }
        return doExecute(jedis -> {
            String result;
            if (seconds > 0) {
                result = jedis.set(key.getBytes(), SerializeUtils.serialize(value), JedisEnum.NXXX.XX.getValue().getBytes(), JedisEnum.EXPX.EX.getValue().getBytes(), seconds);
            } else {
                result = jedis.set(key.getBytes(), SerializeUtils.serialize(value), JedisEnum.NXXX.XX.getValue().getBytes());
            }
            return isSuccess(result);
        });
    }

    /**
     * 批量缓存map中的键值
     * <p><b>获取值时需用getObject方法</b></p>
     *
     * @param map 键值map
     */
    public static <T> void setObject(Map<String, T> map) {
        if (MapUtils.isEmpty(map)) {
            return;
        }
        doExecute(jedis -> {
            Pipeline pipeline = jedis.pipelined();
            try {
                for (Map.Entry<String, T> entry : map.entrySet()) {
                    pipeline.set(entry.getKey().getBytes(), SerializeUtils.serialize(entry.getValue()));
                }
                pipeline.sync();
            } finally {
                CloseableUtils.close(pipeline);
            }
            return null;
        });
    }

    /**
     * 增加指定的值
     *
     * @param key   键
     * @param value 增加的值
     * @return 增加后的值
     */
    public static Long incrBy(String key, int value) {
        if (StringUtils.isBlank(key) || value == 0) {
            return 0L;
        }
        return doExecute(jedis -> jedis.incrBy(key, value));
    }

    /**
     * 增加指定的值
     *
     * @param key   键
     * @param field map中的键
     * @param value 增加的值
     * @return 增加后的值
     */
    public static Long hincrBy(String key, String field, int value) {
        if (StringUtils.isBlank(key) || StringUtils.isBlank(field) || value == 0) {
            return 0L;
        }
        return doExecute(jedis -> jedis.hincrBy(key, field, value));
    }

    /**
     * 减少指定的值
     *
     * @param key   键
     * @param value 减少的值
     * @return 减少后的值
     */
    public static Long decrBy(String key, long value) {
        if (StringUtils.isBlank(key) || value == 0) {
            return 0L;
        }
        return doExecute(jedis -> jedis.decrBy(key, value));
    }

    /**
     * 给指定的键设置过期时间
     *
     * @param key     键
     * @param seconds 过期时间（单位：秒）
     * @return 若设置成功则返回true
     */
    public static Boolean expire(String key, int seconds) {
        if (StringUtils.isBlank(key) || seconds <= 0) {
            return false;
        }
        return doExecute(jedis -> {
            Long result = jedis.expire(key, seconds);
            return result == 1;
        });
    }

    /**
     * 删除指定的键
     *
     * @param key 键
     * @return 删除键的数量
     */
    public static Long del(String... key) {
        if (ArrayUtils.isEmpty(key)) {
            return 0L;
        }
        return doExecute(jedis -> jedis.del(key));
    }

    /**
     * 删除map中指定的字段
     *
     * @param key   键
     * @param field 字段
     * @return 删除字段的数量
     */
    public static Long hdel(String key, String... field) {
        if (StringUtils.isBlank(key) || ArrayUtils.isEmpty(field)) {
            return 0L;
        }
        return doExecute(jedis -> jedis.hdel(key, field));
    }

    /**
     * 获取以指定格式的键
     *
     * @param pattern 正则表达式
     * @return 匹配的值
     */
    public static Set<String> keys(String pattern) {
        if (StringUtils.isBlank(pattern)) {
            return null;
        }
        return doExecute(jedis -> jedis.keys(pattern));
    }

    /**
     * 获取set的大小
     *
     * @param key 键
     * @return set大小
     */
    public static Long scard(String key) {
        if (StringUtils.isBlank(key)) {
            return 0L;
        }
        return doExecute(jedis -> jedis.scard(key));
    }

    /**
     * 获取sorted set的大小
     *
     * @param key 键
     * @return 获取sorted set大小
     */
    public static Long zcard(String key) {
        if (StringUtils.isBlank(key)) {
            return 0L;
        }
        return doExecute(jedis -> jedis.zcard(key));
    }

    /**
     * 获取sorted set中指定成员的分数
     *
     * @param key    键
     * @param member 成员
     * @return 指定成员的分数
     */
    public static Double zscore(String key, String member) {
        if (StringUtils.isBlank(key)) {
            return null;
        }
        return doExecute(jedis -> jedis.zscore(key, member));
    }

    /**
     * 校验set里是否已存在元素
     *
     * @param key    键
     * @param member 元素
     * @return 若存在则返回true
     */
    public static Boolean sismember(String key, String member) {
        if (StringUtils.isBlank(key)) {
            return false;
        }
        return doExecute(jedis -> jedis.sismember(key, member));
    }

    /**
     * 从set里面删除元素
     *
     * @param key    键
     * @param member 元素
     * @return 删除的数量
     */
    public static Long srem(String key, String... member) {
        if (StringUtils.isBlank(key) || ArrayUtils.isEmpty(member)) {
            return 0L;
        }
        return doExecute(jedis -> jedis.srem(key, member));
    }

    /**
     * 返回键的过期时间（单位：秒）
     *
     * @param key 键
     * @return 键的过期时间
     */
    public static Long ttl(String key) {
        if (StringUtils.isBlank(key)) {
            return null;
        }
        return doExecute(jedis -> jedis.ttl(key));
    }

    /**
     * @return 获取jedis对象
     */
    public static Jedis getJedis() {
        return pool.getResource();
    }

    /**
     * 清空所有的缓存
     */
    public static void flushDB() {
        doExecute(jedis -> jedis.flushDB());
    }

    /**
     * @return 缓存池配置
     */
    public static JedisPoolConfig getConfig() {
        return config;
    }

    /**
     * @return 分片信息
     */
    public static JedisShardInfo getShardInfo() {
        return shardInfo;
    }

    /**
     * 关闭jedis对象
     *
     * @param jedis jedis对象
     */
    private static void close(Jedis jedis) {
        if (jedis != null) {
            jedis.close();
        }
    }

    private static boolean isSuccess(String value) {
        return "OK".equals(value);
    }

    private static <T> T doExecute(Executor<T> executor) {
        Jedis jedis = getJedis();
        try {
            return executor.execute(jedis);
        } catch (Throwable t) {
            log.error("缓存出现异常", t);
            return null;
        } finally {
            close(jedis);
        }
    }

    private interface Executor<T> {
        T execute(Jedis jedis);
    }
}

redis 删除list 指定 value

Long activeUser = JedisUtils.rpush(RedisConstant.CRAZY_ADD_USER_ID, crazyUserId + "");//存入

 JedisUtils.lrem(RedisConstant.CRAZY_ADD_USER_ID, 1, user.getId().toString()); //从尾部删除指定的值