go微服务框架go-micro深度学习_gomicro还有必要学吗-CSDN博客

一、整体架构介绍

产品嘴里的一个小项目，从立项到开发上线，随着时间和需求的不断激增，会越来越复杂，变成一个大项目，如果前期项目架构没设计的不好，代码会越来越臃肿，难以维护，后期的每次产品迭代上线都会牵一发而动全身。项目微服务化，松耦合模块间的关系，是一个很好的选择，随然增加了维护成本，但是还是很值得的。

微服务化项目除了稳定性我个人还比较关心的几个问题：

一: 服务间数据传输的效率和安全性。

二: 服务的动态扩充，也就是服务的注册和发现，服务集群化。

三: 微服务功能的可订制化，因为并不是所有的功能都会很符合你的需求，难免需要根据自己的需要二次开发一些功能。

go-micro是go语言下的一个很好的rpc微服务框架，功能很完善，而且我关心的几个问题也解决的很好：

一：服务间传输格式为protobuf，效率上没的说，非常的快，也很安全。

二：go-micro的服务注册和发现是多种多样的。我个人比较喜欢etcdv3的服务服务发现和注册。

三：主要的功能都有相应的接口，只要实现相应的接口，就可以根据自己的需要订制插件。

业余时间把go-micro的源码系统地读了一遍，越读越感觉这个框架写的好，从中也学到了很多东西。就想整理一系列的帖子，把学习go-micro的心得和大家分享。

通信流程

go-micro的通信流程大至如下

Server监听客户端的调用，和Brocker推送过来的信息进行处理。并且Server端需要向Register注册自己的存在或消亡，这样Client才能知道自己的状态。

Register服务的注册的发现。

Client端从Register中得到Server的信息，然后每次调用都根据算法选择一个的Server进行通信，当然通信是要经过编码/解码，选择传输协议等一系列过程的。

如果有需要通知所有的Server端可以使用Brocker进行信息的推送。

Brocker 信息队列进行信息的接收和发布。

go-micro之所以可以高度订制和他的框架结构是分不开的，go-micro由8个关键的interface组成，每一个interface都可以根据自己的需求重新实现，这8个主要的inteface也构成了go-micro的框架结构。

这些接口go-micir都有他自己默认的实现方式，还有一个go-plugins是对这些接口实现的可替换项。你也可以根据需求实现自己的插件。

这篇帖子主要是给大家介绍go-micro的主体结构和这些接口的功能，具体细节以后的文章我们再慢慢说：

Transort

服务之间通信的接口。也就是服务发送和接收的最终实现方式，是由这些接口定制的。

源码：

type Socket interface {
    Recv(*Message) error
    Send(*Message) error
    Close() error
}
 
type Client interface {
    Socket
}
 
type Listener interface {
    Addr() string
    Close() error
    Accept(func(Socket)) error
}
 
type Transport interface {
    Dial(addr string, opts ...DialOption) (Client, error)
    Listen(addr string, opts ...ListenOption) (Listener, error)
    String() string
}

Transport 的Listen方法是一般是Server端进行调用的，他监听一个端口，等待客户端调用。

Transport 的Dial就是客户端进行连接服务的方法。他返回一个Client接口，这个接口返回一个Client接口，这个Client嵌入了Socket接口，这个接口的方法就是具体发送和接收通信的信息。

http传输是go-micro默认的同步通信机制。当然还有很多其他的插件：grpc,nats,tcp,udp,rabbitmq,nats，都是目前已经实现了的方式。在go-plugins里你都可以找到。

Codec

有了传输方式，下面要解决的就是传输编码和解码问题，go-micro有很多种编码解码方式，默认的实现方式是protobuf,当然也有其他的实现方式，json、protobuf、jsonrpc、mercury等等。

源码

type Codec interface {
    ReadHeader(*Message, MessageType) error
    ReadBody(interface{}) error
    Write(*Message, interface{}) error
    Close() error
    String() string
}
 
type Message struct {
    Id     uint64
    Type   MessageType
    Target string
    Method string
    Error  string
    Header map[string]string
}

Codec接口的Write方法就是编码过程，两个Read是解码过程。

Registry

服务的注册和发现，目前实现的consul,mdns, etcd,etcdv3,zookeeper,kubernetes.等等，

type Registry interface {
    Register(*Service, ...RegisterOption) error
    Deregister(*Service) error
    GetService(string) ([]*Service, error)
    ListServices() ([]*Service, error)
    Watch(...WatchOption) (Watcher, error)
    String() string
    Options() Options
}

简单来说，就是Service 进行Register，来进行注册，Client 使用watch方法进行监控，当有服务加入或者删除时这个方法会被触发，以提醒客户端更新Service信息。

默认的是服务注册和发现是consul，但是个人不推荐使用，因为你不能直接使用consul集群

我个人比较喜欢etcdv3集群。大家可以根据自己的喜好选择。

Selector

以Registry为基础，Selector 是客户端级别的负载均衡，当有客户端向服务发送请求时， selector根据不同的算法从Registery中的主机列表，得到可用的Service节点，进行通信。目前实现的有循环算法和随机算法，默认的是随机算法。

源码：

type Selector interface {
    Init(opts ...Option) error
    Options() Options
    // Select returns a function which should return the next node
    Select(service string, opts ...SelectOption) (Next, error)
    // Mark sets the success/error against a node
    Mark(service string, node *registry.Node, err error)
    // Reset returns state back to zero for a service
    Reset(service string)
    // Close renders the selector unusable
    Close() error
    // Name of the selector
    String() string
}

默认的是实现是本地缓存，当
前实现的有blacklist,label,named等方式。

Broker

Broker是消息发布和订阅的接口。很简单的一个例子，因为服务的节点是不固定的，如果有需要修改所有服务行为的需求，可以使服务订阅某个主题，当有信息发布时，所有的监听服务都会收到信息，根据你的需要做相应的行为。

源码

type Broker interface {
    Options() Options
    Address() string
    Connect() error
    Disconnect() error
    Init(...Option) error
    Publish(string, *Message, ...PublishOption) error
    Subscribe(string, Handler, ...SubscribeOption) (Subscriber, error)
    String() string
}

Broker默认的实现方式是http方式，但是这种方式不要在生产环境用。go-plugins里有很多成熟的消息队列实现方式，有kafka、nsq、rabbitmq、redis，等等。

Client

Client是请求服务的接口，他封装Transport和Codec进行rpc调用，也封装了Brocker进行信息的发布。

源码

type Client interface {
    Init(...Option) error
    Options() Options
    NewMessage(topic string, msg interface{}, opts ...MessageOption) Message
    NewRequest(service, method string, req interface{}, reqOpts ...RequestOption) Request
    Call(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error
    Stream(ctx context.Context, req Request, opts ...CallOption) (Stream, error)
    Publish(ctx context.Context, msg Message, opts ...PublishOption) error
    String() string
}

当然他也支持双工通信 Stream 这些具体的实现方式和使用方式，以后会详细解说。

默认的是rpc实现方式，他还有grpc和http方式，在go-plugins里可以找到

Server

Server看名字大家也知道是做什么的了。监听等待rpc请求。监听broker的订阅信息，等待信息队列的推送等。

源码

type Server interface {
    Options() Options
    Init(...Option) error
    Handle(Handler) error
    NewHandler(interface{}, ...HandlerOption) Handler
    NewSubscriber(string, interface{}, ...SubscriberOption) Subscriber
    Subscribe(Subscriber) error
    Register() error
    Deregister() error
    Start() error
    Stop() error
    String() string
}

默认的是rpc实现方式，他还有grpc和http方式，在go-plugins里可以找到

Service

Service是Client和Server的封装，他包含了一系列的方法使用初始值去初始化Service和Client，使我们可以很简单的创建一个rpc服务。

源码：

type Service interface {
    Init(...Option)
    Options() Options
    Client() client.Client
    Server() server.Server
    Run() error
    String() string
}

二、入门例子

上一篇帖子简单介绍了go-micro的整体框架结构，这一篇主要写go-micro使用方式的例子，中间会穿插一些go-micro的源码，和调用流程图，帮大家更好的理解go-micro的底层。更详细更具体的调用流程和细节，会在以后的帖子里详细讲解。

例子的github地址： gomicrorpc 跑一遍例子，也就会明白个大概。

安装所需要的环境

go-micro服务发现默认使用的是consul，

brew install consul
consul agent -dev

或者直接使用使用docker跑

docker run -p 8300:8300 -p 8301:8301 -p 8301:8301/udp -p 8302:8302/udp -p 8302:8302 -p 8400:8400 -p 8500:8500 -p 53:53/udp consul

我个人更喜欢etcdv3原因我上一篇也有提到过，gomicro服务发现不支持consul集群，我之前也写过etcdv3 集群的搭建和使用帖子，有时间大家可以看一下

安装go-micro框架

go get github.com/micro/go-micro

安装protobuf和依赖 prtobuf的基础知识我这里就不讲了，如果不了解的可以看一下官方文档，就是一个跨平台，跨语言的数据序列化库，简单易学。

是go-micro用于帮助我们生成服务接口和一系列的调用代码

brew install protobuf
go get -u -v github.com/golang/protobuf/{proto,protoc-gen-go}
go get -u -v github.com/micro/protoc-gen-micro

protobuf也可以直接从源码安装

wget https://github.com/protocolbuffers/protobuf/releases/download/v3.6.1/protobuf-all-3.6.1.tar.gz
tar zxvf protobuf-all-3.6.1.tar.gz
cd protobuf-3.6.1/
./autogen.sh
./configure
 make
make install
protoc -h

安装micro工具包，这个安装是可选项，micro提供了一系列的工具来帮助我们更好的使用go-micro。

go get github.com/micro/micro

例子1

创建proto文件common.proto，这个文件包含了传入和返回的参数，参数包含了常用的基础类型、数组、map等。还有一个Say 服务，这个服务里有一个rpc方法。

syntax = "proto3";

package model;

message SayParam {
    string msg = 1;
}

message Pair {
    int32 key = 1;
    string values = 2;
}

message SayResponse {
    string msg = 1;
    // 数组
    repeated string values = 2;
    // map
    map<string, Pair> header = 3;
    RespType type = 4;
}

enum RespType {
    NONE = 0;
    ASCEND = 1;
    DESCEND = 2;
}

// 服务接口
service Say {
    rpc Hello(SayParam) returns (SayResponse) {}
}

在根目录下运行，生成两个模板文件

  protoc --proto\_path=$GOPATH/src:. --micro\_out=. --go_out=. example1/proto/*.proto

一个文件是proto的go 结构文件，还有一个go-micro rpc的接口文件。

server 端：

type Say struct {}

func (s \*Say) Hello(ctx context.Context, req \*model.SayParam, rsp *model.SayResponse) error {
    fmt.Println("received", req.Msg)
    rsp.Header = make(map\[string\]*model.Pair)
    rsp.Header\["name"\] = &model.Pair{Key: 1, Values: "abc"}

    rsp.Msg = "hello world"
    rsp.Values = append(rsp.Values, "a", "b")
    rsp.Type = model.RespType_DESCEND

    return nil
}


func main() {
    // 我这里用的etcd 做为服务发现，如果使用consul可以去掉
    reg := etcdv3.NewRegistry(func(op *registry.Options){
        op.Addrs = \[\]string{
            "http://192.168.3.34:2379", "http://192.168.3.18:2379", "http://192.168.3.110:2379",
        }
    })

    // 初始化服务
    service := micro.NewService(
        micro.Name("lp.srv.eg1"),
        micro.Registry(reg),
    )
    service.Init()
    // 注册 Handler
    model.RegisterSayHandler(service.Server(), new(Say))

    // run server
    if err := service.Run(); err != nil {
        panic(err)
    }
}

服务发现我使用的是etcdv3 替换了默认的consul

micro.NewService 初始化服务，然后返回一个Service接口的实例，newService()方法的大概流程如下，

先是给各个接口初始化默认值，再使用传入的值替换默认值，这也是go-micro可替换插件的地方。

service有一个Init()可选方法，这是一个单例方法，

func (s *service) Init(opts ...Option) {
    // process options
    for _, o := range opts {
        o(&s.opts)
    }

    s.once.Do(func() {
        // save user action
        action := s.opts.Cmd.App().Action
        // set service action
        s.opts.Cmd.App().Action = func(c *cli.Context) {
                .........//这里就不把代码全显示出来了
                .........
        }
}

用于始化cmd的一些信息

service.Run()方法调用流程

因为在初始化的时候没有指定端口，系统会自动分配一个端口号分给Server，并把这个server的信息注册到Register。

BeferStart和AfterStart也都是可以自定义的

client 端：

func main() {
    // 我这里用的etcd 做为服务发现，如果使用consul可以去掉
    reg := etcdv3.NewRegistry(func(op *registry.Options){
        op.Addrs = \[\]string{
            "http://192.168.3.34:2379", "http://192.168.3.18:2379", "http://192.168.3.110:2379",
        }
    })

    // 初始化服务
    service := micro.NewService(
        micro.Registry(reg),
    )
    service.Init()
    sayClent := model.NewSayService("lp.srv.eg1", service.Client())


    rsp, err := sayClent.Hello(context.Background(), &model.SayParam{Msg: "hello server"})
    if err != nil {
        panic(err)
    }

    fmt.Println(rsp)

}

上面根据proto文件的生成的两个文件中有一个是rpc的接口文件，接口文件已经帮我们把调用方法的整个流程封装好了。

只需要给出服务名称和licent就可以。然后调用Hello方法

源码：

func (c \*sayService) Hello(ctx context.Context, in \*SayParam, opts ...client.CallOption) (*SayResponse, error) {
    req := c.c.NewRequest(c.name, "Say.Hello", in)
    out := new(SayResponse)
    err := c.c.Call(ctx, req, out, opts...)
    if err != nil {
        return nil, err
    }
    return out, nil
}

主要的流程里都在c.c.Call方法里。简单来说流程如下

就是得到节点信息address，根据address去查询 pool里是否有连接，如果有则取出来，如果没有则创建，然后进行数据传输，传输完成后把client放回到pool内。pool的大小也是可以控制的，这部分的代码读起来特别爽，具体的细节和处理流程会在以后的帖子里详细讲解

例子2

例子1，做了一个简单的服务，已经不能再简单了，只是为了能让大家熟悉一下go-micro。看完例子1后应该会有更多的想法，想使用更多的go-micro的功能，比如protobuf生成的类都在一起，如果想model和api分开怎么处理，怎么使用go-micro的双向流，怎么使用消息推送，等等。所以我就双做了一个小例子，这个例子里包含了一些东西。

这个例子我就只说一下组织结构，也没有多少代码，大家有时间看一下就ok了。

proto下的两个文件夹，一个model一个rpcapi，是把数据和api分开，api引用了model

看一下rpcapi

syntax = "proto3";

package rpcapi;
import "github.com/lpxxn/gomicrorpc/example2/proto/model/common.proto";

// 服务接口
service Say {
    rpc Hello(model.SayParam) returns (model.SayResponse) {}
    rpc Stream(model.SRequest) returns (stream model.SResponse) {}

}

import了model里的common.proto

在生成的时候一个只要go_out另一个只要micro_out就好了

  protoc --proto_path=$GOPATH/src:. --go_out=. example2/proto/model/*.proto 
  
  protoc --proto_path=$GOPATH/src:. --micro_out=. example2/proto/rpcapi/*.proto

订阅一个信息

    // Register Subscribers
    if err := server.Subscribe(server.NewSubscriber(common.Topic1, subscriber.Handler)); err != nil {
        panic(err)
    }

当有信息发送时，所有订阅了lp.srv.eg2.topic1这个信息的服务都会收到信息

客户端发送信息

    p := micro.NewPublisher(common.Topic1, service.Client())
    p.Publish(context.TODO(), &model.SayParam{Msg: lib.RandomStr(lib.Random(3, 10))})

如果是生产环境一定不要用go-micro默认的信息发布和订阅处理方式，micro的插件plugin里是有很多成熟的插件。

使用双向流的小功能

这个方法只是每次向客户端发送一些数据，每次只发送一部分。比如我们给客户端推送的数据很大时，一次性全都推过去，是不太正确的做法，分批推送还是比较好的。

func (s \*Say) Stream(ctx context.Context, req \*model.SRequest, stream rpcapi.Say_StreamStream) error {
    for i := 0; i < int(req.Count); i++ {
        rsp := &model.SResponse{}
        for j := lib.Random(3, 5); j < 10; j++ {
            rsp.Value = append(rsp.Value, lib.RandomStr(lib.Random(3, 10)))
        }
        if err := stream.Send(rsp); err != nil {
            return err
        }
        // 模拟处理过程
        time.Sleep(time.Microsecond * 50)
    }
    return nil
}

希望这个小例子能让大家入门go-micro.

三、Registry服务的注册和发现

服务的注册与发现是微服务必不可少的功能，这样系统才能有更高的性能，更高的可用性。go-micro框架的服务发现有自己能用的接口Registry。只要实现这个接口就可以定制自己的服务注册和发现。

go-micro在客户端做的负载，典型的Balancing-aware Client模式。

服务端把服务的地址信息保存到Registry, 然后定时的心跳检查，或者定时的重新注册服务。客户端监听Registry，最好是把服务信息保存到本地，监听服务的变动，更新缓存。当调用服务端的接口是时，根据客户端的服务列表和负载算法选择服务端进行通信。

go-micro的能用Registry接口

type Registry interface {
    Register(*Service, ...RegisterOption) error
    Deregister(*Service) error
    GetService(string) ([]*Service, error)
    ListServices() ([]*Service, error)
    Watch(...WatchOption) (Watcher, error)
    String() string
    Options() Options
}
 
type Watcher interface {
    // Next is a blocking call
    Next() (*Result, error)
    Stop()
}

这个接口还是很简单明了的，看方法也大概能猜到主要的作用

Register方法和Deregister是服务端用于注册服务的，Watcher接口是客户端用于监听服务信息变化的。

接下来我以go-micro的etcdv3为Registry的例给大家详细讲解一下go-micro的详细服务发现过程

go-micro 服务端注册服务

流程图

服务端看上去流程还是比较简单的，当服务端调用Run()方法时，会调用service.Start()方法。这个除了监听端口，启动服务，还会把服务的ip端口号信息，和所有的公开接口的元数据信息保存到我们选择的Register服务器上去。

看上去没有问题，但是，如果我们的节点发生故障，也是需要告诉Register把我们的节点信息删除掉。

Run()方法中有个go s.run(ex) 方法的调用，这个方法就是根据我们设置interval去重新注册服务，当然比较保险的方式是我们把服务的ttl也设置上，这样当服务在未知的情况下崩溃，到了ttl的时间Register服务也会自动把信息删除掉。

设置服务的ttl和 interval

    // 初始化服务
    service := micro.NewService(
        micro.Name(common.ServiceName),
        micro.RegisterTTL(time.Second*30),
        micro.RegisterInterval(time.Second*20),
        micro.Registry(reg),
    )

ttl就是注册服务的过期时间，interval就是间隔多久再次注册服务。如果系统崩溃，过期时间也会把服务删除掉。客户端当然也会有相应的判断，下面会详细解说

客户端发现服务

客户端的服务发现要步骤多一些，但并不复杂，他涉及到服务选择Selector和服务发现Register两部分。

Selector是基于服务发现的，根据你选择的主机选择算法，返回主机的信息。默认的情况，go-micro是每次要得到服务器主机的信息都要去Register去获取。但是查看cmd.go的源码你会发现默认初始化的值，selector的默认flag是cache。DefaultSelectors里的cache对应的就是初始化cacheSelector方法

但是当你在执行service.Init()方法时

go-micro会把默认的selector替换成cacheSelector,具体的实现是在cmd.go的Before方法里

cacheSelector 会把从Register里获取的主机信息缓存起来。并设置超时时间，如果超时则重新获取。在获取主机信息的时候他会单独跑一个协程，去watch服务的注册，如果有新节点发现，则加到缓存中，如果有节点故障则删除缓存中的节点信息。当client还要根据selector选择的主机选择算法才能得到主机信息，目前只有两种算法，循环和随机法。为了增加执行效率，很client端也会设置缓存连接池，这个点，以后会详细说。

所以大概的客户端服务发现流程是下面这样