【Redis】手写Redis客户端

　　基于理解了RESP原理的基础上，手写一个Redis客户端，实现一个自己的Jedis（mini版）。

　　RESP参考：【Redis】Redis序列化协议(RESP)

一、简洁版Jedis

分析

1、建立连接
　　SimpleJedis的构造方法，完成建立连接；
　　我们平时使用Jedis时，其实本质也是一样的实现；

// 创建client
Jedis jedis = new Jedis("127.0.0.1", 6379);
// 创建socket连接，发送socket流
String ret = jedis.set("aaa", "11");

 2、set 命令
　　SimpleJedis#set(K, V)方法执行set命令；
　　客户端发给redis-server的序列串，就是按前面的分析，分别替换K的长度和实际K内容，以及V的长度和V的内容； 

3、get 命令
　　get(Key)命令，应该给redis-server发送什么样的协议串呢？
　　这个需要按 上篇文章那样，去拦截TCP传输的数据，以此来窥探。拦截get命令的TCP数据，就不具体演示了，可以参考上一篇文章。

完整示例

public class SimpleJedis {

    private Socket socket = null;

    public SimpleJedis() {
        try {
            socket = new Socket("127.0.0.1", 6379);

            socket.setReuseAddress(true);
            socket.setKeepAlive(true);
            socket.setTcpNoDelay(true);
            socket.setSoLinger(true, 0);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String set(final String key, String value) throws IOException {

        StringBuilder stringBuilder = new StringBuilder();

        stringBuilder.append("*3").append("
");

        stringBuilder.append("$3").append("
");

        stringBuilder.append("SET").append("
");

        stringBuilder.append("$").append(key.length()).append("
");

        stringBuilder.append(key).append("
");

        stringBuilder.append("$").append(value.length()).append("
");

        stringBuilder.append(value).append("
");
        socket.getOutputStream().write(stringBuilder.toString().getBytes());

        InputStream inputStream = socket.getInputStream();
        byte b[] = new byte[1024];
        int len = inputStream.read(b);
        return new String(b, 0, len);
    }

    public String get(final String key) throws IOException {

        StringBuilder sb = new StringBuilder();

        sb.append("*2").append("
");

        sb.append("$3").append("
");

        sb.append("GET").append("
");

        sb.append("$").append(key.length()).append("
");

        sb.append(key).append("
");

        socket.getOutputStream().write(sb.toString().getBytes());

        InputStream inputStream = socket.getInputStream();
        byte b[] = new byte[1024];
        int len = inputStream.read(b);
        return new String(b, 0, len);
    }

    public static void main(String[] args) throws IOException {
        SimpleJedis myJedis = new SimpleJedis();

        System.out.println(myJedis.set("aa", "11"));
        System.out.println("-----------------");
        System.out.println(myJedis.get("aa"));
        System.out.println("-----------------");
    }
}

　　启动redis-server后，运行程序，验证结果

　　

二、进化版Jedis

　　朝着架构师的目标，向前迈一步。一个可复用的客户端组件，应该怎样设计、实现呢！

　　建立连接后 传输数据，是redis规范约定的“协议”。

　　在使用Jedis客户端时，直接操作的是API；执行set、get操作，并没有让我们自己进行按“协议”拼装数据；

　　同时客户端传输数据到server端，对我们使用者来说，也是无感知的。

　　因此我们不妨也分层来实现。

　　要实现一个redis客户端，需要考虑

• 传输层 Connection

• 协议层 RedisProtocol

• API层 RedisClient

　　

1、传输层 Connection

/**
 * 传输层
 * 负责连接的建立，数据发送与接收
 */
public class Connection {


    private Socket socket;
    private String host;
    private int port;
    private OutputStream outputStream;
    private InputStream inputStream;

    public Connection(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public Connection connection() {
        try {
            if (!isConnected()) {
                socket = new Socket(host, port);
                outputStream = socket.getOutputStream();
                inputStream = socket.getInputStream();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return this;
    }

    // 判断是否连接
    private boolean isConnected() {
        return this.socket != null &&
                this.socket.isBound() &&
                !this.socket.isClosed() &&
                socket.isConnected();

    }

    public Connection sendCommand(RedisProtocol.Command command, byte[]... args) {
        connection();
        RedisProtocol.sendCommand(outputStream, command, args);
        return this;
    }

    public String getStatusReply() {
        try {
            byte[] bytes = new byte[1024];
            int len = inputStream.read(bytes);
            return new String(bytes, 0, len);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
} 

 2、协议层 RedisProtocol

/**
 * redis客户端
 * 消息协议层
 */
public class RedisProtocol {

    public static final String DOLLAR_BYTE = "$";
    public static final String ASTERISK_BYTE = "*";
    public static final String BLANK_STRING = "
";

    /**
     * redis操作命令 枚举
     */
    public static enum Command {
        PING, SET, GET
    }

    /**
     * 发送命令
     *
     * @param os
     * @param command
     * @param args
     */
    public static void sendCommand(OutputStream os, Command command, byte[]... args) {
        StringBuffer sb = new StringBuffer();
        sb.append(ASTERISK_BYTE).append(args.length + 1).append(BLANK_STRING);
        sb.append(DOLLAR_BYTE).append(command.name().length()).append(BLANK_STRING);
        sb.append(command.name()).append(BLANK_STRING);

        for (byte[] arg : args) {
            sb.append(DOLLAR_BYTE).append(arg.length).append(BLANK_STRING);
            sb.append(new String(arg)).append(BLANK_STRING);
        }

        try {
            os.write(sb.toString().getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
} 

 3、API层 RedisClient

public class RedisCilent {


    private Connection connection;

    public RedisCilent(String host, int port) {
        connection = new Connection(host, port);
    }


    public String set(String key, String value) {
        connection.sendCommand(RedisProtocol.Command.SET, key.getBytes(), value.getBytes());
        return connection.getStatusReply();
    }


    public String get(String key) {
        connection.sendCommand(RedisProtocol.Command.GET, key.getBytes());
        return connection.getStatusReply();
    }


    public static void main(String[] args) {
        RedisCilent redisCilent = new RedisCilent("127.0.0.1", 6379);
        System.out.println(redisCilent.set("aa", "11"));
        System.out.println("-----------------");
        System.out.println(redisCilent.get("aa"));
        System.out.println("-----------------");
    }
}

4、验证，运行结果如下：

　　

三、举一反三

　　我们经常使用Jedis，对Redis进行各种操作。一番探究下来，其实本质就是客户端程序和服务端建立连接，在指定的端口传输“指令数据”；只是“指令数据”，需要按照约定的格式。

　　Jedis客户端和redis-server之间就是普通的网络通信。特殊之处，就是Redis采用的序列化协议RESP是非二进制、人类可读的。　　

　　其实，其他组件的客户端，也是通过类似的模式；

　　1、MySQL客户端，和mysql-server进行交互，也是通过TCP，默认在3306端口；

　　2、Zookeeper客户端，和server端交互、传输指令，也是通过TCP连接，默认在2181端口；

　　3、……

　　这些客户端和对应server的交互，本身就是基于tcp的一个Request/Response模式。

　　是不是，可以列举很多呢。其实了解了底层原理，一通百通。

　　我们实现的mini版 Jedis，只是实现了最核心的set、get操作；然而对于操作Redis来说，虽然这是最基础、最核心的，但真正完备的Redis客户端，还应该支持 诸如连接断开重试、pipeline管道操作等。

　　但本文的最终目的并不是重复造一个轮子，而是通过对底层原理的研究，做到反推、和验证，进而举一反三。

　　（偷偷告诉你，进阶版Jedis更像Jedis的源码哦~）

参考：https://www.jianshu.com/p/0e9897c9e45c