Go Micro 是一个散布式系统开发框架。Go Micro 提供了散布式系统开发的中心需求，包括 RPC 和事情驱动的通讯。Gin 是一个用 Golang 编写的 web 框架。本文首先引见怎样运用 go-micro 和 go-grpc 构建微效劳，然后再引见怎样集成 gin 和 go-micro。我们运用的 go-micro 版本是 v1.18.0，golang 版本是 v1.13，gin 版本是 v1.7.2。
02 运用 go-micro 和 go-grpc 构建微效劳在我们末尾运用 go-micro 之前，我们还需求提早做一些预备任务。安装 protoc、protoc-gen-go 和 protoc-gen-micro，关于如何安装，读者冤家们可以参阅官方文档，我们在之前的文章中也引见过，限于篇幅，本文不再赘述。
其实，我们可以运用 Go Micro 工具集以命令的方式快速生成模板文件，但是由于本文我们不预备引见工具集的相关内容，所以我们运用手动创立文件的方式。
下面我们正式末尾引见如何构建效劳，包括效劳端效劳和客户端效劳。
效劳端效劳端代码目录：
├── go.mod
├── go.sum
├── handler
│ └── user
│ └── user.go
├── main.go
└── proto
└── user
├── user.pb.go
├── user.pb.micro.go
└── user.proto
构建效劳端效劳，分为以下几个步骤：
编写 protobuf 文件
第一步是编写 protobuf 文件，普通会将不同 package 的 protobuf 文件寄存在独自的文件目录中。
文件途径： proto/user/user.proto
syntax = "proto3";
package user;
service User {
rpc Login(LoginRequest) returns (LoginResponse) {}
}
message LoginRequest {
string email = 1;
string password = 2;
}
message LoginResponse {
string username = 1;
}
阅读下面这段代码，我们在定义的 user.proto 文件中，创立了一个 rpc 效劳。
生成文件
第二步是生成文件，运用命令：
protoc --proto_path=. --micro_out=. --go_out=. user.proto
执行以上命令，将会自动生成两个文件，辨别是 user.pb.go 和 user.micro.go 。
阅读 user.micro.go 文件，可以发如今该文件中曾经自动生成了客户端和效劳端的代码。
编写 handler
第三步是编写效劳端的 handler 代码。
文件途径： handler/user/user.go
type User struct{}
func (u *User) Login(ctx context.Context, req *protoUser.LoginRequest, rsp *protoUser.LoginResponse) error {
if req.Email != "gopher@88.com" || req.Password != "123456" {
rsp.Username = "Sorry " + req.Email
return nil
}
rsp.Username = "Welcome " + req.Email
return nil
}
定义效劳端效劳
第四步是定义效劳端效劳，需求留意的是，这里运用的是 grpc。在 main.go 文件中编写如下代码：
文件途径： main.go
func main() {
// 创立效劳
service := grpc.NewService(
micro.Name("go.micro.srv.demo"),
micro.Version("v0.0.0"),
micro.RegisterTTL(time.Second * 10),
micro.RegisterInterval(time.Second * 5),
)
// 注册处置器
err := protoUser.RegisterUserHandler(service.Server(), new(user.User))
if err !=nil {
log.Fatal(err)
}
// 运转效劳
if err = service.Run(); err != nil {
log.Fatal(err)
}
}
完成以上 4 个步骤，我们就曾经完成了效劳端 rpc 效劳，接上去，我们末尾编写客户端代码。
客户端客户端代码目录：
├── go.mod
├── go.sum
├── main.go
├── proto
│ └── user
│ ├── user.pb.go
│ ├── user.pb.micro.go
│ └── user.proto
└── router
├── router.go
└── v1
└── user.go
构建客户端效劳，分为以下几个步骤：
拷贝 proto 文件和生成文件
第一步是拷贝效劳端的 proto 文件和生成文件，目的是为了保证效劳端和客户端的类型分歧性。
定义客户端效劳
第二步是定义客户端：
文件途径： router/v1/user.go
func NewUserClient() protoUser.UserService {
// 创立效劳
service := grpc.NewService()
// 创立客户端
userClient := protoUser.NewUserService("go.micro.srv.demo", service.Client())
return userClient
}
rpc 调用远程效劳的办法
第三步是 rpc 调用远程效劳的办法：
文件途径： router/v1/user.go
client := NewUserClient()
// rpc 调用远程效劳的办法
resp, err := client.Login(context.TODO(), &protoUser.LoginRequest{Email: param.Email, Password: param.Password})
if err != nil {
fmt.Println(err)
}
完成以上 3 步，我们就曾经基本编写完客户端的代码。
03 gin 和 go-micro 集成接上去，我们引见如何集成 gin 和 go-micro，该部分代码也是在客户端中，共需求两个步骤。
创立路由
文件途径： router/router.go
func NewRouter() *gin.Engine {
r := gin.New()
userControllerV1 := new(v1.User)
// 路由分组
v1 := r.Group("/v1")
{
v1.Use(gin.Logger(), gin.Recovery())
userV1 := v1.Group("/user")
{
userV1.POST("/login", userControllerV1.Login)
}
}
return r
}
启动（监听）效劳
文件途径： main.go
func main() {
r := router.NewRouter()
server := &http.Server{
Addr: ":8080",
Handler: r,
ReadTimeout: time.Second * 10,
WriteTimeout: time.Second * 10,
MaxHeaderBytes: 1 << 20,
}
if err := server.ListenAndServe(); err != nil {
log.Fatal(err)
}
}
至此，我们曾经完成了集成 gin 和 go-micro，启动效劳端效劳和客户端效劳后，我们就可以运用以下命令停止 cURL 测试：
curl --location --request POST 'http://127.0.0.1:8080/v1/user/login' \
--header 'Content-Type: application/json' \
--data-raw '{
"email": "gopher@88.com",
"password": "123456"
}'
04 总结 (责任编辑：admin)