乐趣区

关于golang:gomicro开发RPC服务的方法及其运行原理

go-micro 是一个出名的 golang 微服务框架,最新版本是 v4,这篇文章将介绍 go-micro v4 开发 RPC 服务的办法及其运作原理。

基本概念

go-micro 有几个重要的概念,后边开发 RPC 服务和介绍其运行原理的时候会用到,这里先相熟下:

  • Service:代表一个 go-micro 应用程序,Service 中包含:Server、Client、Broker、Transport、Registry、Config、Store、Cache 等程序运行所需的各个模块。
  • Server:代表一个 go-micro 服务器,次要函数包含:Start、Stop、Handle、Subscribe。默认创立的 Server 是 rpcServer。
  • Broker:用于解决异步音讯,次要的函数包含:Connect、Publish、Subscribe。默认的 Broker 是 httpBroker。
  • Router: 用于音讯解决的路由,外部包含两种路由形式:RPC 服务映射 serviceMap 和音讯订阅器 subscribers。
  • Codec: 用于音讯的编解码,次要函数包含:Marshal、Unmarshal 默认的 Codec 是 json.Marshaler,是基于 jsonpb 的。RPC 服务是依据申请头中的 Content-Type 主动创立的。
  • Registry: 用于服务发现,次要函数包含:Register、Deregister、GetService、ListServices、Watch。默认的 Registry 是 mdns。
  • Selector: 用于从同一个服务的多个实例之中抉择一个,反对缓存,有随机和轮询两种策略。
  • Transport:用于同步通信,次要函数包含:Dial、Listen。它的底层基于 Socket 的 send、recv 语义,有多种实现,包含 http、grpc、quic 等。默认的 Transport 是 httpTransport。

开发 RPC 服务

RPC 全称是 Remote Procedure Call,翻译过去是就是:近程过程调用,中心思想是:像调用本地函数一样调用近程函数。常见的 Dubbo、Spring Cloud 都能够称为 RPC 框架,还有最近很风行的 gRPC。

应用 go-micro 创立一个 RPC 服务很简略,共分三步走:

1、编写 proto 协定文件

这个服务提供的性能很简略,名字为 Hello,提供一个办法名字为 Say,须要传入一个字符串 Name,而后返回一个字符串 Message。这个文件我命名为 hello.proto,放到了我的项目中的 proto 文件夹中。

syntax = "proto3";

option go_package="/proto";

package Business;

service Hello {rpc Say (SayRequest) returns (SayResponse);
}

message SayResponse {string Message = 1;}

message SayRequest {string Name = 1;}

2、生成 go-micro 服务端代理

须要首先装置 protoc 和两个代码生成插件。

protoc 下载地址:https://github.com/protocolbu…,保留到 GOPATH/bin 目录中。同时倡议将 GOPATH/bin 增加到环境变量 PATH 中,不便间接执行相干命令。

两个插件间接通过命令即可装置:

go install google.golang.org/protobuf/cmd/protoc-gen-go
go install go-micro.dev/v4/cmd/protoc-gen-micro@v4

而后在我的项目的目录下执行命令:

protoc --go_out=. --go_opt=paths=source_relative --micro_out=. --micro_opt=paths=source_relative proto/hello.proto

而后会在 proto 文件夹中生成两个文件:hello.pb.go 和 hello.pb.micro.go。

下个步骤中就要应用它们来创立 RPC 服务。

3、编写 go-micro 服务

这里先把代码贴出来,而后再做一个简要阐明:

package main

import (
    "context"
    "fmt"
    "log"
    "rpchello/proto"

    "go-micro.dev/v4"
    "go-micro.dev/v4/server"
)

type Hello struct{}

func (s *Hello) Say(ctx context.Context, req *proto.SayRequest, rsp *proto.SayResponse) error {fmt.Println("request:", req.Name)
    rsp.Message = "Hello" + req.Name
    return nil
}

func main() {
    rpcServer := server.NewServer(server.Name("rpchello.service"),
        server.Address("0.0.0.0:8001"),
    )

    proto.RegisterHelloHandler(rpcServer, &Hello{})

    service := micro.NewService(micro.Server(rpcServer),
    )

    if err := service.Run(); err != nil {log.Fatal(err)
    }
}

上边咱们创立了一个 Hello 类型,而后给它绑定了一个名为 Say 的函数。这个是和 proto 协定对应的,其实是实现了生成代码 hello.pb.micro.go 中的 HelloHandler 接口:

type HelloHandler interface {Say(context.Context, *SayRequest, *SayResponse) error
}

而后 main 函数中是咱们的重头戏:先创立一个 Server,默认状况下就是 rpc Server,设置它的名字、监听地址等参数;而后创立一个 Service,并绑定刚刚创立的 Server;而后应用生成的服务端代理函数将咱们编写的 Hello 服务注册到 Server 中;最初开启运行 Service。

当然只有一个服务端没有什么意义,还得有客户端来拜访它。这里也给一个例子:

package main

import (
    "bufio"
    "context"
    "fmt"
    "os"
    "rpchello/proto"

    "go-micro.dev/v4"
    "go-micro.dev/v4/client"
)

func main() {

    service := micro.NewService(micro.Client(client.NewClient()),
    )

    service.Init()
    client := proto.NewHelloService("rpchello.service", service.Client())

    rsp, err := client.Say(context.TODO(), &proto.SayRequest{Name: "BOSSMA"})
    if err != nil {fmt.Println(err)
    }

    fmt.Println(rsp)

    fmt.Println("Press Enter key to exit the program...")
    in := bufio.NewReader(os.Stdin)
    _, _, _ = in.ReadLine()}

这里调用服务的时候没有指定服务的地址和端口,因为外部走了服务发现,服务端会主动注册服务,客户端会依据服务名称查找到对应的地址和端口。默认的服务发现机制应用的是 mdns。

RPC 服务的运行原理

这里从服务端的角度进行介绍,先来看一张图:

请大家参考代码从上往下看。

NewServer 时创立一个 rpcServer,这个 rpcServer 还会创立一个 httpTransport 用于程序间网络通信,并绑定到以后 rpcServer。

RegisterXXXHandler 时应用咱们编写的 Handler 创立一个外部的 service 实例,而后注册这个 service 实例到 rpcServer 外部的 router 中,客户端申请时会用到它。这里其实能够注册任意一个带办法的类型,并不一定要定义 proto 协定,定义它只是为了合作更不便。

Service.Run 时会调用 rpcServer 的 Start 办法,这个办法外部会调用其绑定的 httpTransport 的 Listen 办法,而后在其创立的 Listener 上接管客户端连贯,接管办法 Accept 传入了以后 rpcServer 的连贯解决办法:rpcServer.ServeConn,有连贯到来时会调用它。

当客户端申请来长期,客户端连贯被交给 rpcServer 的 ServeConn 办法,而后又调用到 HandleEvent 办法。

而后进入 rpcServer 外部的 router 的函数 ServeRequest 中,通过剖析申请音讯,找到申请的服务名字和办法名字,在 router 中找到后面注册过的 service,通过 servcie.call,再进入 function.call,最终通过反射调用到咱们编写的 Handler 的业务办法。

有的同学可能会想,反射不是性能很低吗?!反射性能低次要是查找办法和字段的时候,调用办法的性能并不低,而查找办法和字段等的操作曾经在 RegisterXXXHandler 的步骤中做了,并且缓存到了 router 中,所以性能并不受影响。


以上就是本文的次要内容了,如有问题,欢送交换。演示代码已公布到 Github:https://github.com/bosima/go-…

播种更多架构常识,请关注微信公众号 萤火架构。原创内容,转载请注明出处。

退出移动版