Jedis

jedis是redis的java客户端，而要实现一个自定义的redis客服端需要了解redis的自定义应用层协议resp协议。

RESP协议

resp是redis的自定义应用层协议，传输层基于tcp实现。

优点

1. 简单好实现
2. 能快速解析
3. 肉眼可读
   

请求-相应模型

一般来说是一问一答，redis服务器接收不同参数组成的命令，处理完后返回给客服端。
一些特殊场景

1. redis请求可以管道化，允许客服端一次发送多个请求，然后等待响应。
2. 客服端订阅的通道，当resp2连接订阅了pub/sub通道，该协议将变成推送协议，客户端不再需要发送命令，因为服务器将在接收到新消息后自动推送给客服端。
3. 调用momitor命令会切换到zd-hoc-push模式，这种模式的协议没有指定，但很容易解析
4. 在保护模式下，非环回Ip请求redis的连接会被服务器拒绝
5. resp3的推送类型（push type)允许服务器向连接发送带外数据，服务器可以随时推送数据，并且推送的数据不一定和客户端执行的特定命令相关。、
   

resp协议描述

resp本质上是一个支持多种数据类型的序列化协议，在resp中，数据的第一个字节决定了他的类型。
客户端以批量字符串数组（array of bulk strings)形式向redis服务器发送命令，数组的第一个bulk string是命令名称，数组后续元素是该命令的参数，服务器返回一个resp类型。应答的类型由命令决定，也可能由客户端的协议版本决定。resp是一个二进制协议，使用ascii编码，\r\n是协议的终止符。我们将resp数据类型分为简单（simple)，批量（bulk)和聚合（aggregate)。simple类型传输文本，如Boolean，Integer；bulk类型可以传输二进制数据，所以bulk strings需要客户端进一步编码和解码；aggregate类型，如数组，映射可以有不同数量的子元素和嵌套级别。

因此redis客服端需要按照上述格式，构造出字符串往socket中写，从socket中读取字符串按照上述格式解析。

引入Jedis前置工作

我们不必按照上述协议，进行解析/构造字符串，咱们直接使用jedis库，就可以完成和redis服务器通信的操作。

引入jedis依赖

<dependency>
  <groupId>redis.clientsgroupId>
  <artifactId>jedisartifactId>
  <version>4.4.2version>
dependency>

选择一个相对较新的版本即可

配置端口转发

redis服务器安装在云服务上，而我们编写的代码则是本地主机。需要进行端口转发，直接把服务器的redis端口映射到本地。

还有一种解决方法，就是通过访问公网Ip，并且开放redis的端口，但是这个操作非常危险，因为redis的端口非常容易被黑客攻击

因此我们要配置ssh端口转发，把云服务器的redis端口，映射到本地主机。

1. 打开连接

2. 选择隧道，添加

3. 配置端口转发

4. 验证

配置完端口转发，要端口之前的连接，重新连接才能生效。然后打开cmd

使用jedis

jedis最简单的程序

public static void main(String[] args) {
    // 连接redis服务器，8888是我们配置的端口转发
    // 这里的url只是开发阶段才这样写，等程序部署上线后，
    // 要按照云服务器的实际情况来写 ip和端口
    JedisPool jedisPool = new JedisPool("tcp://127.0.0.1:8888");
    //从redis连接池中获取一个连接，并且使用完要释放
    try(Jedis jedis = jedisPool.getResource()) {
        String pong = jedis.ping();
        System.out.println(pong);
    }
}

这个报错没有关系，不影响使用，忽略即可

五种数据类型

全局命令

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.params.SetParams;

import java.util.Set;

public class RedisDemoNormal {
    /**
     * get和set的使用
     * @param jedis
     */
    private static void test1(Jedis jedis) {
        System.out.println("get和set的使用");
        //清空数据库，避免上一组测试的数据影响下一组测试的结果
        jedis.flushAll();
        jedis.set("key", "111");
        jedis.set("key2", "222");

        String value1 = jedis.get("key");
        String value2 = jedis.get("key2");
        System.out.println("value1=" + value1);
        System.out.println("value2=" + value2);
        // 设置参数
        SetParams params = new SetParams();
        params.ex(10);
        params.xx();
        jedis.set("key", "3333");
        String value3 = jedis.get("key");
        System.out.println("value3=" + value3);
    }

    /**
     * exists和del的使用
     * @param jedis
     */
    private static void test2(Jedis jedis) {
        System.out.println("exists和del的使用");
        jedis.flushAll();

        jedis.set("key", "111");
        jedis.set("key2", "222");
        jedis.set("key3", "333");

        boolean result = jedis.exists("key");
        System.out.println("result:" + result);

        long result2 = jedis.del("key");
        System.out.println("result2:" + result2);

        result = jedis.exists("key");
        System.out.println("result:" + result);

        result2 = jedis.del("key", "key2", "key3");
        System.out.println("result2:" + result2);
    }

    /**
     * keys的使用
     * @param jedis
     */
    private static void test3(Jedis jedis) {
        System.out.println("keys的使用");
        jedis.flushAll();

        jedis.set("key", "111");
        jedis.set("key2", "222");
        jedis.set("key3", "333");
        // redis中的key不能重复，并且没有顺序
        Set<String> keys = jedis.keys("*");
        System.out.println(keys);
    }

    /**
     * expire和ttl的使用
     * @param jedis
     */
    private static void test4(Jedis jedis) {
        System.out.println("expire和ttl的使用");
        jedis.flushAll();

        jedis.set("key", "111");
        jedis.expire("key", 10);
        long time = jedis.ttl("key");
        System.out.println("time:" + time);
    }

    /**
     * type的使用
     * @param jedis
     */
    private static void test5(Jedis jedis) {
        System.out.println("type的使用");
        jedis.flushAll();
        // string
        jedis.set("key", "111");
        String type = jedis.type("key");
        System.out.println("type:" + type);
        // list
        jedis.lpush("key2", "111", "222", "333");
        type = jedis.type("key2");
        System.out.println("type:" + type);
        //hash
        jedis.hset("key3", "f1", "111");
        type = jedis.type("key3");
        System.out.println("type:" + type);
        // set
        jedis.sadd("key4", "111", "222", "333");
        type = jedis.type("key4");
        System.out.println("type:" + type);
        // zset
        jedis.zadd("key5", 10, "zhangsan");
        type = jedis.type("key5");
        System.out.println("type:" + type);

    }
    public static void main(String[] args) {
        JedisPool jedisPool = new JedisPool("tcp://127.0.0.1:8888");
        try(Jedis jedis = jedisPool.getResource()) {
            //test1(jedis);
            //test2(jedis);
            //test3(jedis);
            //test4(jedis);
            test5(jedis);
        }
    }
}

执行结果

string类型

public class RedisDemoString {
    /**
     * mset和mget的使用
     * @param jedis
     */
    private static void test1(Jedis jedis) {
        System.out.println("mset和mget的使用");
        jedis.flushAll();

        jedis.mset("key1", "111", "key2", "222", "key3", "333");
        List<String> values = jedis.mget("key1", "key2", "key3");
        System.out.println("values:" + values);
    }

    /**
     * setrange和getrange使用
     * @param jedis
     */
    private static void test2(Jedis jedis) {
        System.out.println("setrange和getrange的使用“");
        jedis.flushAll();

        jedis.set("key", "abcdefghijk");
        String result = jedis.getrange("key", 2, 4);
        System.out.println("result:" + result);
        jedis.setrange("key", 2, "xyz");
        String result2 = jedis.getrange("key", 2, 4);
        System.out.println("result2:" + result2);
    }

    /**
     * append的使用
     * @param jedis
     */
    private static void test3(Jedis jedis) {
        System.out.println("append的使用");
        jedis.flushAll();

        jedis.set("key", "abc");
        jedis.append("key", "def");

        String value = jedis.get("key");
        System.out.println("value:" + value);
    }

    /**
     * incr和decr的使用
     * @param jedis
     */
    private static void test4(Jedis jedis) {
        System.out.println("incr和decr的使用");
        jedis.flushAll();

        jedis.set("key", "100");
        long result = jedis.incr("key");
        System.out.println("result：" + result);

        String value = jedis.get("key");
        System.out.println("value:" + value);

        result = jedis.decr("key");
        System.out.println("result:" + result);

        value = jedis.get("key");
        System.out.println("value" + value);

    }
    public static void main(String[] args) {
        JedisPool jedisPool = new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis = jedisPool.getResource()) {
            test1(jedis);
            test2(jedis);
            test3(jedis);
            test4(jedis);
        }
    }
}

执行结果

list类型

public class RedisDemoList {
    /**
     * lpush和lrange的使用
     * @param jedis
     */
    private static void test1(Jedis jedis) {
        System.out.println("lpush和lrange使用");
        jedis.flushAll();

        jedis.lpush("key", "111", "222", "333");

        List<String> result = jedis.lrange("key", 0, -1);
        System.out.println(result);
    }

    /**
     * rpush的使用
     * @param jedis
     */
    private static void test2(Jedis jedis) {
        System.out.println("rpush的使用");
        jedis.flushAll();

        jedis.rpush("key", "111", "222", "333");

        List<String> result = jedis.lrange("key", 0, -1);
        System.out.println("result:" + result);
    }

    /**
     * lpop和rpop的使用
     * @param jedis
     */
    private static void test3(Jedis jedis) {
        System.out.println("lpop和rpop");
        jedis.flushAll();

        jedis.rpush("key", "111", "222", "333");
        String result = jedis.lpop("key");
        System.out.println("result:" + result);
        String result2 = jedis.rpop("key");
        System.out.println("resul2:" + result2);
    }

    /**
     * blpop的使用
     * @param jedis
     */
    private static void test4(Jedis jedis) {
        System.out.println("blpop的使用");
        jedis.flushAll();
        // 返回结果是一个“二元组”，第一个是从哪个key对应的list中删除，第二个是删除元素是什么
        List<String> results = jedis.blpop(100, "key");
        // 此时会阻塞等待，通过linux打开redis-cli，往key中添加元素即可
        System.out.println("results[0]:" + results.get(0));
        System.out.println("results[1]:" + results.get(1));
    }

    /**
     * llen的使用
     * @param jedis
     */
    private static void test5(Jedis jedis) {
        System.out.println("llen");
        jedis.flushAll();
        jedis.rpush("key", "111", "222", "333");
        long llen = jedis.llen("key");
        System.out.println("len:" + llen);
    }
    public static void main(String[] args) {
        JedisPool jedisPool = new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis = jedisPool.getResource()){
            test1(jedis);
            test2(jedis);
            test3(jedis);
            test4(jedis);
            test5(jedis);
        }
    }
}

hash类型

public class RedisDemoHash {
    /**
     *
     * @param jedis
     */
    private static void test1(Jedis jedis) {
        System.out.println("hset和hget");
        jedis.flushAll();
        // 只添加一个value
        jedis.hset("key", "f1", "111");
        // 添加多个value
        Map<String, String> fields = new HashMap<>();
        fields.put("f2", "222");
        fields.put("f3", "333");
        jedis.hset("key", fields);

        String result = jedis.hget("key", "f1");
        System.out.println("result:" + result);

        result = jedis.hget("key", "f2");
        System.out.println("result:" + result);

        result = jedis.hget("key", "f100");
        System.out.println("result:" + result);
    }

    /**
     * hexists使用
     * @param jedis
     */
    private static void test2(Jedis jedis) {
        System.out.println("hexists使用");
        jedis.flushAll();

        Map<String, String> fields = new HashMap<>();
        fields.put("f1", "111");
        fields.put("f2", "222");
        fields.put("f3", "333");
        jedis.hset("key", fields);

        boolean result = jedis.hexists("key", "f1");
        System.out.println("result:" + result);

        result = jedis.hexists("key", "f100");
        System.out.println("reshult:" + result);
    }

    /**
     * hdel的使用
     * @param jedis
     */
    private static void test3(Jedis jedis) {
        System.out.println("hdel的使用");
        jedis.flushAll();

        jedis.hset("key", "f1", "111");
        jedis.hset("key", "f2", "222");

        long result = jedis.hdel("key", "f1", "f2");
        System.out.println("result:" + result);

        boolean exists = jedis.hexists("key", "f1");
        System.out.println("exists:" + exists);
        exists = jedis.hexists("key", "f2");
        System.out.println("exists:" + exists);
    }

    /**
     * hkeys和kvals的使用
     * @param jedis
     */
    private static void test4(Jedis jedis) {
        System.out.println("hkeys和hvals的使用");
        jedis.flushAll();

        jedis.hset("key", "f1", "111");
        jedis.hset("key", "f2", "222");
        jedis.hset("key", "f3", "333");

        Set<String> fields = jedis.hkeys("key");
        List<String> vals = jedis.hvals("key");
        System.out.println("fields:" + fields);
        System.out.println("vals:"+ vals);
    }

    /**
     * hmget和hmset的使用
     * @param jedis
     */
    private static void test5(Jedis jedis) {
        System.out.println("hmget和hmset的使用");
        jedis.flushAll();

        Map<String, String> fields = new HashMap<>();
        fields.put("f1", "111");
        fields.put("f2", "222");
        fields.put("f3", "333");
        jedis.hmset("key", fields);

        List<String> values = jedis.hmget("key", "f1", "f2", "f3");
        System.out.println("values:" + values);

    }
    public static void main(String[] args) {
        JedisPool jedisPool = new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis = jedisPool.getResource()){
            test1(jedis);
            test2(jedis);
            test3(jedis);
            test4(jedis);
            test5(jedis);
        }
    }
}

执行结果：

set类型

public class RedisDemoSet {
    /**
     * sadd和smembers的使用
     * @param jedis
     */
    private static void test1(Jedis jedis) {
        System.out.println("sadd和smembers的使用");
        jedis.flushAll();

        jedis.sadd("key", "111", "222", "333");
        Set<String> result = jedis.smembers("key");
        System.out.println("result:" + result);
    }

    /**
     * sismember和scard的使用
     * @param jedis
     */
    private static void test2(Jedis jedis) {
        System.out.println("sismember和scard的使用");
        jedis.flushAll();

        jedis.sadd("key", "111", "222", "333");
        boolean result = jedis.sismember("key", "100");
        System.out.println("result: " + result);

        long len = jedis.scard("key");
        System.out.println("len:" + len);
    }

    /**
     * spop使用
     * @param jedis
     */
    private static void test3(Jedis jedis) {
        System.out.println("spop使用");
        jedis.flushAll();

        jedis.sadd("key", "111", "222", "333");
        String result = jedis.spop("key");
        System.out.println("result:" + result);
    }

    /**
     * sinter的使用
     * @param jedis
     */
    private static void test4(Jedis jedis) {
        System.out.println("sinter的使用");
        jedis.flushAll();

        jedis.sadd("key", "111", "222", "333");
        jedis.sadd("key2", "222", "333", "444");

        Set<String> result = jedis.sinter("key", "key2");
        System.out.println("result:" + result);
    }

    /**
     * sinterstore的使用
     * @param jedis
     */
    private static void test5(Jedis jedis) {
        System.out.println("sinterstore使用");
        jedis.flushAll();

        jedis.sadd("key", "111", "222", "333");
        jedis.sadd("key2", "111", "333", "444");
        long len = jedis.sinterstore("key3", "key", "key2");
        System.out.println("len:" + len);

        Set<String> result = jedis.smembers("key3");
        System.out.println("result:" + result);
    }
    public static void main(String[] args) {
        JedisPool jedisPool = new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis = jedisPool.getResource()){
            test1(jedis);
            test2(jedis);
            test3(jedis);
            test4(jedis);
            test5(jedis);
        }
    }
} 

执行结果：

zset类型

public class RedisDemoZSet {
    /**
     * zadd和zrange的使用
     * @param jedis
     */
    private static void test1(Jedis jedis) {
        System.out.println("zadd和zrange的使用");
        jedis.flushAll();
        // 添加一个value
        jedis.zadd("key", 10, "zhangsan");
        // 添加多个value
        Map<String, Double> map = new HashMap<>();
        map.put("lisi", 20.0);
        map.put("wangwu", 30.0);
        jedis.zadd("key", map);

        List<String> members = jedis.zrange("key", 0, -1);
        System.out.println("members:" + members);
        // 获取zset的value要借助jedis封装的Tuple类型
        List<Tuple> membersWithScore = jedis.zrangeWithScores("key", 0, -1);
        System.out.println("membersWithScore:" + membersWithScore);
        String member = membersWithScore.get(0).getElement();
        double score = membersWithScore.get(0).getScore();
        System.out.println("member:" + member + ", score:" + score);
    }

    /**
     * zcard的使用
     * @param jedis
     */
    private static void test2(Jedis jedis) {
        System.out.println("zcard的使用");
        jedis.flushAll();

        Map<String, Double> map = new HashMap<>();
        map.put("zhangsan", 10.0);
        map.put("lisi", 20.0);
        map.put("wangwu", 30.0);

        jedis.zadd("key", map);
        long len = jedis.zcard("key");
        System.out.println("len:" + len);
    }

    /**
     * zrem的使用
     * @param jedis
     */
    private static void test3(Jedis jedis) {
        System.out.println("zrem的使用");
        jedis.flushAll();

        jedis.zadd("key", 10, "zhangsan");
        jedis.zadd("key", 20, "lisi");
        jedis.zadd("key", 30, "wangwu");

        long count = jedis.zrem("key", "zhangsan", "lisi");
        System.out.println("count:" + count);

        List<Tuple> result = jedis.zrangeWithScores("key", 0, -1);
        System.out.println("result:" + result);
    }

    /**
     * zscore的使用
     * @param jedis
     */
    private static void test4(Jedis jedis) {
        System.out.println("zscore的使用");
        jedis.flushAll();

        jedis.zadd("key", 10, "zhangsan");
        jedis.zadd("key", 20, "lisi");
        jedis.zadd("key", 30, "wangwu");

        Double score = jedis.zscore("key", "zhangsan");
        System.out.println("score: " + score);
    }

    /**
     * zrank的使用
     * @param jedis
     */
    private static void test5(Jedis jedis) {
        System.out.println("zrank的使用");
        jedis.flushAll();

        jedis.zadd("key", 10, "zhangsan");
        jedis.zadd("key", 20, "lisi");
        jedis.zadd("key", 30, "wangwu");

        Long rank = jedis.zrank("key", "zhangsan");
        System.out.println("rank:" + rank);

    }
    public static void main(String[] args) {
        JedisPool jedisPool = new JedisPool("tcp://127.0.0.1:8888");
        try (Jedis jedis = jedisPool.getResource()) {
            test1(jedis);
            test2(jedis);
            test3(jedis);
            test4(jedis);
            test5(jedis);
        }

    }
}

执行结果：