go使用twirp开发rpc

超、凢脫俗 2023-03-13 12:24 5阅读 0赞

### go使用twirp开发rpc ###

*   *  twirp简介
     *  安装
     *  开发
     *  实现rpc

## twirp简介 ##

twirp是谷歌开源的rpc框架，默认支持golang并提供其他语言的实现版本，使用proto进行rpc定义开发。

## 安装 ##

安装proto插件和twirp插件

go get github.com/twitchtv/twirp/protoc-gen-twirp
    go get github.com/golang/protobuf/protoc-gen-go

## 开发 ##

*  编写proto文件
    
        //文件名test.proto
        syntax = "proto3";
        
        //包名，通过protoc生成时go文件时
        package main;
        
        message A{
        }
        message B {
        	string result = 1;
        }
        
        service Test{
        	rpc hello(A) returns(B);
        }
 *  生成go代码  
    proto\_path指定proto文件所在目录，twirp\_out指定生成的rpc代码存放目录，go\_out指定生成的modal代码存放目录，最后一个参数是编译的proto文件路径
    
        protoc --proto_path=. --twirp_out=. --go_out=. ./test.proto
 *  server与hook  
    阅读twirp\_out中的代码  
    默认生成的Server结构体以service名称+Server作为名称  
    默认生成的service接口以service名称为名  
    主要方法有
    
        type Test interface {
        	Hello(context.Context, *A) (*B, error)
        }
        type testJSONClient struct {
        	client HTTPClient
        	urls   [1]string
        	opts   twirp.ClientOptions
        }
        //proto定义的rpc方法
        func (c *testJSONClient) Hello(ctx context.Context, in *A) (*B, error) {
        	ctx = ctxsetters.WithPackageName(ctx, "main")
        	ctx = ctxsetters.WithServiceName(ctx, "Test")
        	ctx = ctxsetters.WithMethodName(ctx, "Hello")
        	out := new(B)
        	err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out)
        	if err != nil {
        		twerr, ok := err.(twirp.Error)
        		if !ok {
        			twerr = twirp.InternalErrorWith(err)
        		}
        		callClientError(ctx, c.opts.Hooks, twerr)
        		return nil, err
        	}
        	//调用钩子函数
        	callClientResponseReceived(ctx, c.opts.Hooks)
        	return out, nil
        }
        
        type testServer struct {
        	Test
        	hooks *twirp.ServerHooks
        }
        
        func NewTestServer(svc Test, hooks *twirp.ServerHooks) TwirpServer {
        	return &testServer{
        		Test:  svc,
        		hooks: hooks,
        	}
        }
    
    其中，twirp.ClientOptions的Hooks成员类型为ClientHooks
    
        type ClientHooks struct {
        	RequestPrepared func(context.Context, *http.Request) (context.Context, error)
        	ResponseReceived func(context.Context)
        	Error func(context.Context, Error)
        }
    
    而twirp.ServerHooks恰好是他的一个实现
    
        type ServerHooks struct {
        	RequestReceived func(context.Context) (context.Context, error)
        	RequestRouted func(context.Context) (context.Context, error)
        	ResponsePrepared func(context.Context) context.Context
        	ResponseSent func(context.Context)
        	Error func(context.Context, Error) context.Context
        }
    
    而TwirpServer 是一个继承http.Handler的接口
    
        type TwirpServer interface {
        	http.Handler
        	ServiceDescriptor() ([]byte, int)
        	ProtocGenTwirpVersion() string
        	PathPrefix() string
        }
    
    所以核心就在NewTestServer这个方法  
    他的第一个参数传递service的实现对象  
    第二个参数传递twirp.ServerHooks引用类型的钩子对象，实现rpc调用的拦截  
    最终方法返回一个http.Handler对象，就可以通过http.ListenAndServe方法，运行这个handler

## 实现rpc ##

编写实现代码，因为proto生成的代码都在相同目录，且包名都是main，所以这里面可以直接使用生成代码中的结构而不需要导入文件

*  服务端  
    http.ListenAndServe返回值为error，如果输出为空代表启动正常，否则为出错原因
    
        package main
        
        import (
        	context "context"
        	"fmt"
        	"net/http"
        
        	twirp "github.com/twitchtv/twirp"
        )
        
        type TestImpl struct{}
        
        func (t TestImpl) Hello(ctx context.Context, a *A) (*B, error) {
        	println("hello")
        	//返回结果Result字段为"server result"
        	return &B{Result: "server result"}, nil
        }
        
        //重写RequestReceived，在请求发起时打印
        var testHook = &twirp.ServerHooks{
        	RequestReceived: func(ctx context.Context) (context.Context, error) {
        		println("receive ...")
        		return ctx, nil
        	},
        	ResponseSent: func(ctx context.Context) {
        		println("response ...")
        	},
        }
        
        func main() {
        	twirpHandler := NewTestServer(TestImpl{}, testHook)
        	fmt.Printf("%v\n", http.ListenAndServe(":8080", twirpHandler))
        }
 *  客户端  
    接下来编写客户端看看结果
    
        //+build ignore
        
        package main
        
        import (
        	"context"
        	"net/http"
        )
        
        func main() {
        	client := NewTestProtobufClient("http://localhost:8080", &http.Client{})
        	res, _ := client.Hello(context.Background(), &A{})
        	println(res.Result)
        }
 *  运行  
    运行服务端程序以后再启动客户端，可以看到服务端打印
    
        receive ...
        hello
        response ...
    
    客户端输出
    
        server result
    
    更多文章，请搜索公众号歪歪梯Club  
    ![更多资料，请搜索公众号编程宝可梦][20200521183346518.jpg]

[20200521183346518.jpg]: /images/20230312/41b02f09b70341e4b184c938fac675d0.png