golang rpc protobuf protorpc

最新推荐文章于 2022-10-12 16:52:49 发布

你大晨哥

最新推荐文章于 2022-10-12 16:52:49 发布

阅读量447

点赞数

分类专栏： golang

本文链接：https://blog.csdn.net/yanchendage/article/details/119391531

版权

golang 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

原生rpc

参考：
https://geektutu.com/post/quick-go-rpc.html
server.go

// server/main.go
package main

import (
	"log"
	"net/http"
	"net/rpc"
)

type Result struct {
	Num, Ans int
}

type Cal int

func (cal *Cal) Square(num int, result *Result) error {
	result.Num = num
	result.Ans = num * num
	return nil
}

func main() {
	rpc.Register(new(Cal))
	rpc.HandleHTTP()

	log.Printf("Serving RPC server on port %d", 1234)
	if err := http.ListenAndServe(":1234", nil); err != nil {
		log.Fatal("Error serving: ", err)
	}
}

client.go

package main

import (
	"log"
	"net/rpc"
)

type Result struct {
	Num, Ans int
}

func main() {
	client, _ := rpc.DialHTTP("tcp", "localhost:1234")
	var result Result
	if err := client.Call("Cal.Square", 12, &result); err != nil {
		log.Fatal("Failed to call Cal.Square. ", err)
	}
	log.Printf("%d^2 = %d", result.Num, result.Ans)
}

原生rpc+protobuf

cal.proto

syntax = "proto3";
package pb;
option go_package = "./;pb";

message SquareRequest {
    int64 num = 1;
}

message SquareResponse {
	int64 num = 1;
	int64 ans = 2;
}

protoc --go_out=. *.proto

server.go

package main

import (
	"log"
	"net/http"
	"net/rpc"
	"rpc_protobuf/pb"
)
type Cal int

func (cal *Cal) Square(request pb.SquareRequest, response *pb.SquareResponse) error {
	response.Num = request.Num
	response.Ans = request.Num * request.Num
	return nil
}

func main() {
	rpc.Register(new(Cal))
	rpc.HandleHTTP()

	log.Printf("Serving RPC server on port %d", 1235)
	if err := http.ListenAndServe(":1235", nil); err != nil {
		log.Fatal("Error serving: ", err)
	}
}

client.go

// client/main.go
package main

import (
	"log"
	"net/rpc"
	"rpc_protobuf/pb"
)

func main() {
	client, _ := rpc.DialHTTP("tcp", "localhost:1235")

	request  := pb.SquareRequest{Num:int64(13)}
	var response *pb.SquareResponse

	if err := client.Call("Cal.Square", request, &response); err != nil {
		log.Fatal("Failed to call Cal.Square. ", err)
	}
	log.Printf("%d^2 = %d", response.Num, response.Ans)
}

原生rpc+protobuf+protorpc

其实上面那种写法有点多此一举的感觉，完全没有用到protobuf的核心功能序列化与反序列化.
cal.proto

syntax = "proto3";
package pb;
option go_package = "./;pb";

message SquareRequest {
    int64 num = 1;
}

message SquareResponse {
	int64 num = 1;
	int64 ans = 2;
}

service CalService {
	rpc Square (SquareRequest) returns (SquareResponse);
}

执行
protoc --go_out=. *.proto 生成 cal.pb.go
protoc --protorpc_out=. *.proto 生成 cal.pb.protorpc.go

cal.pb.protorpc.go里是核心的代码后边我会分析

server.go

package main

import (
	"rpc_protorpc/pb"
)
type Cal int

func (cal *Cal) Square(request *pb.SquareRequest,response *pb.SquareResponse) error {
	response.Num = request.Num
	response.Ans = request.Num * request.Num
	return nil
}

func main() {
	pb.ListenAndServeCalService("tcp",`127.0.01:1236`,new(Cal))
}

client.go

package main

import (
	"fmt"
	"log"
	"rpc_protorpc/pb"
)

func main()  {
	calClient, err := pb.DialCalService("tcp", `127.0.01:1236`)
	if err != nil {
		log.Fatalf("service.DialCalService: %v", err)
	}
	defer calClient.Close()

	args := &pb.SquareRequest{Num:14}
	reply, err := calClient.Square(args)
	if err != nil {
		log.Fatalf("calClient.Square: %v", err)
	}
	fmt.Println(reply.Ans)
}

分析原生rpc源码

铺垫一下http包，具体百度一下

我们平时创建一个http服务器怎么写

	http.HandleFunc("/", indexHandler)
	http.ListenAndServe(":9999", nil)

看ListenAndServe

func ListenAndServe(addr string, handler Handler) error {
}

看handler

type Handler interface {
	ServeHTTP(ResponseWriter, *Request)
}

总结来说就是如果你想处理http请求，你的handler就需要实现方ServeHTTP方法。

分析服务端源码

	rpc.Register(new(Cal))
	rpc.HandleHTTP()

看HandleHTTP
注释写着HandleHTTP registers an HTTP handler for RPC ，大概就是注册一个rpc的handler。
看http.Handle(rpcPath, server)
我们看看注册进去的server是什么，如果他有ServeHTTP方法我们就认为他能处理http请求。

// ServeHTTP implements an http.Handler that answers RPC requests.
func (server *Server) ServeHTTP(w http.ResponseWriter, req *http.Request) {}

看来跟我们想的一样！
接着看ServeHTTP
主要是调用了server.ServeConn(conn)
server.ServeConn
从代码和注释看出来，链接是阻塞的，默认的序列化反序列化是gob，这也就是为什么golang 原生的rpc不能垮语言

// ServeConn runs the server on a single connection.
// ServeConn blocks, serving the connection until the client hangs up.
// The caller typically invokes ServeConn in a go statement.
// ServeConn uses the gob wire format (see package gob) on the
// connection. To use an alternate codec, use ServeCodec.
// See NewClient's comment for information about concurrent access.
func (server *Server) ServeConn(conn io.ReadWriteCloser) {
	buf := bufio.NewWriter(conn)
	srv := &gobServerCodec{
		rwc:    conn,
		dec:    gob.NewDecoder(conn),
		enc:    gob.NewEncoder(buf),
		encBuf: buf,
	}
	server.ServeCodec(srv)
}

server.ServeCodec(srv)

	for {
		service, mtype, req, argv, replyv, keepReading, err := server.readRequest(codec)
		...省略
		go service.call(server, sending, wg, mtype, req, argv, replyv, codec)
	}

核心就是一直轮询客户端的请求，并用gob做反序列化，利用反射得到service、参数、返回值等，然后开启一个协程 go service.call 去做本地调用并返回。

分析客户端代码

其实不看代码用脑子想想无非也就是链接服务端，用gob做序列化，发送到服务端。看看我想的对不对。

链接服务端，具体就自己看源码吧，没什么。

client, _ := rpc.DialHTTP("tcp", "localhost:1234")

gob做序列化

client.codec.WriteRequest(&client.request, call.Args)

看见这个codec没有，codec就是gob,这句代码再清晰不过了，就是先codec再write。

开始分析protorpc源码

分析前先想一想，其实protobuf+rpc的终极形态应该是将codec由gob换成protobuf，我们就按照这个思路来。

先看服务端

看ListenAndServeCalService
这个代码是由protorpc根据cal.proto生成的，点进去看看。

	for {
		conn, err := lis.Accept()
		if err != nil {
			log.Fatalf("lis.Accept(): %v\n", err)
		}
		go srv.ServeCodec(protorpc.NewServerCodec(conn))
	}

可以看到就是在轮询监听器，一但有连接请求就开一个协程，这里srv.ServeCodec是不是有点眼熟，往上翻是不是看到了server.ServeCodec(srv),这里可以很明显到看到参数变成了protorpc.NewServerCodec(conn),说明服务端的codec变成了protobuf。

再来看看客户端

看pb.DialCalService
一直追进去，看到了rpc.NewClientWithCodec(NewClientCodec(conn))
看NewClientWithCodec
从注释都能看出来，client用了指定的codec，这里的codec就是使用protobuf实现的codec

// NewClientWithCodec is like NewClient but uses the specified
// codec to encode requests and decode responses.
func NewClientWithCodec(codec ClientCodec) *Client {
	client := &Client{
		codec:   codec,
		pending: make(map[uint64]*Call),
	}
	go client.input()
	return client
}

codec是什么玩意

type ClientCodec interface {
	WriteRequest(*Request, interface{}) error
	ReadResponseHeader(*Response) error
	ReadResponseBody(interface{}) error

	Close() error
}

可以很明显的看到codec是个接口，只要实现了WriteRequest、ReadResponseHeader、ReadResponseBody、ReadResponseBody就可以实现codec，我们看看protorpc里面有没有。
在这里插入图片描述
很清楚的看到了protorpc的client.go实现了codec，又印证了前面的假设。

看reply, err := calClient.Square(args)
到这里客户端开始发起rpc请求了。进入Square发现其实最终还是调用了Call方法，与前面rpc+protobuf的代码十分相似。

if err = c.Call("CalService.Square", in, out); err != nil {
	return nil, err
}

总结

go原生的rpc呢codec是gob，不能垮语言，只能golang用，如果想用垮语言呢需要用到protobuf，就需要实现一个protobuf的codec。而protorpc就是帮你实现了这个codec，并帮你把方法封装了一下。但是不管是原生的，还是protorpc都缺少注册中心(registry)、服务发现(service discovery)、负载均衡(load balance)、超时处理(timeout processing)等特性，而且都是用了原生的net库，因此我自己实现了一个完整版的rpc，目前在测试阶段。

你大晨哥

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
golang rpc protobuf protorpc

原生rpc参考：https://geektutu.com/post/quick-go-rpc.htmlserver.go// server/main.gopackage mainimport ( "log" "net/http" "net/rpc")type Result struct { Num, Ans int}type Cal intfunc (cal *Cal) Square(num int, result *Result) error { result.Nu
复制链接

扫一扫

专栏目录