乐趣区

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

jiezi

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-…

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

退出移动版