手写Redis客户端

清疚 2023-07-15 05:53 9阅读 0赞

## 一、前言 ##

要想手写Redis客户端，必须先了解清楚Redis的通信协议是什么。我的理解就是客户端与服务端按照双方约定的规则来进行的编码方式，客户端将要发送的命令进行编码，然后服务端收到后，使用同样的协议进行解码，服务端处理完成后，再次编码返回给客户端，客户端解码拿到返回结果，这样就完成了一次通信。博主这里为了方便小伙伴们理解，画了一张客户端与服务端通信的结构图，如下：

![在这里插入图片描述][20200315163028174.png]  
理解了这个通信结构图，我们再来揭开Redis通信协议的神秘面纱——RESP。

## 二、什么是RESP？ ##

参考 [Redis官方解释][Redis]

全是英文？没关系，博主这里提取重点来解释一下。

`RESP`是基于`TCP`的应用层协议 `RESP(Redis Serialization Protocol)`；

`RESP`底层采用的是`TCP`的连接方式，通过`TCP`进行数据传输，然后根据解析规则解析相应的信息,

`Redis` 的客户端和服务端之间正是采取的`RESP`的协议来实现通信的。

`Redis` 协议在以下三个目标之间进行折中：

*  易于实现
 *  解析高效
 *  人类可读

`RESP`可以序列化不同的数据类型，如整数，字符串，数组。还有一种特定的错误类型。请求从客户端发送到`Redis`服务器，作为表示要执行的命令的参数的字符串数组。Redis使用特定于命令的数据类型进行回复。

`RESP`是二进制安全的，不需要处理从一个进程传输到另一个进程的批量数据，因为它使用前缀长度来传输批量数据。

注意：`RESP` 虽然是为 `Redis` 设计的，但是同样也可以用于其他 `C/S` 的软件。`Redis Cluster`使用不同的二进制协议(Gossip)，以便在节点之间交换消息。

--------------------

**1、Redis通信协议**

*  客户端和服务器通过 `TCP` 连接来进行数据交互， 服务器默认的端口号为 `6379` 。
 *  客户端和服务器发送的命令或数据一律以 `\r\n` （`CRLF`）结尾。
 *  在这个协议中， 所有发送至 `Redis` 服务器的参数都是二进制安全（`binary safe`）的。

**2、请求协议**

*<参数数量> CRLF
    $<参数 1 的字节数量> CRLF
    <参数 1 的数据> CRLF
    ...
    $<参数 N 的字节数量> CRLF
    <参数 N 的数据> CRLF

举个例子， 以下是一个命令协议的打印版本：

*3
    $3
    SET
    $5
    mykey
    $7
    myvalue

这个命令的实际协议值如下：

"*3\r\n$3\r\nSET\r\n$5\r\nmykey\r\n$7\r\nmyvalue\r\n"

**3、返回协议**

Redis 命令会返回多种不同类型的回复。

通过检查服务器发回数据的第一个字节， 可以确定这个回复是什么类型：

*  状态回复（status reply）的第一个字节是 “`+`”
 *  错误回复（error reply）的第一个字节是 “`-`”
 *  整数回复（integer reply）的第一个字节是 “`:`”
 *  批量回复（bulk reply）的第一个字节是 “`$`”
 *  多条批量回复（multi bulk reply）的第一个字节是 “`*`”

**4、状态回复**

一个状态回复（或者单行回复，single line reply）是一段以 “`+`” 开始、 “`\r\n`” 结尾的单行字符串。

以下是一个状态回复的例子：

+OK

先把这几个主要的先介绍下吧，剩下的可以参考 [http://doc.redisfans.com/topic/protocol.html][http_doc.redisfans.com_topic_protocol.html] 这个`Redis`中文翻译版。

## 三、Redis的客户端Jedis ##

手写之前我们还是先来看下我们用的比较多的`Jedis`是如何连接后台`Redis`服务的。

**1、添加`Jedis`的`Maven`配置**

<dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>

**2、通过`Jedis`往`Redis`set值**

public static void main(String[] args) { 
        Jedis jedis = new Jedis("192.168.0.105", 6379);
        jedis.set("riemann", "0328");
        System.out.println(client.get("riemann"));
    }

**3、注意**

如果出现下面的异常的话：

redis.clients.jedis.exceptions.JedisConnectionException: java.net.SocketTimeoutException: connect timed out

(1)、linux执行下面命令，开放6379端口：

/sbin/iptables -I INPUT -p tcp --dport 6379 -j ACCEPT

(2)、关闭redis的保护模式

vim redis.conf

修改为：

protected-mode no

**4、返回信息**

0328

## 四、手写Redis客户端 ##

我们在使用`Jedis`客户端时，直接操作的是`API`；执行`set、get`操作，并没有让我们自己进行按“协议”拼装数据；  
同时客户端传输数据到`server`端，对我们使用者来说，也是无感知的。  
因此我们不妨也分层来实现。

要实现一个`Redis`客户端，需要考虑：

传输层 Connection

*  传输层 RiemannRedisConnection
 *  协议层 RiemannProtocal
 *  API层 RiemannRedisClient

![在这里插入图片描述][20200315174039680.png]  
画好了这个结构图，我们接下来就用代码来实现一下：

**1、传输层 RiemannRedisConnection**

负责连接的建立，数据发送与接收。

/** * 传输层 RiemannRedisConnection * 负责连接的建立，数据发送与接收。 */
    public class RiemannRedisConnection { 
    
        private Socket socket;
        private String host;
        private Integer port;
        private OutputStream outputStream;
        private InputStream inputStream;
    
        public RiemannRedisConnection(String host, Integer port) { 
            this.host = host;
            this.port = port;
        }
    
        /** * 建立连接 * @return */
        public RiemannRedisConnection connection() { 
            try { 
                socket = new Socket(host, port);
                outputStream = socket.getOutputStream();
                inputStream = socket.getInputStream();
            } catch (IOException e) { 
                e.printStackTrace();
            }
            return this;
        }
    
        /** * 向redis-server服务端发送操作命令 * @param command * @param args * @return */
        public RiemannRedisConnection sendCommand(RiemannCommand command, byte[]... args) { 
            connection();
            RiemannProtocal.sendCommand(outputStream, command, args);
            return this;
        }
    
        /** * redis-server服务端端给的响应 * @return */
        public String response() { 
            byte[] bytes = new byte[1024];
            try { 
                inputStream.available();
                inputStream.read(bytes);
            } catch (IOException e) { 
                e.printStackTrace();
            }
            return new String(bytes, Charset.defaultCharset());
        }
    }

**2、协议层 RiemannProtocal**

负责`RESP`协议串的拼装

/** * 协议层 RiemannProtocal * 负责RESP协议串的拼装 */
    public class RiemannProtocal { 
    
        public static final String DOLLER = "$";
        public static final String ALLERSTIC = "*";
        public static final String CRLF = "\r\n";
    
        /** * 如SET请求 set riemann 0328 * * *3\r\n 长度为3的数组 * $3\r\n 第一个字符串长度为3 * SET\r\n 第一个字符串为SET * $7\r\n 第二个字符串长度为7 * riemann\r\n 第二个字符串为riemann * $4\r\n 第三个字符串长度为4 * 0328\r\n 第三个字符串为0328 * @param os * @param command * @param args */
        public static void sendCommand(OutputStream os, RiemannCommand command, byte[]... args) { 
            StringBuilder sb = new StringBuilder();
            // todo 封装该数组的长度
            sb.append(ALLERSTIC).append(args.length + 1).append(CRLF);
            // todo 封装方法SET、GET
            sb.append(DOLLER).append(command.name().length()).append(CRLF);
            sb.append(command.name()).append(CRLF);
            // todo 封装参数
            for (byte[] arg : args) { 
                sb.append(DOLLER).append(arg.length).append(CRLF);
                sb.append(new String(arg)).append(CRLF);
            }
            try { 
                os.write(sb.toString().getBytes());
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    }

**3、API层 RiemannRedisClient**

顶层API，供用户使用。

/** * API层 RiemannRedisClient * 顶层API，供用户使用。 */
    public class RiemannRedisClient { 
    
        private RiemannRedisConnection connection;
    
        public RiemannRedisClient(String host, Integer port) { 
            connection = new RiemannRedisConnection(host, port);
        }
    
        public String set(String key, String value) { 
            connection.sendCommand(RiemannCommand.SET, key.getBytes(), value.getBytes());
            return connection.response();
        }
    
        public String get(String key) { 
            connection.sendCommand(RiemannCommand.GET, key.getBytes());
            return connection.response();
        }
    
        public String ping() { 
            connection.sendCommand(RiemannCommand.PING);
            return connection.response();
        }
    }

**4、RiemannCommand 枚举redis操作命令**

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

**5、RiemannRedisClientTest 测试类**

public class RiemannRedisClientTest { 
        public static void main(String[] args) { 
            RiemannRedisClient client = new RiemannRedisClient("192.168.0.105", 6379);
            client.set("riemann", "0328");
            System.out.println(jedis.get("riemann"));
        }
    }

**6、控制台返回结果**

0328

**7、去Redis服务端检查是否跟控制台一样**

192.168.0.105:6379> get riemann
    "0328"

验证ok，这样一来我们就从0开始手写了Redis客户端。希望原创文章对你有所帮助。

代码仓库地址：[https://github.com/riemannChow/spring-boot-demo/tree/master/src/main/java/com/riemann/springbootdemo/customize/redis][https_github.com_riemannChow_spring-boot-demo_tree_master_src_main_java_com_riemann_springbootdemo_customize_redis]

[20200315163028174.png]: /images/20230528/c86ba5652ffd4ddbb8be9f52a852fb4b.png
[Redis]: https://redis.io/topics/protocol
[http_doc.redisfans.com_topic_protocol.html]: http://doc.redisfans.com/topic/protocol.html
[20200315174039680.png]: /images/20230528/2f2313b136494f0e88f4ec7d00d1a60c.png
[https_github.com_riemannChow_spring-boot-demo_tree_master_src_main_java_com_riemann_springbootdemo_customize_redis]: https://github.com/riemannChow/spring-boot-demo/tree/master/src/main/java/com/riemann/springbootdemo/customize/redis