Go 實現簡易 RPC 框架

本文旨在講述 RPC 框架設計中的幾個核心問題及其解決方法，並基於 Golang 反射技術，構建了一個簡易的 RPC 框架。

項目地址：Tiny-RPC

RPC

RPC（Remote Procedure Call），即遠程過程調用，能夠理解成，服務 A 想調用不在同一內存空間的服務 B 的函數，因爲不在一個內存空間，不能直接調用，須要經過網絡來表達調用的語義和傳達調用的數據。

服務端

RPC 服務端須要解決 2 個問題：

• 因爲客戶端傳送的是 RPC 函數名，服務端如何維護 函數名 與 函數實體 之間的映射
• 服務端如何根據 函數名 實現對應的 函數實體 的調用

核心流程

• 維護函數名到函數的映射
• 在接收到來自客戶端的函數名、參數列表後，解析參數列表爲反射值，並執行對應函數
• 對函數執行結果進行編碼，並返回給客戶端

方法註冊

服務端須要維護 RPC 函數名到 RPC 函數實體的映射，咱們能夠使用 map 數據結構來維護映射關係。

type Server struct {
    addr  string
    funcs map[string]reflect.Value
}

// Register a method via name
func (s *Server) Register(name string, f interface{}) {
    if _, ok := s.funcs[name]; ok {
        return
    }
    s.funcs[name] = reflect.ValueOf(f)
}

執行調用

通常來講，客戶端在調用 RPC 時，會將 函數名 和 參數列表 做爲請求數據，發送給服務端。

因爲咱們使用了 map[string]reflect.Value 來維護函數名與函數實體之間的映射，則咱們能夠經過 Value.Call() 來調用與函數名相對應的函數。

代碼地址：https://play.golang.org/p/jaP...

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // Register methods
    funcs := make(map[string]reflect.Value)
    funcs["add"] = reflect.ValueOf(add)

    // When receives client's request
    req := []reflect.Value{reflect.ValueOf(1), reflect.ValueOf(2)}
    vals := funcs["add"].Call(req)
    var rsp []interface{}
    for _, val := range vals {
        rsp = append(rsp, val.Interface())
    }

    fmt.Println(rsp)
}

func add(a, b int) (int, error) {
    return a + b, nil
}

具體實現

因爲篇幅的限制，此處沒有貼出服務端實現的具體代碼，細節請查看項目地址。

客戶端

RPC 客戶端須要解決 1 個問題：

• 因爲函數的具體實如今服務端，客戶端只有函數的原型，客戶端如何經過 函數原型 調用其 函數實體

核心流程

• 對調用者傳入的函數參數進行編碼，並傳送給服務端
• 對服務端響應數據進行解碼，並返回給調用者

生成調用

咱們能夠經過 reflect.MakeFunc 爲指定的函數原型綁定一個函數實體。

代碼地址： https://play.golang.org/p/Aae...

package main

import (
    "fmt"
    "reflect"
)

func main() {
    add := func(args []reflect.Value) []reflect.Value {
        result := args[0].Interface().(int) + args[1].Interface().(int)
        return []reflect.Value{reflect.ValueOf(result)}
    }

    var addptr func(int, int) int
    container := reflect.ValueOf(&addptr).Elem()
    v := reflect.MakeFunc(container.Type(), add)
    container.Set(v)

    fmt.Println(addptr(1, 2))
}

具體實現

因爲篇幅的限制，此處沒有貼出客戶端實現的具體代碼，細節請查看項目地址。

數據傳輸格式

咱們須要定義服務端與客戶端交互的數據格式。

type Data struct {
    Name string        // service name
    Args []interface{} // request's or response's body except error
    Err  string        // remote server error
}

與交互數據相對應的編碼與解碼函數。

func encode(data Data) ([]byte, error) {
    var buf bytes.Buffer
    encoder := gob.NewEncoder(&buf)
    if err := encoder.Encode(data); err != nil {
        return nil, err
    }
    return buf.Bytes(), nil
}

func decode(b []byte) (Data, error) {
    buf := bytes.NewBuffer(b)
    decoder := gob.NewDecoder(buf)
    var data Data
    if err := decoder.Decode(&data); err != nil {
        return Data{}, err
    }
    return data, nil
}

同時，咱們須要定義簡單的 TLV 協議（固定長度消息頭 + 變長消息體），規範數據的傳輸。

// Transport struct
type Transport struct {
    conn net.Conn
}

// NewTransport creates a transport
func NewTransport(conn net.Conn) *Transport {
    return &Transport{conn}
}

// Send data
func (t *Transport) Send(req Data) error {
    b, err := encode(req) // Encode req into bytes
    if err != nil {
        return err
    }
    buf := make([]byte, 4+len(b))
    binary.BigEndian.PutUint32(buf[:4], uint32(len(b))) // Set Header field
    copy(buf[4:], b)                                    // Set Data field
    _, err = t.conn.Write(buf)
    return err
}

// Receive data
func (t *Transport) Receive() (Data, error) {
    header := make([]byte, 4)
    _, err := io.ReadFull(t.conn, header)
    if err != nil {
        return Data{}, err
    }
    dataLen := binary.BigEndian.Uint32(header) // Read Header filed
    data := make([]byte, dataLen)              // Read Data Field
    _, err = io.ReadFull(t.conn, data)
    if err != nil {
        return Data{}, err
    }
    rsp, err := decode(data) // Decode rsp from bytes
    return rsp, err
}

相關資料

• 項目地址：Tiny-RPC
• go rpc 源碼分析