Jedis操作API

Redis越来越常用，是不是还不了解一些常用方法，是不是在处理业务需求时，想不到一些简便方法，赶紧来看看文章吧。废话不多说，上代码！方法没写那么全，后续慢慢完善。

package com.redistest;

import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.Before;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisShardInfo;

public class CacheManager {

    private Jedis jedis;

    @Before
    public void init() {
        this.jedis = new Jedis(new JedisShardInfo("redis IP地址", 6379));
    }

    public String get(final String key) {
        return jedis.get(key);
    }

    public String set(final String key, final String value, final int expire) {
        String ret = jedis.set(key, value);
        if (expire > 0) {
            jedis.expire(key, expire);
        }
        return ret;
    }

    public String set(final String key, final byte[] value, final int expire) {
        String ret = jedis.set(key.getBytes(), value);
        if (expire > 0) {
            jedis.expire(key, expire);
        }
        return ret;
    }

    public byte[] getByte(final String key) {
        byte[] obj = jedis.get(key.getBytes());
        return obj;
    }

    public List<String> mget(final String... keys) {
        List<String> list = jedis.mget(keys);
        return list;
    }

    public String mset(final String... keyValues) {
        String result = jedis.mset(keyValues);
        return result;
    }

    public Long incr(final String key, final int expire) {
        Long ret = jedis.incr(key);
        if (expire > 0) {
            jedis.expire(key, expire);
        }
        return ret;
    }

    public Long incrby(String key, int decrement, int expire) {
        Long ret = jedis.incrBy(key, decrement);
        if (expire > 0) {
            jedis.expire(key, expire);
        }
        return ret;
    }

    public Long decr(final String key, final int expire) {
        if (jedis.exists(key)) {
            Long ret = jedis.decr(key);
            if (expire > 0) {
                jedis.expire(key, expire);
            }
            return ret;
        }
        return null;
    }

    public Long del(final String... keys) {
        Long ret = jedis.del(keys);
        return ret;
    }

    public List<String> lrange(final String key) {
        return lrange(key, 0, -1);
    }

    public List<String> lrange(final String key, final int start, final int end) {
        List<String> list = jedis.lrange(key, start, end);
        return list;

    }

    public long lpush(final int expire, final String key, final String... values) {
        long ret = 0L;
        ret = jedis.lpush(key, values);
        if (expire > 0) {
            jedis.expire(key, expire);
        }
        return ret;
    }

    public void rpush(final int expire, final String key, final String... values) {
        jedis.rpush(key, values);
        if (expire > 0) {
            jedis.expire(key, expire);
        }
    }

    public void lrem(final String key, final String value) {
        lrem(key, 0, value);
    }

    public void lrem(final String key, final int count, final String value) {
        jedis.lrem(key, 0, value);
    }

    /**
     * smembers key 返回集合 key中的所有成员。 不存在的 key被视为空集合。
     */
    public Set<String> smembers(final String key) {
        Set<String> obj = jedis.smembers(key);
        return obj;
    }

    /**
     * sadd key member [member ...] 将一个或多个 member元素加入到key 当中， 已经存在于集合的
     * member元素将被忽略.假如 key不存在，则创建一个包含 member元素作成员的集合
     */
    public long sadd(final String key, final String[] value, final int expire) {
        long ret = 0L;
        ret = jedis.sadd(key, value);
        if (expire > 0) {
            jedis.expire(key, expire);
        }
        return ret;
    }

    public long sadd(final String key, final String value, final int expire) {
        return sadd(key, new String[] { value }, expire);
    }

    /**
     * srem key member [member ...] 移除集合 key中的一个或多个 member元素，不存在的 member元素会被忽略。
     * 当 key不是集合类型，返回一个错误
     */
    public long srem(final String key, final String... value) {
        long ret = 0L;
        ret = jedis.srem(key, value);
        return ret;
    }

    /**
     * sdiff key[key ...]返回一个集合的全部成员，该集合是所有给定集合之间的差集。不存在的 key被视为空集
     */
    public Set<String> sdiff(final String... keys) {
        Set<String> obj = jedis.sdiff(keys);
        return obj;
    }

    /**
     * srandmember key [count] 如果命令执行时，只提供了 key 参数，那么返回集合中的一个随机元素。 从 Redis 2.6
     * 版本开始, SRANDMEMBER 命令接受可选的 count 参数：如果 count 为正数，且小于集合基数，那么命令返回一个包含 count
     * 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。 如果 count
     * 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值.该操作和 spop相似，但 spop
     * 将随机元素从集合中移除并返回，而 srandmember则仅仅返回随机元素，而不对集合进行任何改动
     */
    public List<String> srandmember(String key, int count) {
        List<String> obj = jedis.srandmember(key, count);
        return obj;
    }

    /**
     * scard key 返回集合 key的元素的数量
     */
    public Long scard(String key) {
        Long obj = jedis.scard(key);
        return obj;
    }

    /**
     * sismember key member 判断 member元素是否集合 key的成员。
     */
    public Boolean sismember(String key, String value) {
        Boolean obj = jedis.sismember(key, value);
        return obj;
    }

    public String hmset(final String key, final Map<String, String> map, final int expire) {
        String ret = jedis.hmset(key, map);
        if (expire > 0) {
            jedis.expire(key, expire);
        }
        return ret;
    }

    public Map<String, String> hgetAll(final String key) {
        return jedis.hgetAll(key);
    }

    public Set<String> zrevrangebyscore(final String key, final double max, final double min, final int offset,
            final int count) {
        Set<String> obj = jedis.zrevrangeByScore(key, max, min, offset, count);
        return obj;
    }

    public String hget(final String key, final String field) {
        return jedis.hget(key, field);
    }

    public Long hset(final String key, final String field, final String value) {
        return jedis.hset(key, field, value);
    }

    public Long hdel(final String key, final String... fields) {
        return jedis.hdel(key, fields);
    }

    public Set<String> getKeys(final String pattern) {
        return jedis.keys(pattern);
    }
}