Go Micro（3）——开发微服务
这是一个高等级的说明：怎样使用 go-micro 来编写微服务，如果你想学习更多微服务的知识以及Micro的整体架构，参考以前的文章。
什么是 Go Micro?
Go Micro 是一个插件化的基础框架，基于此可以构建微服务。Micro 的设计哲学是『可插拔』的插件化架构。在架构之外，它默认实现了 consul 作为服务发现，通过 http 进行通信，通过 protobuf 和 json 进行编解码。我们一步步深入下去。
Go Micro 是：
- 一个用
Golang编写的包 - 一系列插件化的接口定义
- 基于
RPC
Go Micro 为下面的模块定义了接口：
- 服务发现
- 编解码
- 服务端、客户端
- 订阅、发布消息
更详细的说明可以在这里看到。
Go Micro 从一年多以前开始开发，最初只是个人需求，很快我发现这对那些编写微服务的程序员会有很大的价值。它基于我在不同的技术公司如 google 和 hailo 的开发经验编写而成。
就像前面提到的，Go Micro 是一个 golang 编写的插件化架构，专注于提供底层的接口定义和基础工具。这些接口可以接纳各种实现。比如 Registry 接口定义了服务发现的接口，默认采用了 consul 作为服务发现的实现，但也可以采用其他实现比如 etcd 和 zookeeper 等，只要能满足接口，就可以使用。
插件化的架构意味着如果你想替换底层的实现，你不需要修改任何底层的代码。
编写一个服务
如果你想直接看代码，看这里：examples/service
顶层的 Service 接口是构建服务的主要组件。它把底层的各个包需要实现的接口，做了一次封装。
type Service interface {
Init(...Option)
Options() Options
Client() client.Client
Server() server.Server
Run() error
String() string
}
初始化
一个服务可以这样创建 micro.NewService
import "github.com/micro/go-micro"
service := micro.NewService()
参数可以在创建时传入
service := micro.NewService(
micro.Name("greeter"),
micro.Version("latest"),
)
所有可选的参数设置可以在这里看到
Go Micro 也提供了读取命令行的方式
import (
"github.com/micro/cli"
"github.com/micro/go-micro"
)
service := micro.NewService(
micro.Flags(
cli.StringFlag{
Name: "environment",
Usage: "The environment",
},
)
)
通过 service.Init 来解析参数，附加的处理可以通过 micro.Action 解决
service.Init(
micro.Action(func(c *cli.Context) {
env := c.StringFlag("environment")
if len(env) > 0 {
fmt.Println("Environment set to", env)
}
}),
)
Go Micro 提供了提供了预定义的参数，也会被 service.Init 解析，这里可以看到所有的 flag
定义 API
我们使用 protobuf 文件来定义服务的 API，这是一种方便且严格的定义方式，协议将会提供给服务端和客户端。下面是一个协议的例子：greeter.proto
syntax = "proto3";
service Greeter {
rpc Hello(HelloRequest) returns (HelloResponse) {}
}
message HelloRequest {
string name = 1;
}
message HelloResponse {
string greeting = 2;
}
这里定义了一个服务叫做 Greeter，它提供一个接口叫 Hello，它接受 HelloRequest 的请求，返回 HelloResponse。
生成 API 接口
我们使用 protoc 和 proto-gen-go 这两个工具来生成代码，Go Micro 也会生成客户端代码，减少工作量，这里需要使用我们 fork 并修改过的 github.com/micro/protobuf，与原始版本的区别是，fork 版本能生成客户端代码
go get github.com/micro/protobuf/{proto,protoc-gen-go}
protoc --go_out=plugins=micro:. greeter.proto
生成的代码可以在 handler 中引用相应的包进行使用，下面是生成的一部分代码
type HelloRequest struct {
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
type HelloResponse struct {
Greeting string `protobuf:"bytes,2,opt,name=greeting" json:"greeting,omitempty"`
}
// Client API for Greeter service
type GreeterClient interface {
Hello(ctx context.Context, in *HelloRequest, opts ...client.CallOption) (*HelloResponse, error)
}
type greeterClient struct {
c client.Client
serviceName string
}
func NewGreeterClient(serviceName string, c client.Client) GreeterClient {
if c == nil {
c = client.NewClient()
}
if len(serviceName) == 0 {
serviceName = "greeter"
}
return &greeterClient{
c: c,
serviceName: serviceName,
}
}
func (c *greeterClient) Hello(ctx context.Context, in *HelloRequest, opts ...client.CallOption) (*HelloResponse, error) {
req := c.c.NewRequest(c.serviceName, "Greeter.Hello", in)
out := new(HelloResponse)
err := c.c.Call(ctx, req, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for Greeter service
type GreeterHandler interface {
Hello(context.Context, *HelloRequest, *HelloResponse) error
}
func RegisterGreeterHandler(s server.Server, hdlr GreeterHandler) {
s.Handle(s.NewHandler(&Greeter{hdlr}))
}
实现 handler
服务端需要注册 handler 来处理请求，一个 handler 是一个这样的方法：
func(ctx context.Context, req interface{}, rsp interface{}) error
正如上面看到的，一个 handler 实现了 API 协议中定义的接口
type GreeterHandler interface {
Hello(context.Context, *HelloRequest, *HelloResponse) error
}
这里是一个 Greeter 的 handler 实现
import proto "github.com/micro/micro/examples/service/proto"
type Greeter struct{}
func (g *Greeter) Hello(ctx context.Context, req *proto.HelloRequest, rsp *proto.HelloResponse) error {
rsp.Greeting = "Hello " + req.Name
return nil
}
handler 需要注册到某个服务
service := micro.NewService(
micro.Name("greeter"),
)
proto.RegisterGreeterHandler(service.Server(), new(Greeter))
运行服务
服务可以直接调用 server.Run() 来运行，这会让服务监听一个随机端口，这个调用也会让服务将自身注册到注册器，当服务停止运行时，会在注册器注销自己。
完整的服务端
package main
import (
"log"
"github.com/micro/go-micro"
proto "github.com/micro/go-micro/examples/service/proto"
"golang.org/x/net/context"
)
type Greeter struct{}
func (g *Greeter) Hello(ctx context.Context, req *proto.HelloRequest, rsp *proto.HelloResponse) error {
rsp.Greeting = "Hello " + req.Name
return nil
}
func main() {
service := micro.NewService(
micro.Name("greeter"),
micro.Version("latest"),
)
service.Init()
proto.RegisterGreeterHandler(service.Server(), new(Greeter))
if err := service.Run(); err != nil {
log.Fatal(err)
}
}
注意，服务发现机制需要首先运行起来，这样服务才能注册到注册器中，才能被客户端发现。
编写客户端
client 包用于向服务端发起请求，当你创建一个服务，客户端可以调用的接口已经自动生成了
调用上面的服务可以用下面的客户端代码
/ create the greeter client using the service name and client
greeter := proto.NewGreeterClient("greeter", service.Client())
// request the Hello method on the Greeter handler
rsp, err := greeter.Hello(context.TODO(), &proto.HelloRequest{
Name: "John",
})
if err != nil {
fmt.Println(err)
return
}
fmt.Println(rsp.Greeter)
proto.NewGreeterClient 就是我们刚才生成的代码，根据服务名称发送请求。
完整的示例可以在这里看到：go-micro/examples/service
