golang中的net/rpc包

本文先介绍RPC，然后go原生对RPC的使用，之后是介绍go语言中有哪些RPC框架以及一些其他常见的框架，最后是探究go语言中rpc的源码。

（1）首先介绍下什么RPC？
（2）RPC可以做什么？
（3）RPC与REST风格的API有什么不同？
（4）go语言中使用RPC
（5）常见的RPC框架
（6）RPC源码探究

一、什么是RPC？

RPC是Remote Procedure Call，其中文意思就是 远程过程调用，可以理解成 一台主机上的进程调用另一台主机的进程服务，由一方为其它若干个主机提供服务。从表面上看非常类似于http API，RPC的目的可以屏蔽不同语言之间的关联，最大程度上进行解耦，调用方不需要知道服务方是用什么语言编写和其实现，只要知道服务方的RPC对外服务就行。其本质就是进程间的一种通信方式，可以是本机也可以是不同主机。

二、RPC可以做什么？

API、进程间通信，主要用于分布式应用间通信。

三、RPC与REST风格API有什么不同？

本质区别就是REST是使用http协议，相比RPC的实现协议传输会传更多的内容，但是两个可以做相同的事情。

四、go语言中使用RPC

RPC分服务提供和服务使用，也就是服务端和客户端，我们先来编写服务端：

 

服务端：

1）服务内容

// 对外提供的必须是对外可见的类型
type Arith int

// 对外提供的方法也要是对外可见的类型，其中要被注册的服务至少要有一个对外可见的方法，不然执行的时候的时候会打印错误，还有对外服务的必须是方法第一个参数必须是对外可见的类型，第二个参数可以是对外可见类型或者是内置类型，然后必须要有一个返回值。
func (t *Arith) Multiply(args *Args, reply *int) error {
    *reply = args.A * args.B
    return nil
}

　

2）端口监听

l, err := net.Listen("tcp", ":12345")

　　

3）注册服务

t := new(GetServerTime)
// 注册到RPC
err = rpc.Register(t)
// 或者按名称注册
rpc.RegisterName("name",new(GetServerTime))

　　

　　

4）开启服务

rpc.HandleHTTP()

　　

5）启动HTTP服务

 

http.Serve(l, nil)

　　

相比服务端，客户端的编写会简单很多，

客户端：

1）连接服务RPC

 

client, err := rpc.DialHTTP(协议, ip:端口)

　　

2）调用RPC服务
有两种方式：同步或异步

// 同步方式
client.Call("rpc上的公开类名:公开方法", 第一个传入的变量, 第二个传入的变量)
// 异步方式
divCall := client.Go("rpc上的公开类名:公开方法", 第一次传入的变量, 第二个传入的变量, nil)
replyCall := <- divCall.Done        阻塞，等待异步完成

　　

最基本的流程就是这样，然后下面一段例子，是从标准库那边copy过来的：

 

public.go

package public

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

　　

server.go

package main

import (
	"Songzhibin/test/rpc/public"
	"errors"
	"log"
	"net"
	"net/http"
	"net/rpc"
)

type Arith int

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

func (t *Arith) Divide(args *public.Args, quo *public.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()
	l, e := net.Listen("tcp", ":1234")
	if e != nil {
		log.Fatal("listen error:", e)
	}
	go http.Serve(l, nil)
	select {}
}

　　

　　

client.go

// 客户端
package main

import (
   "Songzhibin/test/rpc/public"
   "fmt"
   "log"
   "net/rpc"
)

func main() {
   client, err := rpc.DialHTTP("tcp", "127.0.0.1:1234")
   if err != nil {
      log.Fatal("dialing:", err)
   }
   // 然后，客户端可以执行远程调用：

   // Synchronous call
   args := &public.Args{7, 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)
   // 或：

   // Asynchronous call
   quotient := new(public.Quotient)
   divCall := client.Go("Arith.Divide", args, quotient, nil)
   replyCall := <-divCall.Done // will be equal to divCall
   // check errors, print, etc.
   fmt.Printf("%#v\n", replyCall)
}

　　

　　

 

TCP-RPC(GOB)

public.go　　

package public

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

　　

server.go

package main

import (
	"Songzhibin/test/rpc/public"
	"errors"
	"fmt"
	"net"
	"net/rpc"
)

type Arith int

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

func (t *Arith) Divide(args *public.Args, quo *public.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() 不使用 HandleHTTP()
	l, err := net.Listen("tcp", ":1234")
	if err != nil {
		fmt.Println(err)
		return
	}
	for {
		// 获取连接
		conn, err := l.Accept()
		if err != nil {
			fmt.Println(err)
			return
		}
		rpc.ServeConn(conn)
	}
	select {}
}

　　

　　

client.go

package main

import (
	"Songzhibin/test/rpc/public"
	"fmt"
	"log"
	"net/rpc"
)

func main() {
	// 这里只需要将 DialHTTP改为Dial 即可
	client, err := rpc.Dial("tcp", "127.0.0.1:1234")
	if err != nil {
		log.Fatal("dialing:", err)
	}
	// 然后，客户端可以执行远程调用：

	// Synchronous call
	args := &public.Args{7, 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)
	// 或：

	// Asynchronous call
	quotient := new(public.Quotient)
	divCall := client.Go("Arith.Divide", args, quotient, nil)
	replyCall := <-divCall.Done // will be equal to divCall
	// check errors, print, etc.
	fmt.Printf("%#v\n", replyCall)
}

　　

　　

 

 

Json-RPC(TCP)

public.go　　

package public

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

 

server.go

package main

import (
	"Songzhibin/test/rpc/public"
	"errors"
	"fmt"
	"net"
	"net/rpc"
	"net/rpc/jsonrpc"
)

type Arith int

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

func (t *Arith) Divide(args *public.Args, quo *public.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() 不使用 HandleHTTP()
	l, err := net.Listen("tcp", ":1234")
	if err != nil {
		fmt.Println(err)
		return
	}
	for {
		// 获取连接
		conn, err := l.Accept()
		if err != nil {
			fmt.Println(err)
			return
		}
		// 将 rpc.ServeConn 改为jsonrpc.ServeConn
  		// 或使用 rpc.ServeCodec(jsonrpc.NewServerCodec(conn)) 更改指定编码  
		jsonrpc.ServeConn(conn)
	}
	select {}
}

　　

　　

　　

client.go

package main

import (
	"Songzhibin/test/rpc/public"
	"fmt"
	"log"
	"net/rpc/jsonrpc"
)

func main() {
	// 这里只需要将 rpc.Dial改为jsonrpc.Dial 即可
        // 或使用原来的 net.Dial拿到句柄后使用         
        // rpc.NewClientWithCodec(jsonrpc.NewClientCodec(conn)) 更换客户端编码
	client, err := jsonrpc.Dial("tcp", "127.0.0.1:1234")
	if err != nil {
		log.Fatal("dialing:", err)
	}
	// 然后，客户端可以执行远程调用：

	// Synchronous call
	args := &public.Args{7, 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)
	// 或：

	// Asynchronous call
	quotient := new(public.Quotient)
	divCall := client.Go("Arith.Divide", args, quotient, nil)
	replyCall := <-divCall.Done // will be equal to divCall
	// check errors, print, etc.
	fmt.Printf("%#v\n", replyCall)
}

　　

HTTP-RPC

server.go

func main() {
    rpc.RegisterName("HelloService", new(HelloService))

    http.HandleFunc("/jsonrpc", func(w http.ResponseWriter, r *http.Request) {
        var conn io.ReadWriteCloser = struct {
            io.Writer
            io.ReadCloser
        }{
            ReadCloser: r.Body,
            Writer:     w,
        }

        rpc.ServeRequest(jsonrpc.NewServerCodec(conn))
    })

    http.ListenAndServe(":1234", nil)
}