# 8.4 RPC
前面幾個小節我們介紹瞭如何基於Socket和HTTP來編寫網路應用，透過學習我們瞭解了Socket和HTTP採用的是類似"資訊交換"模式，即客戶端傳送一條資訊到伺服器端，然後(一般來說)伺服器端都會返回一定的資訊以表示響應。客戶端和伺服器端之間約定了互動資訊的格式，以便雙方都能夠解析互動所產生的資訊。但是很多獨立的應用並沒有採用這種模式，而是採用類似常規的函式呼叫的方式來完成想要的功能。

RPC就是想實現函式呼叫模式的網路化。客戶端就像呼叫本地函式一樣，然後客戶端把這些引數打套件之後透過網路傳遞到伺服器端，伺服器端解套件到處理過程中執行，然後執行的結果反饋給客戶端。

RPC（Remote Procedure Call Protocol）——遠端過程呼叫協議，是一種透過網路從遠端計算機程式上請求服務，而不需要了解底層網路技術的協議。它假定某些傳輸協議的存在，如TCP或UDP，以便為通訊程式之間攜帶資訊資料。透過它可以使函式呼叫模式網路化。在OSI網路通訊模型中，RPC跨越了傳輸層和應用層。RPC使得開發包括網路分散式多程式在內的應用程式更加容易。

## RPC工作原理

![](images/8.4.rpc.png?raw=true)

圖8.8 RPC工作流程圖

執行時,一次客戶機對伺服器的RPC呼叫,其內部操作大致有如下十步：

- 1.呼叫客戶端控制代碼；執行傳送引數
- 2.呼叫本地系統核心傳送網路訊息
- 3.訊息傳送到遠端主機
- 4.伺服器控制代碼得到訊息並取得引數
- 5.執行遠端過程
- 6.執行的過程將結果返回伺服器控制代碼
- 7.伺服器控制代碼返回結果，呼叫遠端系統核心
- 8.訊息傳回本地主機
- 9.客戶控制代碼由核心接收訊息
- 10.客戶接收控制代碼返回的資料

## Go RPC
Go標準套件中已經提供了對RPC的支援，而且支援三個級別的RPC：TCP、HTTP、JSONRPC。但Go的RPC套件是獨一無二的RPC，它和傳統的RPC系統不同，它只支援Go開發的伺服器與客戶端之間的互動，因為在內部，它們採用了Gob來編碼。

Go RPC的函式只有符合下面的條件才能被遠端訪問，不然會被忽略，詳細的要求如下：

- 函式必須是匯出的(首字母大寫)
- 必須有兩個匯出型別的引數，
- 第一個引數是接收的引數，第二個引數是返回給客戶端的引數，第二個引數必須是指標型別的
- 函式還要有一個返回值error

舉個例子，正確的RPC函式格式如下：

	func (t *T) MethodName(argType T1, replyType *T2) error

T、T1和T2型別必須能被`encoding/gob`套件編解碼。

任何的RPC都需要透過網路來傳遞資料，Go RPC可以利用HTTP和TCP來傳遞資料，利用HTTP的好處是可以直接複用`net/http`裡面的一些函式。詳細的例子請看下面的實現

### HTTP RPC
http的伺服器端程式碼實現如下：

```Go

package main

import (
	"errors"
	"fmt"
	"net/http"
	"net/rpc"
)

type Args struct {
	A, B int
}

type Quotient struct {
	Quo, Rem int
}

type Arith int

func (t *Arith) Multiply(args *Args, reply *int) error {
	*reply = args.A * args.B
	return nil
}

func (t *Arith) Divide(args *Args, quo *Quotient) error {
	if args.B == 0 {
		return errors.New("divide by zero")
	}
	quo.Quo = args.A / args.B
	quo.Rem = args.A % args.B
	return nil
}

func main() {

	arith := new(Arith)
	rpc.Register(arith)
	rpc.HandleHTTP()

	err := http.ListenAndServe(":1234", nil)
	if err != nil {
		fmt.Println(err.Error())
	}
}

```
透過上面的例子可以看到，我們註冊了一個Arith的RPC服務，然後透過`rpc.HandleHTTP`函式把該服務註冊到了HTTP協議上，然後我們就可以利用http的方式來傳遞資料了。

請看下面的客戶端程式碼：

```Go

package main

import (
	"fmt"
	"log"
	"net/rpc"
	"os"
)

type Args struct {
	A, B int
}

type Quotient struct {
	Quo, Rem int
}

func main() {
	if len(os.Args) != 2 {
		fmt.Println("Usage: ", os.Args[0], "server")
		os.Exit(1)
	}
	serverAddress := os.Args[1]

	client, err := rpc.DialHTTP("tcp", serverAddress+":1234")
	if err != nil {
		log.Fatal("dialing:", err)
	}
	// Synchronous call
	args := Args{17, 8}
	var reply int
	err = client.Call("Arith.Multiply", args, &reply)
	if err != nil {
		log.Fatal("arith error:", err)
	}
	fmt.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)

	var quot Quotient
	err = client.Call("Arith.Divide", args, &quot)
	if err != nil {
		log.Fatal("arith error:", err)
	}
	fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)

}

```
我們把上面的伺服器端和客戶端的程式碼分別編譯，然後先把伺服器端開啟，然後開啟客戶端，輸入程式碼，就會輸出如下資訊：
```Go

$ ./http_c localhost
Arith: 17*8=136
Arith: 17/8=2 remainder 1

```
透過上面的呼叫可以看到引數和返回值是我們定義的struct型別，在伺服器端我們把它們當做呼叫函式的引數的型別，在客戶端作為`client.Call`的第2，3兩個引數的型別。客戶端最重要的就是這個Call函式，它有3個引數，第1個要呼叫的函式的名字，第2個是要傳遞的引數，第3個要返回的引數(注意是指標型別)，透過上面的程式碼例子我們可以發現，使用Go的RPC實現相當的簡單，方便。
### TCP RPC
上面我們實現了基於HTTP協議的RPC，接下來我們要實現基於TCP協議的RPC，伺服器端的實現程式碼如下所示：
```Go

package main

import (
	"errors"
	"fmt"
	"net"
	"net/rpc"
	"os"
)

type Args struct {
	A, B int
}

type Quotient struct {
	Quo, Rem int
}

type Arith int

func (t *Arith) Multiply(args *Args, reply *int) error {
	*reply = args.A * args.B
	return nil
}

func (t *Arith) Divide(args *Args, quo *Quotient) error {
	if args.B == 0 {
		return errors.New("divide by zero")
	}
	quo.Quo = args.A / args.B
	quo.Rem = args.A % args.B
	return nil
}

func main() {

	arith := new(Arith)
	rpc.Register(arith)

	tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234")
	checkError(err)

	listener, err := net.ListenTCP("tcp", tcpAddr)
	checkError(err)

	for {
		conn, err := listener.Accept()
		if err != nil {
			continue
		}
		rpc.ServeConn(conn)
	}

}

func checkError(err error) {
	if err != nil {
		fmt.Println("Fatal error ", err.Error())
		os.Exit(1)
	}
}

```
上面這個程式碼和http的伺服器相比，不同在於:在此處我們採用了TCP協議，然後需要自己控制連線，當有客戶端連線上來後，我們需要把這個連線交給rpc來處理。

如果你留心了，你會發現這它是一個阻塞型的單使用者的程式，如果想要實現多併發，那麼可以使用goroutine來實現，我們前面在socket小節的時候已經介紹過如何處理goroutine。
下面展現了TCP實現的RPC客戶端：

```Go

package main

import (
	"fmt"
	"log"
	"net/rpc"
	"os"
)

type Args struct {
	A, B int
}

type Quotient struct {
	Quo, Rem int
}

func main() {
	if len(os.Args) != 2 {
		fmt.Println("Usage: ", os.Args[0], "server:port")
		os.Exit(1)
	}
	service := os.Args[1]

	client, err := rpc.Dial("tcp", service)
	if err != nil {
		log.Fatal("dialing:", err)
	}
	// Synchronous call
	args := Args{17, 8}
	var reply int
	err = client.Call("Arith.Multiply", args, &reply)
	if err != nil {
		log.Fatal("arith error:", err)
	}
	fmt.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)

	var quot Quotient
	err = client.Call("Arith.Divide", args, &quot)
	if err != nil {
		log.Fatal("arith error:", err)
	}
	fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)

}

```
這個客戶端程式碼和http的客戶端程式碼對比，唯一的區別一個是DialHTTP，一個是Dial(tcp)，其他處理一模一樣。

### JSON RPC
JSON RPC是資料編碼採用了JSON，而不是gob編碼，其他和上面介紹的RPC概念一模一樣，下面我們來示範一下，如何使用Go提供的json-rpc標準套件，請看伺服器端程式碼的實現：

```Go

package main

import (
	"errors"
	"fmt"
	"net"
	"net/rpc"
	"net/rpc/jsonrpc"
	"os"
)

type Args struct {
	A, B int
}

type Quotient struct {
	Quo, Rem int
}

type Arith int

func (t *Arith) Multiply(args *Args, reply *int) error {
	*reply = args.A * args.B
	return nil
}

func (t *Arith) Divide(args *Args, quo *Quotient) error {
	if args.B == 0 {
		return errors.New("divide by zero")
	}
	quo.Quo = args.A / args.B
	quo.Rem = args.A % args.B
	return nil
}

func main() {

	arith := new(Arith)
	rpc.Register(arith)

	tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234")
	checkError(err)

	listener, err := net.ListenTCP("tcp", tcpAddr)
	checkError(err)

	for {
		conn, err := listener.Accept()
		if err != nil {
			continue
		}
		jsonrpc.ServeConn(conn)
	}

}

func checkError(err error) {
	if err != nil {
		fmt.Println("Fatal error ", err.Error())
		os.Exit(1)
	}
}

```
透過示例我們可以看出 json-rpc是基於TCP協議實現的，目前它還不支援HTTP方式。

請看客戶端的實現程式碼：
```Go

package main

import (
	"fmt"
	"log"
	"net/rpc/jsonrpc"
	"os"
)

type Args struct {
	A, B int
}

type Quotient struct {
	Quo, Rem int
}

func main() {
	if len(os.Args) != 2 {
		fmt.Println("Usage: ", os.Args[0], "server:port")
		log.Fatal(1)
	}
	service := os.Args[1]

	client, err := jsonrpc.Dial("tcp", service)
	if err != nil {
		log.Fatal("dialing:", err)
	}
	// Synchronous call
	args := Args{17, 8}
	var reply int
	err = client.Call("Arith.Multiply", args, &reply)
	if err != nil {
		log.Fatal("arith error:", err)
	}
	fmt.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)

	var quot Quotient
	err = client.Call("Arith.Divide", args, &quot)
	if err != nil {
		log.Fatal("arith error:", err)
	}
	fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)

}

```
## 總結
Go已經提供了對RPC的良好支援，透過上面HTTP、TCP、JSON RPC的實現,我們就可以很方便的開發很多分散式的Web應用，我想作為讀者的你已經領會到這一點。但遺憾的是目前Go尚未提供對SOAP RPC的支援，欣慰的是現在已經有第三方的開源實現了。



## links
   * [目錄](<preface.md>)
   * 上一節: [REST](<08.3.md>)
   * 下一節: [小結](<08.5.md>)