分析Jedis源码实现操作非关系型数据库Redis

如果测试项目用的maven依赖，先把maven坐标准备好

<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple;

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

/**
 * Jedis工具类
 */
public class JedisUtil {
    private String ip ="127.0.0.1";
    private int port = 8001;
    public JedisUtil(){

    }
    public JedisUtil(String ip,int port){
        this.ip = ip;
        this.port = port;
    }

    /**
     * 获得redis对象
     * @return 获得redis对象
     */
    public Jedis createJedis(){
        Jedis jedis = new Jedis(ip,port);
        return jedis;
    }

    /**
     * 获得redis对象
     * @param ip 连接redis的IP地址
     * @param port 连接redis的端口号
     * @return 获得redis对象
     */
    public Jedis createJedis(String ip,int port){
        Jedis jedis = new Jedis(ip,port);
        return jedis;
    }

    /**
     * 保存字符串
     * @param key
     * @param val
     */
    public void setString(String key,String val){
        createJedis().set(key,val);
    }

    /**
     * 保存二进制
     * @param key
     * @param val
     */
    public void setByte(byte [] key,byte [] val){
        createJedis().set(key, val);
    }


    /**
     * 根据key获得字符串
     * @param key
     * @return
     */
    public String getString(String key){
        return createJedis().get(key);
    }

    /**
     * 获取二进制
     * @param key
     * @return
     */
    public byte [] getByte(byte [] key){
        return createJedis().get(key);
    }


    /**
     * 根据key删除
     * @param key
     */
    public void del(String key){
        createJedis().del(key);
    }

    /**
     * 保存整数
     * @param key
     * @param val
     */
    public void setInt(String key,String val){

    }

    /**
     * 设置过期时间
     * @param key 键
     * @param val 值
     * @param time 过期时间
     */
    public void setexBasic(String key,String val,int time){
        createJedis().setex(key,time,val);
    }

    /**
     * 对二进制key-val设置过期时间
     * @param key
     * @param time
     * @param val
     */
    public void setexCyte(byte [] key,int time,byte [] val){
        createJedis().setex(key,time,val);
    }

    /**
     *设置哈希值
     * @param key
     * @param map
     */
    public void setHash(String key, Map<String,String> map){
        createJedis().hmset(key, map);
    }

    /**
     * 获取哈希值
     * @param key
     * @param field
     * @return
     */
    public String getHash(String key,String field){
        return createJedis().hget(key,field);
    }

    /**
     * 向队列中放数据
     * @param key
     * @param tag 0 左边，1右边
     * @param strings
     */
    public void setQueue(String key,int tag,String...strings){
        if (tag == 0){
            // 左边放
            createJedis().lpush(key,strings);
        }else if (tag == 1){
            // 右边放
            createJedis().rpush(key, strings);
        }
    }

    /**
     * 向队列中获取数据
     * @param key
     * @param tag 0 左边取，1右边取
     * return
     */
    public String getQueue(String key,int tag){
        if (tag == 0){
            // 左边取
            return createJedis().lpop(key);
        }else if (tag == 1){
            // 右边取
            return createJedis().rpop(key);
        }
        return null;
    }

    /**
     * 添加集合
     * @param key
     * @param strings
     */
    public void sadd(String key,String...strings){
        Jedis jedis = createJedis();
        jedis.sadd(key, strings);
        jedis.close();
    }

    /**
     * 获取差集
     * @param strings
     * @return
     */
    public Set<String> sdiff(String...strings){
        Jedis jedis = createJedis();
        Set<String> set = jedis.sdiff(strings);
        jedis.close();
        return set;
    }


    /**
     * 获取交集
     * @param strings
     * @return
     */
    public Set<String> sinter(String...strings){
        Jedis jedis = createJedis();
        Set<String> set = jedis.sinter(strings);
        jedis.close();
        return set;
    }

    /**
     * 添加有序集合
     * @param key
     * @param map
     */
    public void zadd(String key,Map<String,Double> map){
        Jedis jedis = createJedis();
        jedis.zadd(key, map);
        jedis.close();
    }

    /**
     * 给元素增量
     * @param key
     * @param score
     * @param member
     * @return 增量后的数
     */
    public Double zincreby(String key,double score,String member){
        Jedis jedis = createJedis();
        Double d =  jedis.zincrby(key, score, member);
        return d;
    }

    /**
     * 返回升序排列的集合
     * @param key
     * @return
     */
    public Set<String> zrange(String key){
        Jedis jedis = createJedis();
        Set<String> set = jedis.zrange(key,0,-1);
        return  set;
    }


    /**
     * 返回降序排列的集合
     * @param key
     * @return
     */
    public Set<String> zrevrange(String key){
        Jedis jedis = createJedis();
        Set<String> set = jedis.zrevrange(key,0,-1);
        return set;
    }

    /**
     * 返回降序排序的集合，带上分数
     * @param key
     * @return
     */
    public Set<Tuple> zrevrangeWithScores(String key){
        Jedis jedis = createJedis();
        Set<Tuple> set = jedis.zrevrangeWithScores(key,0,-1);
        return set;
    }

}