手寫Redis客戶端-實現自己的Jedis

上一篇，我們詳細研究了Redis底層使用的協議——RESP(REdis Serialization Protocol)，這篇我們在基於理解了RESP原理的基礎上，手寫一個Redis客戶端，實現一個自己的Jedis（mini版）。
還沒了解Redis底層RESP協議的同學，可以先移步Redis底層協議RESP詳解，對RESP做一個大致的瞭解。

Redis分爲服務器端/客戶端，並且客戶端除了CLI終端命令行方式，還支持大多數主流編程語言；那麼可以大膽推測，這些跨語言的客戶端的實現，都是遵循RESP協議規範的；也都是通過網絡通信、與服務器端進行連接和傳輸數據的。

RESP回顧

RESP在Redis中用作請求-響應協議的方式如下：

客戶端將命令作爲Bulk Strings的RESP數組發送到Redis服務器。
服務器根據命令實現回覆一種RESP類型。

在RESP中，某些數據的類型取決於第一個字節：

“+”代表簡單字符串Simple Strings
“+”代表錯誤類型
“:”代表整數
“$”代表Bulk Strings
“*”代表數組
此外，RESP能夠使用稍後指定的Bulk Strings或Array的特殊變體來表示Null值。
在RESP中，協議的不同部分始終以“\r\n”（CRLF）結束。

通過攔截TCP傳輸的數據，我們在redis-cli客戶端執行SET key value ;
攔截到對應的resp通信協議串

*3
$3
SET
$3
key
$5
value

基於上篇對RESP的分析，我們應該能快速推斷，如果要執行SET abc 1234，對應的resp通信協議串爲：

*3
$3
SET
$3
abc
$4
1234

原理其實很簡單；我們實現的客戶端，只要將這個協議串，基於socket發送給redis-server，進完成了一個set操作，在redis-server執行了SET abc 1234;
按resp協議的請求-響應模型，如果redis-server執行成功，會返回+OK\r\n；

簡潔版Jedis

下面，我們基於以上推斷，快速實現一個簡潔版Redis客戶端；

分析：

1、建立連接
SimpleJedis的構造方法，完成建立連接；
我們平時使用Jedis時，其實本質也是一樣的實現；

Jedis jedis = new Jedis("172.17.19.22");//創建client
jedis.set("key", "value");//創建socket連接，發送socket流

2、set 命令
SimpleJedis#set(K, V)方法執行set命令；
客戶端發給redis-server的序列串，就是按前面的分析，分別替換K的長度和實際K內容，以及V的長度和V的內容；

3、get 命令
get(Key)命令，應該給redis-server發送什麼樣的協議串呢？
這個需要按上篇文章那樣，去攔截TCP傳輸的數據，以此來窺探。攔截get命令的TCP數據，就不具體演示了，可以參考上一篇文章。
這裏我直接給出結論；
當執行 get abc;命令時，發送給redis-server的協議串是：

*2
$3
GET
$3
abc

第一行*2表示這條發給Redis server的命令是數組，數組有2個元素(其實就是get、abc、這倆字符串)；
後面的4行數據，分別是對數組2個元素的表示，每個元素用兩行；具體含義可以參見上一篇文章。

最後給出完整示例：

/**
 * 簡潔版-Redis客戶端
 * A new redis client for Java.
 */
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("\r\n");

        stringBuilder.append("$3").append("\r\n");

        stringBuilder.append("SET").append("\r\n");

        stringBuilder.append("$").append(key.length()).append("\r\n");

        stringBuilder.append(key).append("\r\n");

        stringBuilder.append("$").append(value.length()).append("\r\n");

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

        InputStream inputStream = socket.getInputStream();
        byte b[] = new byte[inputStream.available()];
        inputStream.read(b);
        return new String(b);
    }

    public String get(final String key) throws IOException {

        StringBuilder sb = new StringBuilder();

        sb.append("*2").append("\r\n");

        sb.append("$3").append("\r\n");

        sb.append("GET").append("\r\n");

        sb.append("$").append(key.length()).append("\r\n");

        sb.append(key).append("\r\n");

        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).split("\r\n")[1];
    }

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

        System.out.println(myJedis.set("mt", "2020"));//+OK
        System.out.println(myJedis.get("mt"));// "2020"
    }
}

啓動redis-server後，運行程序，就能驗證結果了。

進化版

朝着架構師的目標，向前邁一步。一個可複用的客戶端組件，應該怎樣設計、實現呢！

建立連接後傳輸數據，是redis規範約定的“協議”。
我們在使用Jedis客戶端時，直接操作的是API；執行set、get操作，並沒有讓我們自己進行按“協議”拼裝數據；
同時客戶端傳輸數據到server端，對我們使用者來說，也是無感知的。
因此我們不妨也分層來實現。

要實現一個redis客戶端，需要考慮

傳輸層 Connection
協議層 RedisProtocol
API層 RedisClient

以下是對應的實現:

傳輸層 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 {
            socket = new Socket(host, port);
            outputStream = socket.getOutputStream();
            inputStream = socket.getInputStream();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return this;
    }

    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];
            inputStream.available();
            int len = inputStream.read(bytes);
            return new String(bytes, 0, len);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

協議層 RedisProtocol

負責RESP協議串的拼裝；

/**
 * redis客戶端
 * 消息協議層
 */
public class RedisProtocol {

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

    /**
     * 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();
        }
    }
}

API層 RedisClient

頂層API，供用戶使用；

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 cilent = new RedisCilent("127.0.0.1", 6379);
        System.out.println(cilent.set("mt", "2011"));
        System.out.println(cilent.get("mt"));
    }
}

舉一反三

我們經常使用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的源碼哦~）

本文首發於公衆號架構道與術(ToBeArchitecturer)，歡迎關注、共同進步~

關注公衆號，回覆redis，獲得完整源碼。

手寫Redis客戶端-實現自己的Jedis

手寫Redis客戶端-實現自己的Jedis

RESP回顧

簡潔版Jedis

分析：

進化版

傳輸層 Connection

協議層 RedisProtocol

API層 RedisClient

舉一反三

Spring Cloud 部署時如何使用 Kubernetes 作爲註冊中心和配置中心

Phaser多任務協同的神器

終於有人把Java內存模型(JMM)說清楚了

Redis底層協議RESP詳解

手寫Redis客戶端-實現自己的Jedis

開闢鴻蒙，聊聊華爲微內核

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結