Redis工具类

1.maven依赖

<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>${jedis.version}</version>
</dependency>

2.redis.properties(每个属性不做过多解释)

redis.pool.maxActive=5
redis.pool.maxIdle=1
redis.pool.maxWait=10000
redis.pool.testOnBorrow=true
redis.expire=6000
redis.ip=localhost
redis.port=6379
redis.password=

3.连接池

public final class RedisUtils {

    private static long DEFAULT_EXPIRE = 0L;

    private static JedisPool jedisPool = null;

    private RedisUtils() {}

    static {
        ResourceBundle rb = ResourceBundle.getBundle("redis");
        DEFAULT_EXPIRE = Long.valueOf(rb.getString("redis.expire"));

        int maxActive = Integer.parseInt(rb.getString("redis.pool.maxActive"));
        int maxIdle = Integer.parseInt(rb.getString("redis.pool.maxIdle"));
        int maxWait = Integer.parseInt(rb.getString("redis.pool.maxWait"));
        boolean testOnBorrow = Boolean.parseBoolean(rb.getString("redis.pool.testOnBorrow"));
        String ip = rb.getString("redis.ip");
        int port = Integer.parseInt(rb.getString("redis.port"));
        String pwd = rb.getString("redis.password");

        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(maxActive);
        config.setMaxIdle(maxIdle);
        config.setMaxWaitMillis(maxWait);
        config.setTestOnBorrow(testOnBorrow);

        if (StringUtils.isNotBlank(pwd)) {
            jedisPool = new JedisPool(config, ip, port, 2000, pwd);
        } else {
            jedisPool = new JedisPool(config, ip, port);
        }
    }

    /**
     * 获取连接池
     */
    public static JedisPool getJedisPool() {
        return jedisPool;
    }

    /**
     * 获取Jedis连接
     */
    public static Jedis getJedis() {
        return getJedisPool().getResource();
    }

    /**
     * 回收Jedis连接
     */
    public static void releaseJedis(Jedis jedis) {
        if (jedisPool != null && jedis != null) {
            getJedisPool().returnResource(jedis);
        }
    }

    /**
     * 销毁Jedis连接
     */
    public static void returnBrokenResource(Jedis jedis) {
        if (jedisPool != null && jedis != null) {
            jedisPool.returnBrokenResource(jedis);
        }
    }

    /**
     * 获取默认过期时间
     */
    public static long getDefaultExpire() {
        return DEFAULT_EXPIRE;
    }
}

4.对Key操作

public final class RedisKeyUtils {

    private RedisKeyUtils() {}

    private static Jedis getJedis() {
        return RedisUtils.getJedis();
    }

    private static void releaseJedis(Jedis jedis) {
        RedisUtils.releaseJedis(jedis);
    }

    /**
     * 清空所有Key
     */
    public static String flushAll() {
        Jedis jedis = getJedis();
        String state = jedis.flushAll();
        releaseJedis(jedis);
        return state;
    }

    /**
     * 更改key
     * @return 状态码
     */
    public static String rename(String oldKey, String newKey) {
        return rename(SafeEncoder.encode(oldKey), SafeEncoder.encode(newKey));
    }

    /**
     * 更改key
     * @return 状态码
     */
    public static String rename(byte[] oldKey, byte[] newKey) {
        Jedis jedis = getJedis();
        String status = jedis.rename(oldKey, newKey);
        releaseJedis(jedis);
        return status;
    }

    /**
     * 更改key, 仅当新key不存在时才执行
     * @return 状态码
     */
    public static long renamenx(String oldKey, String newKey) {
        Jedis jedis = getJedis();
        long status = jedis.renamenx(oldKey, newKey);
        releaseJedis(jedis);
        return status;
    }

    /**
     * 设置key的过期时间, 以秒为单位
     * @return 影响的记录数
     */
    public static long expired(String key, int seconds) {
        Jedis jedis = getJedis();
        long count = jedis.expire(key, seconds);
        releaseJedis(jedis);
        return count;
    }

    /**
     * 设置key的过期时间, 单位秒[它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00，格里高利历）的偏移量]
     * @return 影响的记录数
     */
    public static long expiredAt(String key, long unixTime) {
        Jedis jedis = getJedis();
        long count = jedis.expireAt(key, unixTime);
        releaseJedis(jedis);
        return count;
    }

    /**
     * 查询key的过期时间
     * @return 以秒为单位的时间表示
     */
    public static long ttl(String key) {
        Jedis jedis = getJedis();
        long len = jedis.ttl(key);
        releaseJedis(jedis);
        return len;
    }

    /**
     * 取消对key过期时间的设置
     * @return 影响的记录数
     */
    public static long persist(String key) {
        Jedis jedis = getJedis();
        long count = jedis.persist(key);
        releaseJedis(jedis);
        return count;
    }

    /**
     * 删除keys对应的记录, 可以是多个key
     * @return 删除的记录数
     */
    public static long del(String... keys) {
        Jedis jedis = getJedis();
        long count = jedis.del(keys);
        releaseJedis(jedis);
        return count;
    }

    /**
     * 删除keys对应的记录, 可以是多个key
     * @return 删除的记录数
     */
    public static long del(byte[]... keys) {
        Jedis jedis = getJedis();
        long count = jedis.del(keys);
        releaseJedis(jedis);
        return count;
    }

    /**
     * 判断key是否存在
     */
    public static boolean exists(String key) {
        Jedis jedis = getJedis();
        boolean exists = jedis.exists(key);
        releaseJedis(jedis);
        return exists;
    }

    /**
     * 对List, Set, SortSet进行排序, 如果集合数据较大应避免使用这个方法
     * @return List<String> 全部记录
     */
    public static List<String> sort(String key) {
        Jedis jedis = getJedis();
        List<String> list = jedis.sort(key);
        releaseJedis(jedis);
        return list;
    }

    /**
     * 对List, Set, SortSet进行排序或limit
     * @param params 定义排序类型或limit的起止位置
     * @return List<String> 全部或部分记录
     */
    public static List<String> sort(String key, SortingParams params) {
        Jedis jedis = getJedis();
        List<String> list = jedis.sort(key, params);
        releaseJedis(jedis);
        return list;
    }

    /**
     * 返回指定key存储的类型
     * @param key
     * @return string|list|set|zset|hash
     */
    public static String type(String key) {
        Jedis jedis = getJedis();
        String type = jedis.type(key);
        releaseJedis(jedis);
        return type;
    }

    /**
     * 查找所有匹配给定的模式的键
     * @param pattern *多个 ?表示一个
     * @return
     */
    public Set<String> keys(String pattern) {
        Jedis jedis = getJedis();
        Set<String> set = jedis.keys(pattern);
        releaseJedis(jedis);
        return set;
    }
}

5.对String操作

public final class RedisStringUtils {

    private RedisStringUtils() {}

    private static Jedis getJedis() {
        return RedisUtils.getJedis();
    }

    private static void releaseJedis(Jedis jedis) {
        RedisUtils.releaseJedis(jedis);
    }

    /**
     * 根据key获取记录
     * @param key
     * @return
     */
    public static String get(String key) {
        Jedis jedis = getJedis();
        String value = jedis.get(key);
        releaseJedis(jedis);
        return value;
    }

    /**
     * 根据key获取记录
     * @param key
     * @return
     */
    public static byte[] get(byte[] key) {
        Jedis jedis = getJedis();
        byte[] value = jedis.get(key);
        releaseJedis(jedis);
        return value;
    }

    /**
     * 添加有过期时间的记录
     * @param key
     * @param seconds 过期时间，以秒为单位
     * @param value
     * @return 操作状态
     */
    public static String setex(String key, int seconds, String value) {
        Jedis jedis = getJedis();
        String str = jedis.setex(key, seconds, value);
        releaseJedis(jedis);
        return str;
    }

    /**
     * 添加有过期时间的记录
     * @param key
     * @param seconds 过期时间，以秒为单位
     * @param value
     * @return 操作状态
     */
    public static String setex(byte[] key, int seconds, byte[] value) {
        Jedis jedis = getJedis();
        String str = jedis.setex(key, seconds, value);
        releaseJedis(jedis);
        return str;
    }

    /**
     * 添加一条记录, 仅当给定的key不存在时才插入
     * @param key
     * @param value
     * @return 状态码 1插入成功且key不存在 0未插入key存在
     */
    public static long setnx(String key, String value) {
        Jedis jedis = getJedis();
        long str = jedis.setnx(key, value);
        releaseJedis(jedis);
        return str;
    }

    /**
     * 添加记录, 如果记录已存在将覆盖原有的value
     * @param key
     * @param value
     * @return
     */
    public static String set(byte[] key, byte[] value) {
        Jedis jedis = getJedis();
        String status = jedis.set(key, value);
        releaseJedis(jedis);
        return status;
    }

    /**
     * 添加记录, 如果记录已存在将覆盖原有的value
     * @param key
     * @param value
     * @return
     */
    public static String set(String key, String value) {
        return set(SafeEncoder.encode(key), SafeEncoder.encode(value));
    }

    /**
     * 添加记录, 如果记录已存在将覆盖原有的value
     * @param key
     * @param value
     * @return
     */
    public static String set(String key, byte[] value) {
        return set(SafeEncoder.encode(key), value);
    }

    /**
     * 从指定位置开始插入数据, 插入的数据会覆盖指定位置以后的数据
     * 比如：123456789 setRange(key, 4, 0000) 结果123400009
     * @param key
     * @param offset
     * @param value
     * @return
     */
    public static long setRange(String key, long offset, String value) {
        Jedis jedis = getJedis();
        long len = jedis.setrange(key, offset, value);
        releaseJedis(jedis);
        return len;
    }

    /**
     * 在指定的key中追加value
     * @param key
     * @param value
     * @return 追加后value的长度
     */
    public static long append(String key, String value) {
        Jedis jedis = getJedis();
        long len = jedis.append(key, value);
        releaseJedis(jedis);
        return len;
    }

    /**
     * 将key对应的value减去指定的值, 只有value可以转为数字时该方法才可用
     * @param key
     * @param number 要减去的值
     * @return 减指定值后的值
     */
    public static long decrBy(String key, long number) {
        Jedis jedis = getJedis();
        long len = jedis.decrBy(key, number);
        releaseJedis(jedis);
        return len;
    }

    /**
     * 将key对应的value加上指定的值, 只有value可以转为数字时该方法才可用
     * @param key
     * @param number 要加上的值
     * @return 相加后的值
     */
    public static long incrBy(String key, long number) {
        Jedis jedis = getJedis();
        long len = jedis.incrBy(key, number);
        releaseJedis(jedis);
        return len;
    }

    /**
     * 对指定key的value进行截取
     * @param key
     * @param startOffset 开始位置(包含)
     * @param endOffset 结束位置(包含)
     * @return 截取的值
     */
    public static String getrange(String key, long startOffset, long endOffset) {
        Jedis jedis = getJedis();
        String value = jedis.getrange(key, startOffset, endOffset);
        releaseJedis(jedis);
        return value;
    }

    /**
     * 获取并设置指定key对应的value
     * @param key
     * @param value
     * @return 原始value或null
     */
    public static String getSet(String key, String value) {
        Jedis jedis = getJedis();
        String str = jedis.getSet(key, value);
        releaseJedis(jedis);
        return str;
    }

    /**
     * 批量获取记录, 如果指定的key不存在返回List的对应位置将是null
     * @param keys
     * @return 值的集合
     */
    public static List<String> mget(String... keys) {
        Jedis jedis = getJedis();
        List<String> str = jedis.mget(keys);
        releaseJedis(jedis);
        return str;
    }

    /**
     * 批量存储记录
     * @param keysvalues "key1","value1","key2","value2";
     * @return
     */
    public static String mset(String... keysvalues) {
        Jedis jedis = getJedis();
        String str = jedis.mset(keysvalues);
        releaseJedis(jedis);
        return str;
    }

    /**
     * 获取key对应的值的长度
     * @param key
     * @return value值得长度
     */
    public static long strlen(String key) {
        Jedis jedis = getJedis();
        long len = jedis.strlen(key);
        releaseJedis(jedis);
        return len;
    }
}

6.对List操作

public final class RedisListUtils {

    private RedisListUtils() {}

    private static Jedis getJedis() {
        return RedisUtils.getJedis();
    }

    private static void releaseJedis(Jedis jedis) {
        RedisUtils.releaseJedis(jedis);
    }

    /**
     * List长度
     * @param key
     * @return
     */
    public static long llen(byte[] key) {
        Jedis jedis = getJedis();
        long count = jedis.llen(key);
        releaseJedis(jedis);
        return count;
    }

    /**
     * List长度
     * @param key
     * @return
     */
    public static long llen(String key) {
        return llen(SafeEncoder.encode(key));
    }

    /**
     * 覆盖操作, 将覆盖List中指定位置的值
     * @param key
     * @param index
     * @param value
     * @return 状态码
     */
    public static String lset(byte[] key, int index, byte[] value) {
        Jedis jedis = getJedis();
        String status = jedis.lset(key, index, value);
        releaseJedis(jedis);
        return status;
    }

    /**
     * 覆盖操作, 将覆盖List中指定位置的值
     * @param key
     * @param index
     * @param value
     * @return
     */
    public static String lset(String key, int index, String value) {
        return lset(SafeEncoder.encode(key), index, SafeEncoder.encode(value));
    }

    /**
     * 在指定位置插入记录
     * @param key
     * @param where 前面插入或后面插入
     * @param pivot 相对位置的内容
     * @param value 插入的内容
     * @return 记录总数
     */
    public static long linsert(byte[] key, BinaryClient.LIST_POSITION where, byte[] pivot, byte[] value) {
        Jedis jedis = getJedis();
        long count = jedis.linsert(key, where, pivot, value);
        releaseJedis(jedis);
        return count;
    }

    /**
     * 在指定位置插入记录
     * @param key
     * @param where 前面插入或后面插入
     * @param pivot 相对位置的内容
     * @param value 插入的内容
     * @return 记录总数
     */
    public static long linsert(String key, BinaryClient.LIST_POSITION where, String pivot, String value) {
        return linsert(SafeEncoder.encode(key), where, SafeEncoder.encode(pivot), SafeEncoder.encode(value));
    }

    /**
     * 获取List中指定位置的值
     * @param key
     * @param index
     * @return
     */
    public static byte[] lindex(byte[] key, int index) {
        Jedis jedis = getJedis();
        byte[] value = jedis.lindex(key, index);
        releaseJedis(jedis);
        return value;
    }

    /**
     * 获取List中指定位置的值
     * @param key
     * @param index
     * @return
     */
    public static String lindex(String key, int index) {
        return SafeEncoder.encode(lindex(SafeEncoder.encode(key), index));
    }

    /**
     * 将List中的第一条记录移出List
     * @param key
     * @return 移出的记录
     */
    public static byte[] lpop(byte[] key) {
        Jedis jedis = getJedis();
        byte[] value = jedis.lpop(key);
        releaseJedis(jedis);
        return value;
    }

    /**
     * 将List中的第一条记录移出List
     * @param key
     * @return 移出的记录
     */
    public static String lpop(String key) {
        return SafeEncoder.encode(lpop(SafeEncoder.encode(key)));
    }

    /**
     * 将List中最后第一条记录移出List
     * @param key
     * @return 移出的记录
     */
    public static String rpop(String key) {
        Jedis jedis = getJedis();
        String value = jedis.rpop(key);
        releaseJedis(jedis);
        return value;
    }

    /**
     * 向List中追加记录
     * @param key
     * @param value
     * @return
     */
    public static long lpush(byte[] key, byte[] value) {
        Jedis jedis = getJedis();
        long count = jedis.lpush(key, value);
        releaseJedis(jedis);
        return count;
    }

    /**
     * 向List中追加记录
     * @param key
     * @param value
     * @return
     */
    public static long lpush(String key, String value) {
        return lpush(SafeEncoder.encode(key), SafeEncoder.encode(value));
    }

    /**
     * 向List头部追加记录
     * @param key
     * @param value
     * @return 记录总数
     */
    public static long rpush(byte[] key, byte[] value) {
        Jedis jedis = getJedis();
        long count = jedis.rpush(key, value);
        releaseJedis(jedis);
        return count;
    }

    /**
     * 向List头部追加记录
     * @param key
     * @param value
     * @return 记录总数
     */
    public static long rpush(String key, String value) {
        Jedis jedis = getJedis();
        long count = jedis.rpush(key, value);
        releaseJedis(jedis);
        return count;
    }

    /**
     * 获取指定范围的记录, 可以做为分页使用
     * @param key
     * @param start
     * @param end
     * @return
     */
    public static List<String> lrange(String key, long start, long end) {
        Jedis jedis = getJedis();
        List<String> list = jedis.lrange(key, start, end);
        releaseJedis(jedis);
        return list;
    }

    /**
     * 获取指定范围的记录, 可以做为分页使用
     * @param key
     * @param start
     * @param end
     * @return
     */
    public static List<byte[]> lrange(byte[] key, int start, int end) {
        Jedis jedis = getJedis();
        List<byte[]> list = jedis.lrange(key, start, end);
        releaseJedis(jedis);
        return list;
    }

    /**
     * 删除List中c条记录，被删除的记录值为value
     * @param key
     * @param c 要删除的数量，如果为负数则从List的尾部检查并删除符合的记录
     * @param value 要匹配的值
     * @return 删除后的List中的记录数
     */
    public static long lrem(byte[] key, int c, byte[] value) {
        Jedis jedis = getJedis();
        long count = jedis.lrem(key, c, value);
        releaseJedis(jedis);
        return count;
    }

    /**
     * 删除List中c条记录，被删除的记录值为value
     * @param key
     * @param c 要删除的数量，如果为负数则从List的尾部检查并删除符合的记录
     * @param value 要匹配的值
     * @return 删除后的List中的记录数
     */
    public static long lrem(String key, int c, String value) {
        return lrem(SafeEncoder.encode(key), c, SafeEncoder.encode(value));
    }

    /**
     * 只保留start与end之间的记录
     * @param key
     * @param start 记录的开始位置(0表示第一条记录)
     * @param end 记录的结束位置（如果为-1则表示最后一个，-2，-3以此类推）
     * @return 执行状态码
     */
    public static String ltrim(byte[] key, int start, int end) {
        Jedis jedis = getJedis();
        String str = jedis.ltrim(key, start, end);
        releaseJedis(jedis);
        return str;
    }

    /**
     * 只保留start与end之间的记录
     * @param key
     * @param start 记录的开始位置(0表示第一条记录)
     * @param end 记录的结束位置（如果为-1则表示最后一个，-2，-3以此类推）
     * @return 执行状态码
     */
    public static String ltrim(String key, int start, int end) {
        return ltrim(SafeEncoder.encode(key), start, end);
    }
}

7.对Set操作

public final class RedisSetUtils {

    private RedisSetUtils() {}

    private static Jedis getJedis() {
        return RedisUtils.getJedis();
    }

    private static void releaseJedis(Jedis jedis) {
        RedisUtils.releaseJedis(jedis);
    }

    /**
     * 向Set添加一条记录，如果member已存在返回0,否则返回1
     * @param key
     * @param member
     * @return 操作码,0或1
     */
    public static long sadd(String key, String member) {
        Jedis jedis = getJedis();
        long s = jedis.sadd(key, member);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 向Set添加一条记录，如果member已存在返回0,否则返回1
     * @param key
     * @param member
     * @return 操作码,0或1
     */
    public static long sadd(byte[] key, byte[] member) {
        Jedis jedis = getJedis();
        long s = jedis.sadd(key, member);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 获取给定key中元素个数
     * @param key
     * @return 元素个数
     */
    public static long scard(String key) {
        Jedis jedis = getJedis();
        long len = jedis.scard(key);
        releaseJedis(jedis);
        return len;
    }

    /**
     * 返回从第一组和所有的给定集合之间的差异的成员
     * @param keys
     * @return 差异的成员集合
     */
    public static Set<String> sdiff(String... keys) {
        Jedis jedis = getJedis();
        Set<String> set = jedis.sdiff(keys);
        releaseJedis(jedis);
        return set;
    }

    /**
     * 这个命令等于sdiff, 但返回的不是结果集, 而是将结果集存储在新的集合中, 如果目标已存在, 则覆盖
     * @param newKey 新结果集的key
     * @param keys 比较的集合
     * @return 新集合中的记录数
     */
    public static long sdiffstore(String newKey, String... keys) {
        Jedis jedis = getJedis();
        long s = jedis.sdiffstore(newKey, keys);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 返回给定集合交集的成员, 如果其中一个集合为不存在或为空，则返回空Set
     * @param keys
     * @return 交集成员的集合
     */
    public static Set<String> sinter(String... keys) {
        Jedis jedis = getJedis();
        Set<String> set = jedis.sinter(keys);
        releaseJedis(jedis);
        return set;
    }

    /**
     * 这个命令等于sinter, 但返回的不是结果集, 而是将结果集存储在新的集合中, 如果目标已存在, 则覆盖
     * @param newKey 新结果集的key
     * @param keys 比较的集合
     * @return 新集合中的记录数
     */
    public long sinterstore(String newKey, String... keys) {
        Jedis jedis = getJedis();
        long s = jedis.sinterstore(newKey, keys);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 确定一个给定的值是否存在
     * @param key
     * @param member 要判断的值
     * @return 存在返回1，不存在返回0s
     */
    public static boolean sismember(String key, String member) {
        Jedis jedis = getJedis();
        boolean s = jedis.sismember(key, member);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 返回集合中的所有成员
     * @param key
     * @return 成员集合
     */
    public static Set<String> smembers(String key) {
        Jedis jedis = getJedis();
        Set<String> set = jedis.smembers(key);
        releaseJedis(jedis);
        return set;
    }

    /**
     * 返回集合中的所有成员
     * @param key
     * @return 成员集合
     */
    public static Set<byte[]> smembers(byte[] key) {
        Jedis jedis = getJedis();
        Set<byte[]> set = jedis.smembers(key);
        releaseJedis(jedis);
        return set;
    }

    /**
     * 将成员从源集合移出放入目标集合, 如果源集合不存在或不包哈指定成员, 不进行任何操作, 返回0
     * 否则该成员从源集合上删除, 并添加到目标集合, 如果目标集合中成员已存在, 则只在源集合进行删除
     * @param srcKey 源集合
     * @param dstKey 目标集合
     * @param member 源集合中的成员
     * @return 状态码，1成功，0失败
     */
    public static long smove(String srcKey, String dstKey, String member) {
        Jedis jedis = getJedis();
        long s = jedis.smove(srcKey, dstKey, member);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 从集合中删除成员
     * @param key
     * @return 被删除的成员
     */
    public static String spop(String key) {
        Jedis jedis = getJedis();
        String s = jedis.spop(key);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 从集合中删除指定成员
     * @param key
     * @param member 要删除的成员
     * @return 状态码 1:success 0:成员不存在
     */
    public static long srem(String key, String member) {
        Jedis jedis = getJedis();
        long s = jedis.srem(key, member);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 合并多个集合并返回合并后的结果, 合并后的结果集合并不保存
     * @param keys
     * @return 合并后的结果集合
     */
    public static Set<String> sunion(String... keys) {
        Jedis jedis = getJedis();
        Set<String> set = jedis.sunion(keys);
        releaseJedis(jedis);
        return set;
    }

    /**
     * 合并多个集合并将合并后的结果集保存在指定的新集合中, 如果新集合已经存在则覆盖
     * @param newKey 新集合的key
     * @param keys 要合并的集合
     * @return
     */
    public static long sunionstore(String newKey, String... keys) {
        Jedis jedis = getJedis();
        long s = jedis.sunionstore(newKey, keys);
        releaseJedis(jedis);
        return s;
    }
}

8.对SortSet操作

public final class RedisSortSetUtils {

    private RedisSortSetUtils() {}

    private static Jedis getJedis() {
        return RedisUtils.getJedis();
    }

    private static void releaseJedis(Jedis jedis) {
        RedisUtils.releaseJedis(jedis);
    }

    /**
     * 向集合中增加一条记录, 如果这个值已存在, 这个值对应的权重将被置为新的权重
     * @param key
     * @param score 权重
     * @param member 要加入的值
     * @return 状态码 1成功，0已存在member的值
     */
    public static long zadd(String key, double score, String member) {
        Jedis jedis = getJedis();
        long s = jedis.zadd(key, score, member);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 获取集合中元素的数量
     * @param key
     * @return 如果返回0则集合不存在
     */
    public static long zcard(String key) {
        Jedis jedis = getJedis();
        long len = jedis.zcard(key);
        releaseJedis(jedis);
        return len;
    }

    /**
     * 获取指定权重区间内集合的数量
     * @param key
     * @param min 最小排序位置
     * @param max 最大排序位置
     * @return
     */
    public static long zcount(String key, double min, double max) {
        Jedis jedis = getJedis();
        long len = jedis.zcount(key, min, max);
        releaseJedis(jedis);
        return len;
    }

    /**
     * 返回指定位置的集合元素 0为第一个元素 -1为最后一个元素
     * @param key
     * @param start 开始位置(包含)
     * @param end 结束位置(包含)
     * @return
     */
    public static Set<String> zrange(String key, int start, int end) {
        Jedis jedis = getJedis();
        Set<String> set = jedis.zrange(key, start, end);
        releaseJedis(jedis);
        return set;
    }

    /**
     * 获得set的长度
     * @param key
     * @return
     */
    public static long zlength(String key) {
        Set<String> set = zrange(key, 0, -1);
        long len = set.size();
        return len;
    }

    /**
     * 权重增加给定值，如果给定的member已存在
     * @param key
     * @param score 要增的权重
     * @param member 要插入的值
     * @return 增后的权重
     */
    public static double zincrby(String key, double score, String member) {
        Jedis jedis = getJedis();
        double s = jedis.zincrby(key, score, member);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 返回指定权重区间的元素集合
     * @param key
     * @param min
     * @param max
     * @return
     */
    public static Set<String> zrangeByScore(String key, double min, double max) {
        Jedis redis = getJedis();
        Set<String> set = redis.zrangeByScore(key, min, max);
        releaseJedis(redis);
        return set;
    }

    /**
     * 获取指定值在集合中的位置，集合排序从低到高
     * @param key
     * @param member
     * @return
     */
    public static long zrank(String key, String member) {
        Jedis jedis = getJedis();
        long index = jedis.zrank(key, member);
        releaseJedis(jedis);
        return index;
    }

    /**
     * 获取指定值在集合中的位置，集合排序从高到低
     * @param key
     * @param member
     * @return
     */
    public static long zrevrank(String key, String member) {
        Jedis jedis = getJedis();
        long index = jedis.zrevrank(key, member);
        releaseJedis(jedis);
        return index;
    }

    /**
     * 从集合中删除成员
     * @param key
     * @param member
     * @return 1:success
     */
    public static long zrem(String key, String member) {
        Jedis jedis = getJedis();
        long s = jedis.zrem(key, member);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 删除
     * @param key
     * @return
     */
    public static long zrem(String key) {
        Jedis jedis = getJedis();
        long s = jedis.del(key);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 删除给定位置区间的元素
     * @param key
     * @param start 开始区间，从0开始(包含)
     * @param end 结束区间,-1为最后一个元素(包含)
     * @return 删除的数量
     */
    public static long zremrangeByRank(String key, int start, int end) {
        Jedis jedis = getJedis();
        long s = jedis.zremrangeByRank(key, start, end);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 删除给定权重区间的元素
     * @param key
     * @param min 下限权重(包含)
     * @param max 上限权重(包含)
     * @return 删除的数量
     */
    public static long zremrangeByScore(String key, double min, double max) {
        Jedis jedis = getJedis();
        long s = jedis.zremrangeByScore(key, min, max);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 获取给定区间的元素，原始按照权重由高到低排序
     * @param key
     * @param start
     * @param end
     * @return
     */
    public static Set<String> zrevrange(String key, int start, int end) {
        Jedis jedis = getJedis();
        Set<String> set = jedis.zrevrange(key, start, end);
        releaseJedis(jedis);
        return set;
    }

    /**
     * 获取给定值在集合中的权重
     * @param key
     * @param member
     * @return
     */
    public static double zscore(String key, String member) {
        Jedis jedis = getJedis();
        Double score = jedis.zscore(key, member);
        releaseJedis(jedis);
        return Objects.isNull(score) ? 0 : score;
    }
}

9.对Hash操作

public final class RedisHashUtils {

    private RedisHashUtils() {}

    private static Jedis getJedis() {
        return RedisUtils.getJedis();
    }

    private static void releaseJedis(Jedis jedis) {
        RedisUtils.releaseJedis(jedis);
    }

    /**
     * 从hash中删除指定的存储
     * @param key
     * @param fieid 存储的名字
     * @return 状态码 1成功 0失败
     */
    public static long hdel(String key, String fieid) {
        Jedis jedis = getJedis();
        long s = jedis.hdel(key, fieid);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 删除某Hash
     * @param key
     * @return
     */
    public static long hdel(String key) {
        Jedis jedis = getJedis();
        long s = jedis.del(key);
        releaseJedis(jedis);
        return s;
    }

    /**
     * hash中指定的存储是否存在
     * @param key
     * @param field 存储的名字
     * @return
     */
    public static boolean hexists(String key, String field) {
        Jedis jedis = getJedis();
        boolean s = jedis.hexists(key, field);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 返回hash中指定存储位置的值
     * @param key
     * @param field 存储的名字
     * @return 存储对应的值
     */
    public static String hget(String key, String field) {
        Jedis jedis = getJedis();
        String s = jedis.hget(key, field);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 返回hash中指定存储位置的值
     * @param key
     * @param fieid
     * @return
     */
    public static byte[] hget(byte[] key, byte[] fieid) {
        Jedis jedis = getJedis();
        byte[] s = jedis.hget(key, fieid);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 以Map的形式返回hash中的存储和值
     * @param key
     * @return
     */
    public static Map<String, String> hgetAll(String key) {
        Jedis jedis = getJedis();
        Map<String, String> map = jedis.hgetAll(key);
        releaseJedis(jedis);
        return map;
    }

    /**
     * 添加一个对应关系
     * @param key
     * @param field
     * @param value
     * @return 状态码 1成功 0失败 field已存在将更新也返回0
     */
    public static long hset(String key, String field, String value) {
        Jedis jedis = getJedis();
        long s = jedis.hset(key, field, value);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 添加一个对应关系
     * @param key
     * @param field
     * @param value
     * @return
     */
    public static long hset(String key, String field, byte[] value) {
        Jedis jedis = getJedis();
        long s = jedis.hset(key.getBytes(), field.getBytes(), value);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 添加对应关系, 只有在field不存在时才执行
     * @param key
     * @param field
     * @param value
     * @return 状态码 1成功 0失败field已存
     */
    public static long hsetnx(String key, String field, String value) {
        Jedis jedis = getJedis();
        long s = jedis.hsetnx(key, field, value);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 获取hash中value的集合
     * @param key
     * @return
     */
    public static List<String> hvals(String key) {
        Jedis jedis = getJedis();
        List<String> list = jedis.hvals(key);
        releaseJedis(jedis);
        return list;
    }

    /**
     * 在指定的存储位置加上指定的数字, 存储位置的值必须可转为数字类型
     * @param key
     * @param field 存储位置
     * @param value 要增加的值, 可以是负数
     * @return 增加指定数字后，存储位置的值
     */
    public static long hincrby(String key, String field, long value) {
        Jedis jedis = getJedis();
        long s = jedis.hincrBy(key, field, value);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 返回指定hash中的所有存储名字, 类似Map中的keySet方法
     * @param key
     * @return 存储名称的集合
     */
    public static Set<String> hkeys(String key) {
        Jedis jedis = getJedis();
        Set<String> set = jedis.hkeys(key);
        releaseJedis(jedis);
        return set;
    }

    /**
     * 获取hash中存储的个数, 类似Map中size方法
     * @param key
     * @return
     */
    public static long hlen(String key) {
        Jedis jedis = getJedis();
        long len = jedis.hlen(key);
        releaseJedis(jedis);
        return len;
    }

    /**
     * 根据多个key, 获取对应的value, 返回List; 如果指定的key不存在, List对应位置为null
     * @param key
     * @param fields
     * @return
     */
    public static List<String> hmget(String key, String... fields) {
        Jedis jedis = getJedis();
        List<String> list = jedis.hmget(key, fields);
        releaseJedis(jedis);
        return list;
    }

    /**
     * 根据多个key, 获取对应的value, 返回List; 如果指定的key不存在, List对应位置为null
     * @param key
     * @param fields
     * @return
     */
    public static List<byte[]> hmget(byte[] key, byte[]... fields) {
        Jedis jedis = getJedis();
        List<byte[]> list = jedis.hmget(key, fields);
        releaseJedis(jedis);
        return list;
    }

    /**
     * 添加对应关系, 如果对应关系已存在, 则覆盖
     * @param key
     * @param map
     * @return 状态, 成功返回OK
     */
    public static String hmset(String key, Map<String, String> map) {
        Jedis jedis = getJedis();
        String s = jedis.hmset(key, map);
        releaseJedis(jedis);
        return s;
    }

    /**
     * 添加对应关系, 如果对应关系已存在，则覆盖
     * @param key
     * @param map
     * @return
     */
    public static String hmset(byte[] key, Map<byte[], byte[]> map) {
        Jedis jedis = getJedis();
        String s = jedis.hmset(key, map);
        releaseJedis(jedis);
        return s;
    }
}

10.总结

这大概是最全的Jedis对Redis的操作工具类，其实很多方法开发中基本用不到，可以作为平时开发的参考。这里还可以通过序列化及泛型对其优化，设置值时一般要设置过期时间等。

源码地址：https://gitee.com/jsjack_wang/JavaDemo