• 用 Go 来了解一下 Redis 通讯协议
    • 介绍
    • 协议
      • 请求协议
      • 回复
    • 实践
      • 与 Redis 服务器交互
      • 请求
      • 回复
    • 小结
    • 参考

    用 Go 来了解一下 Redis 通讯协议

    Go、PHP、Java… 都有那么多包来支撑你使用 Redis,那你是否有想过

    有了服务端,有了客户端,他们俩是怎样通讯,又是基于什么通讯协议做出交互的呢?

    介绍

    基于我们的目的,本文主要讲解和实践 Redis 的通讯协议

    Redis 的客户端和服务端是通过 TCP 连接来进行数据交互, 服务器默认的端口号为 6379

    客户端和服务器发送的命令或数据一律以 \r\n (CRLF)结尾(这是一条约定)

    协议

    在 Redis 中分为请求回复,而请求协议又分为新版和旧版,新版统一请求协议在 Redis 1.2 版本中引入,最终在 Redis 2.0 版本成为 Redis 服务器通信的标准方式

    本文是基于新版协议来实现功能,不建议使用旧版(1.2 挺老旧了)。如下是新协议的各种范例:

    请求协议

    1、 格式示例

    1. *<参数数量> CR LF
    2. $<参数 1 的字节数量> CR LF
    3. <参数 1 的数据> CR LF
    4. ...
    5. $<参数 N 的字节数量> CR LF
    6. <参数 N 的数据> CR LF

    在该协议下所有发送至 Redis 服务器的参数都是二进制安全(binary safe)的

    2、打印示例

    1. *3
    2. $3
    3. SET
    4. $5
    5. mykey
    6. $7
    7. myvalue

    3、实际协议值

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

    这就是 Redis 的请求协议规范,按照范例1编写客户端逻辑,最终发送的是范例3,相信你已经有大致的概念了,Redis 的协议非常的简洁易懂,这也是好上手的原因之一,你可以想想协议这么定义的好处在哪?

    回复

    Redis 会根据你请求协议的不同(执行的命令结果也不同),返回多种不同类型的回复。在这个回复“协议”中,可以通过检查第一个字节,确定这个回复是什么类型,如下:

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

    有了回复的头部标识,结尾的 CRLF,你可以大致猜想出回复“协议”是怎么样的,但是实践才能得出真理,斎知道怕是你很快就忘记了 ?

    实践

    与 Redis 服务器交互

    1. package main
    2. import (
    3. "log"
    4. "net"
    5. "os"
    6. "github.com/EDDYCJY/redis-protocol-example/protocol"
    7. )
    8. const (
    9. Address = "127.0.0.1:6379"
    10. Network = "tcp"
    11. )
    12. func Conn(network, address string) (net.Conn, error) {
    13. conn, err := net.Dial(network, address)
    14. if err != nil {
    15. return nil, err
    16. }
    17. return conn, nil
    18. }
    19. func main() {
    20. // 读取入参
    21. args := os.Args[1:]
    22. if len(args) <= 0 {
    23. log.Fatalf("Os.Args <= 0")
    24. }
    25. // 获取请求协议
    26. reqCommand := protocol.GetRequest(args)
    27. // 连接 Redis 服务器
    28. redisConn, err := Conn(Network, Address)
    29. if err != nil {
    30. log.Fatalf("Conn err: %v", err)
    31. }
    32. defer redisConn.Close()
    33. // 写入请求内容
    34. _, err = redisConn.Write(reqCommand)
    35. if err != nil {
    36. log.Fatalf("Conn Write err: %v", err)
    37. }
    38. // 读取回复
    39. command := make([]byte, 1024)
    40. n, err := redisConn.Read(command)
    41. if err != nil {
    42. log.Fatalf("Conn Read err: %v", err)
    43. }
    44. // 处理回复
    45. reply, err := protocol.GetReply(command[:n])
    46. if err != nil {
    47. log.Fatalf("protocol.GetReply err: %v", err)
    48. }
    49. // 处理后的回复内容
    50. log.Printf("Reply: %v", reply)
    51. // 原始的回复内容
    52. log.Printf("Command: %v", string(command[:n]))
    53. }

    在这里我们完成了整个 Redis 客户端和服务端交互的流程,分别如下:

    1、读取命令行参数:获取执行的 Redis 命令

    2、获取请求协议参数

    3、连接 Redis 服务器,获取连接句柄

    4、将请求协议参数写入连接:发送请求的命令行参数

    5、从连接中读取返回的数据:读取先前请求的回复数据

    6、根据回复“协议”内容,处理回复的数据集

    7、输出处理后的回复内容及原始回复内容

    请求

    1. func GetRequest(args []string) []byte {
    2. req := []string{
    3. "*" + strconv.Itoa(len(args)),
    4. }
    5. for _, arg := range args {
    6. req = append(req, "$"+strconv.Itoa(len(arg)))
    7. req = append(req, arg)
    8. }
    9. str := strings.Join(req, "\r\n")
    10. return []byte(str + "\r\n")
    11. }

    通过对 Redis 的请求协议的分析,可得出它的规律,先加上标志位,计算参数总数量,再循环合并各个参数的字节数量、值就可以了

    回复

    1. func GetReply(reply []byte) (interface{}, error) {
    2. replyType := reply[0]
    3. switch replyType {
    4. case StatusReply:
    5. return doStatusReply(reply[1:])
    6. case ErrorReply:
    7. return doErrorReply(reply[1:])
    8. case IntegerReply:
    9. return doIntegerReply(reply[1:])
    10. case BulkReply:
    11. return doBulkReply(reply[1:])
    12. case MultiBulkReply:
    13. return doMultiBulkReply(reply[1:])
    14. default:
    15. return nil, nil
    16. }
    17. }
    18. func doStatusReply(reply []byte) (string, error) {
    19. if len(reply) == 3 && reply[1] == 'O' && reply[2] == 'K' {
    20. return OkReply, nil
    21. }
    22. if len(reply) == 5 && reply[1] == 'P' && reply[2] == 'O' && reply[3] == 'N' && reply[4] == 'G' {
    23. return PongReply, nil
    24. }
    25. return string(reply), nil
    26. }
    27. func doErrorReply(reply []byte) (string, error) {
    28. return string(reply), nil
    29. }
    30. func doIntegerReply(reply []byte) (int, error) {
    31. pos := getFlagPos('\r', reply)
    32. result, err := strconv.Atoi(string(reply[:pos]))
    33. if err != nil {
    34. return 0, err
    35. }
    36. return result, nil
    37. }
    38. ...

    在这里我们对所有回复类型进行了分发,不同的回复标志位对应不同的处理方式,在这里需求注意几项问题,如下:

    1、当请求的值不存在,会将特殊值 -1 用作回复

    2、服务器发送的所有字符串都由 CRLF 结尾

    3、多条批量回复是可基于批量回复的,要注意理解

    4、无内容的多条批量回复是存在的

    最重要的是,对不同回复的规则的把控,能够让你更好的理解 Redis 的请求、回复的交互过程 ?

    小结

    写这篇文章的起因,是因为常常在使用 Redis 时,只是用,你不知道它是基于什么样的通讯协议来通讯,这样的感觉是十分难受的

    通过本文的讲解,我相信你已经大致了解 Redis 客户端是怎么样和服务端交互,也清楚了其所用的通讯原理,希望能够对你有所帮助!

    最后,如果想详细查看代码,右拐项目地址:https://github.com/EDDYCJY/redis-protocol-example

    如果对你有所帮助,欢迎点个 Star ?

    参考

    • 通信协议