目录

本篇针对上一篇【go-micro学习与实践】进行补充，希望大家能对go-micro有一个全面、清晰的认知！

Server

  • micro.Server(server.Server)：

定义微服务的服务端。服务端⽤于接收并处理客户端请求。go-micro将服务端抽象成了server.Server接⼝。官⽅Server插件库提供的服务端插件包含：grpc，http，mucp。默认采⽤mucp。以mucp为例：mucp是go-micro的原⽣协议。server.NewServer(…server.Option)返回了server.rpcServer插件。

  • server.Name(string)：

配置服务名称。默认go.micro.server。也可以通过micro.Name(string)进⾏配置。

  • server.Id(string)：

服务标识。默认通过uuid.New().String()⽣成。

  • server.Version(string)：

服务版本。默认latest。

  • server.Address(string)：

服务发布地址。使⽤transport.Listen监听时，传⼊的地址。默认:0。

  • server.Advertise(string)：

服务发现地址。节点注册时，该地址随着节点信息⼀同注册到注册中⼼；客户端发起请求时，seletor通过服务名匹配到节点，然后通过该服务发现地址向节点发送请求。默认空，为空时使⽤服务发布地址的真实地址。

  • server.Broker(broker.Broker)：

事件订阅⽅配置。⽤于处理接收到的事件通知，使⽤broker.Subscribe订阅事件。默认broker.httpBroker。

  • server.Codec(contentType string, c codec.NewCodec)：

新增⾃定义消息解码器。服务端通过content-type获取消息解码器，对收到的请求进⾏解码。codec.ReadHeader⽅法解码消息头，codec.ReadBody⽅法解码消息体。

当添加的content-type与默认的相同时，新增编码器的会覆盖默认的解码器。mucp默认的消息解码器如下：

在这里插入图片描述

  • server.Context(context.Context)：

上下⽂，⽤于传递值。mucp服务中，有两个地⽅⽤到context。

1、 存储server.Wait(*sync.WaitGroup)设置的wait值。

2、传递到RegisterCheck⽅法中执⾏。

  • server.Tracer(trace.Tracer)：

服务链路追踪器，客户端发起请求时，构造⼀个包含trace-id和span-id的content，服务端处理请求时，会修改content中的span-id。当前版本该字段默认未⽤到。可通过server.WrapHandler()⾃主实现。

  • server.Transport(transport.Transport)：

服务端通信协议，服务端通过Transport的Listen()⽅法发布服务监听。默认httpTransport。

  • server.Metadata(map[string]string)：

设置元信息。元信息会在节点信息中展示，默认元信息有transport，broker，server，registry，protocol。默认的元信息⽆法修改。

  • server.Registry(registry.Registry)：

服务注册中⼼，启动服务时，通过Regsitry的Register()⽅法向注册中⼼注册节点信息。

  • server.RegisterTTL(time.Duration)：

注册⽣效时间，对应registry插件中的Timeout。默认90s。

  • server.RegisterCheck(func(context.Context) error)：

注册检查。启动服务时，在节点注册前进⾏检查，检查通过才继续注册。服务运⾏时，进⾏周期性检查，检查失败的断开注册，检查成功的重新注册。默认对任何信息都检查通过。

  • server.RegisterInterval(time.Duration)：

注册检查周期，执⾏注册检查的周期，为0时不进⾏周期检查。默认30s。

  • server.TLSConfig(*tls.TLSConfig)：

设置transport监听的tls配置。

  • server.WithRouter(server.Router)：

覆盖默认的请求路由。对客户端对请求进⾏处理，默认是server.router。ProcessMessage()处理事件，ServeRequest()处理微服务请求。

  • server.Wait(*sync.WaitGroup)：

服务退出时，等待请求结束。传空也能设置成功。

  • server.WrapHandler(server.HandlerWrapper)：

请求拦截器。构建请求处理链，先配置的先处理，最后处理router.ServeRequest⽅法。

  • server.Subwrapper(server.SubscriberWrapper)：

事件拦截器。构建事件处理链，先配置的先处理，最后处理router.ProcessMessage⽅法。

srv := micro.NewService(
 micro.Server(
 server.NewServer(
 server.Name(service),
 server.Id(server.DefaultId),
 server.Version(version),
 server.Address(server.DefaultAddress),
 //server.Advertise(server.DefaultAddress),
 server.Broker(broker.DefaultBroker),
 server.Codec("application/text", func(closer io.ReadWriteCloser) codec.Codec {
 return &bytes.Codec{}
 }),
 server.Context(context.Background()),
 server.Registry(registry.DefaultRegistry),
 //server.Tracer(trace.DefaultTracer),
 server.Metadata(map[string]string{"description": "web ui and route"}),
 server.RegisterTTL(server.DefaultRegisterTTL),
 server.Context(context.WithValue(context.Background(), "isReady", true)),
 server.RegisterCheck(func(ctx context.Context) error {
 if !ctx.Value("isReady").(bool) {
 return fmt.Errorf("server not ready to registry")
 }
 return nil
 }),
 server.RegisterInterval(server.DefaultRegisterInterval),
 server.TLSConfig(&tls.Config{Certificates: []tls.Certificate{transportCert}}),
 //server.WithRouter(server.DefaultRouter),
 server.Wait(nil),
 server.WrapHandler(func(handlerFunc server.HandlerFunc) server.HandlerFunc {
 return func(ctx context.Context, req server.Request, rsp interface{}) error {
// ⽀持链路追踪
 newCtx, s := trace.DefaultTracer.Start(ctx, "web")
 s.Type = trace.SpanTypeRequestInbound
 defer trace.DefaultTracer.Finish(s)
 return handlerFunc(newCtx, req, rsp)
 }
 }),
 server.WrapHandler(func(handlerFunc server.HandlerFunc) server.HandlerFunc { //
⽀持auth认证
 return func(ctx context.Context, req server.Request, rsp interface{}) error {
 token := req.Header()[authHeader]
 account, err := auth.DefaultAuth.Inspect(token)
 if err != nil {
 return err
 }
 return handlerFunc(context.WithValue(ctx, "account", account), req, rsp)
 }
 }),
 server.WrapSubscriber(func(subscriberFunc server.SubscriberFunc)
server.SubscriberFunc {
 return func(ctx context.Context, msg server.Message) error {
 return subscriberFunc(ctx, msg)
 }
 }),
 ),
 ),
 )
Server-补充字段

在这里插入图片描述
在这里插入图片描述

srv := micro.NewService(
micro.Name(service),
 micro.Version(version),
micro.RegisterTTL(10*time.Second),
 micro.RegisterInterval(10*time.Second),
micro.Metadata(),
micro.WrapHandler(),
 micro.WrapSubscriber(),
)

client

  • micro.Client(client.Client)：

定义微服务的客户端。客户端⽤于发送请求。go-micro将客户端抽象成了client.Client接⼝。官⽅Client插件库提供的客户端插件包含：grpc，http，mucp。默认mucp。

以mucp为例。client.NewClient(…client.Option)返回了client.rpcClient插件。

  • client.Broker(broker.Broker)：

事件发布⽅配置。⽤于发布事件通知，使⽤Broker.Publish⽅法发布事件。

  • client.Codec(string, codec.NewCodec)：

新增⾃定义消息编码器。客户端通过content-type获取消息编码器，对要发出的请求使⽤codec.Write⽅法进⾏编码。当添加的content-type与默认的相同时，新增编码器的会覆盖默认的编码器。消息编码器和消息解码器⼀⼀对应。

  • client.ContentType(string)：

设置请求头的Content-Type。通过client.NewRequest()构造请求时，将该参数设

置为请求头的Content-Type，客户端和服务端会根据该请求头，进⾏相应的编码和解码。默认applicaiton/json。

  • client.PoolSize(int)：

连接池⼤⼩。连接池每个地址缓存连接池⼤⼩的连接，发起请求时，先通过pool.Get从连接池中获取连接，⽆法获取再创建新的连接；请求结束时，通过pool.Release将连接放回连接池，连接池满或连接出错时，关闭连接，并从连接池中丢弃。

  • client.PoolTTL(time.Duration)：

连接池超时时间。连接创建时，会记录连接的创建时间，每次获取连接时，计算是否超时，超时时，关闭连接，并从连接池中丢弃。

  • client.Transport(transport.Transport)：

客户端端通信协议，客户端通过Transport的Dial⽅法发起请求。默认httpTransport。

  • client.Selector(selector.Selector)：

设置选择器。客户端先通过Registry.GetService，获取注册中⼼该服务所有的节点信息，然后通过选择器策略strategy，在注册中⼼获取⼀个服务端的节点信息，向节点发起请求。默认选择器为selector.registrySelector，该selector包含两个重要⽅法：

  • selector.Registry(registry.Registry)：

设置注册中⼼。

  • selector.SetStrategy(func ([]*registry.Service) Next)：

设置选择器算法。mucp提供的选择器算法有：

【图片】

  • client.Registry(registry.Registry)：

⽤于设置选择器⾥的注册中⼼。同selector.Registry

  • client.Wrap(client.Wrapper)：

客户端中间件。初始化客户端时执⾏的链⽅法。先配置的先执⾏，先执⾏其他参数的初始化，最后执⾏链路上的⽅法，返回最终的客户端。

  • client.WrapCall(client.CallWrapper)：

请求中间件。每次请求时执⾏的链⽅法。先配置的先执⾏。先执⾏链路上的⽅法，最后执⾏client.call⽅法发起tcp请求。

  • client.Backoff(client.BackoffFunc)：

请求备份。请求前执⾏，执⾏完成后，系统休眠⽅法返回的时间。

  • client.Retry(client.RetryFunc)：

请求是否重试。请求完成后，是否重新发起请求.mucp⽀持以下⼏种⽅法

【图片】

  • client.Retries(int)：

请求重试次数。默认1。

  • client.RequestTimeout(time.Duration)：

请求及响应超时时间。该参数将会设置到请求头Timeout。默认5s。

  • client.StreamTimeout(time.Duration)：

流连接超时时间。该参数将会设置到请求头Timeout。默认5s。流连接可以是双向流，也可以是单向流。

  • client.DialTimeout(time.Duration)：

设置transport中的超时时间，默认5s。

  • client.WithRouter(Router)：

设置router，暂时没有⽤到。

srv := micro.NewService(
 micro.Server(
 client.NewClient(
 client.Broker(broker.DefaultBroker),
 client.Codec("application/text", func(closer io.ReadWriteCloser) codec.Codec {
 return &bytes.Codec{}
 }),
 client.ContentType(client.DefaultContentType),
 client.PoolSize(0),
 client.Selector(selector.NewSelector(selector.SetStrategy(selector.RoundRobin))),
 client.Registry(registry.DefaultRegistry),
 client.Wrap(func(c client.Client) client.Client { // 构造客户端
 if c.Options().Registry == nil {
 return nil
 }
 return c
 }),
 client.WrapCall(func(callFunc client.CallFunc) client.CallFunc {
 return func(ctx context.Context, node *registry.Node, req client.Request, rsp
interface{}, opts client.CallOptions) error { // 设置请求链路追踪
 newCtx, s := trace.DefaultTracer.Start(ctx, "web")
 s.Type = trace.SpanTypeRequestInbound
 defer trace.DefaultTracer.Finish(s)
 return callFunc(newCtx, node, req, rsp, opts)
 }
 }),
 client.Backoff(func(ctx context.Context, req client.Request, attempts int)
(time.Duration, error) { // 打印请求
 log.Infof("attempts %v, the req is %v", attempts, req.Body())
 return 0, nil
 }),
 client.Retry(func(ctx context.Context, req client.Request, retryCount int, err
error) (bool, error) {
 return err != nil, nil
 }),
 client.Retries(client.DefaultRetries),
 client.RequestTimeout(client.DefaultRequestTimeout),
 client.StreamTimeout(client.DefaultRequestTimeout),
 client.DialTimeout(transport.DefaultDialTimeout),
 client.WithRouter(nil),
 ),
 ),
 )
Client-补充字段
  • micro.Selector(selector)：

同client.Selector。官⽅Selector插件库提供的选择器插件包含：dns，label，registry，shard，static。默认使⽤registry。

  • micro.WrapClient(…client.Wrapper)：

同client.Wrapper(client.Wrapper)

  • micro.WrapCall(…client.CallWrapper)：

同client.WrapCall(client.CallWrapper)


srv := micro.NewService(
 micro.Selector(selector.DefaultSelector),
 micro.WrapClient(),
 micro.WrapCall(),
 )

Transport

  • micro.Tranport(transport.Transport)：

统⼀定义服务端和客户端中使⽤的transport插件。

go-micro将服务通信抽象成了transport.Transport接⼝。官⽅Transport插件库提供了众多服务通信插件。包含：grpc，http，memory，nats，quic，rabbitmq，tcp，utp。默认http。

以http为例。transport.NewTransport()返回了transport.httpTransport插件。

  • transport.Addr(…string)：

httpTransport中暂时没有⽤到。

  • transport.Codec(codec.Marshaler)：

httpTransport中暂时没有⽤到。

  • transport.Timeout(time.Duration)：

设置服务端和客户端，接收和发送消息的超时时间。零值表示不设置超时时间，默认零值。

  • transport.Secure(bool)：

是否开启tls通信。

  • transport.TLSConfig(*tls.Config)：

tls证书认证配置，为空时，跳过tls校验。

srv := micro.NewService(
 micro.Transport(
 transport.NewHTTPTransport(
 transport.Addrs(),
 transport.Codec(nil),
 transport.Timeout(transport.DefaultDialTimeout),
 transport.Secure(true),
 transport.TLSConfig(&tls.Config{Certificates: []tls.Certificate{caCert}}),
 ),
 ),
 )

Broker

  • micro.Broker(broker.Broker)：

统⼀定义服务端和客户端中使⽤的broker插件。

go-micro将消息通知抽象成了broker.Broker接⼝。官⽅Broker插件库提供的插件包含：gocloud，

googlepubsub，grpc，http，kafka，memory，mqtt，nats，nsq，proxy，rabbitmq，redis，segmentio，snssqs，sqs，stan，stomp。默认使⽤http。

以http为例。broker.NewBroker(…broker.Option)返回了broker.httpBroker插件。

  • broker.Addrs(…string)：

broker订阅地址。发布⽅发布消息后，可通过该地址访问对应节点，进⾏消息通知。

  • broker.Codec(codec.Marshaler)：

消息编码，解码器。发布消息时进⾏编码，接收消息时进⾏解码。

  • broker.ErrorHandler(broker.Handler)：

消息错误处理逻辑。在memory插件中使⽤，发送消息出现错误时，进⾏的处理罗。

  • broker.Registry(registry.Registry)：

设置注册中⼼，httpBroker在订阅时，会向注册中⼼注册⼀条节点订阅信息。httpBroker在发布消息时，会在注册中⼼找到所有订阅的节点，并向这些节点发送消息。

  • broker.Secure(bool)：

是否开启tls通信broker.TLSConfig(*tls.Config)：tls证书认证配置，为空时，跳过tls校验。

srv := micro.NewService(
 micro.Broker(
 broker.NewBroker(
 broker.Addrs(),
 broker.Codec(json.Marshaler{}),
 broker.ErrorHandler(func(event broker.Event) error {
 return nil
 }),
 broker.Registry(registry.DefaultRegistry),
 broker.Secure(true),
 broker.TLSConfig(nil),
 ),
 ),
 )

Registry

  • micro.Registry(registry.Registry)：

统⼀定义服务端，客户端，broker组件中使⽤的registry插件。go-micro将服务注册抽象成了registry.Registry接⼝。官⽅Registry插件库提供了众多服务注册插件。包含：cache，consul，etcd，eureka，gossip，kubernetes，mdns，memory，mutli，nacos，nats，proxy，zookeeper。默认采⽤mdns协议。

以etcd为例：etcd.NewRegistry(…registry.Option)返回了etcd.etcdRegistry插件。

  • registry.Addrs(…string)：

注册中⼼的地址。也可以通过环境变量MICRO_REGISTRY_ADDRESS，etcd默认127.0.0.1:2379。

  • registry.Timeout(time.Duration)：

注册超时时间。通过registry.Timeout(time.Duration)设置，默认5s。

  • registry.Secure(bool)：

是否启⽤tls认证。

  • registry.TLSConfig(*tls.Config)：

tls认证证书配置。

  • etcd⽤户名，密码：

通过环境变量ETCD_USERNAME设置⽤户名，环境变量ETCD_PASSWORD设置密码。

srv := micro.NewService(
 micro.Registry(
etcd.NewRegistry( // 设置etcd注册中⼼
 registry.Addrs(), // etcd 地址。默认127.0.0.1:2379
 registry.Timeout(10*time.Second), // 超时时间
 registry.Secure(true), // 是否启⽤tls
registry.TLSConfig(&tls.Config{Certificates: []tls.Certificate{pair}})
 ), // tls设置
 ),
 )

Auth

  • micro.Auth(auth.Auth)：

定义认证插件。auth的创建和认证，需⾃⾏实现。⽐如在server拦截器中，实现auth逻辑。

go-micro将认证抽象成了auth.Auth接⼝。官⽅Auth插件库提供的插件包含：jwt。默认不使⽤认证。

以jwt为例。jwt.NewAuth(…auth.Option)返回了jwt.jwt插件。

  • auth.Addrs(…string)：

认证地址。jwt未使⽤。

  • auth.Namespace(string)：

微服务命名空间，以原数据Micro-Namespace存储在context中。

  • auth.PublicKey(string)：

⽤于解码jwt。

  • auth.PrivateKey(string)：

⽤于编码jwt。

  • auth.Credentials(string, string)：

存储账号密码。

  • auth.ClientToken(*auth.Token)：

存储token值。

srv := micro.NewService(
 micro.Auth(
 jwt.NewAuth(
 auth.Addrs(),
 auth.Namespace("blog"),
 auth.PublicKey("1234567"),
 auth.PrivateKey("7654321"),
 //auth.Credentials("root", "123"),
 //auth.ClientToken(&auth.Token{}),
 ),
 ),
 )

Cache

  • micro.Cache(cache.Cache)：

定义缓存插件。go-micro将缓存抽象成了cache.Cache接⼝。官⽅Cache插件库提供的插件包含：redis。默认使⽤本地内存缓存。

以redis为例。cache.NewCache(…cache.Option)返回了redis.redisCache插件。

  • cache.Expiration(time.Duration)：

缓存失效时间。适⽤于本地缓存。

  • cache.Items(map[string]cache.Item)：

缓存值，适⽤于本地缓存。

  • cache.WithAddress(string)：

redis服务地址。默认redis://127.0.0.1:6379。

  • cache.WithContext(context.Context)：

上下⽂。暂时没有⽤到。

srv := micro.NewService(
 micro.Cache(
 cacheRedis.NewCache(
 cache.Expiration(10*time.Second),
 //cache.Items(nil),
 cache.WithAddress("redis://127.0.0.1:6379"),
 //cache.WithContext(context.Background()),
 ),
 ),
 )

Store

  • micro.Store(store.Store)：

定义存储插件。⼀个store表示⼀张表。

go-micro将存储抽象成了store.Store接⼝。官⽅Store插件库提供的插件包含：cockroach、consul、file、memcached、memory、mysql、nats-js、redis。默认使⽤memory。

以redis为例。redis.NewStore(…store.Option)返回了redis.redisCache插件。

  • store.Nodes(…string)：

redis连接地址。⽀持redis集群。

  • store.Database(string)：

数据库名称。redis没有⽤到。

  • store.Table(string)：

表名称。redis中，key值由“表名称“+”key”组成。

  • store.WithContext(context.Context)：

上下⽂。redis没有⽤到。

  • store.WithClient(client.Client)：

客户端。redis没有⽤到。

srv := micro.NewService(
 micro.Store(
 redis.NewStore(
 store.Nodes("127.0.0.1:6379"),
 //store.Database("blog"),
 store.Table("web"),
 //store.WithContext(context.Background()),
 //store.WithClient(nil),
 ),
 ),
 )

Config

  • micro.Config(config.Config)：

定义动态配置插件。

go-micro将动态配置抽象成了config.Config接⼝。默认使⽤的是config.config插件。官⽅Config插件库提供了两类插件对config.config插件进⾏配置：

配置插件的格式包含：cue、hcl、toml、xml、yaml。默认json

配置插件的来源⽅包含：configmap，consul，etcd，grpc，mucp，nacos，nats，pkger，runtimevar，url，vault。默认内存。

先通过config.Load(…source.Source)，配置插件的来源及格式。然后通过config.Values中提供的⽅法，就可以对配置的值进⾏增删改等操作。

cfg := config.DefaultConfig() // 定义插件
cfg.Load(etcd.NewSource(source.WithEncoder(yaml.NewEncoder()))) // 对插件进⾏配置
srv := micro.NewService(
 micro.Config(cfg),
 )
srv.Options().Config.Set("value","parentItem","childItem") // 设置配置
srv.Options().Config.Sync()
srv.Options().Config.Get("parentItem","childItem") // 读取配置值

Runtime

  • micro.Runtime(runtime.Runtime)：

定义服务运⾏时。go-micro将服务运⾏时抽象为runtime.Runtime接⼝。官⽅⾃带⽀持两种Runtime插件：kubernetes，memory。

  • kubernetes：

通过k8sAPI对其他微服务进⾏管理。

  • memory：

通过本地进程状态来对其他微服务进⾏管理。

以memory为例。runtime.NewRuntime(…runtime.Option)返回了runtime.runtime组件。

  • runtime.WithSource(string)：

来源。暂未使⽤。

  • runtime.WithScheduler(runtime.Scheduler)：

执⾏计划。服务运⾏时插件启动后，会开启⼀个循环来处理事件（事件类型包含：create，delete，update）。⾃定义执⾏计划可以发布⼀个事件交给服务运⾏时来处理。

  • runtime.WithType(string)：

类型。暂时只在kubernetes中使⽤，以labels的⽅式展示。

  • runtime.WithImage(string)：

镜像。暂未使⽤。

  • runtime.WithClient(client.Client)：

服务端，⽤于发起微服务请求。

type scheduler struct {
 stop chan bool
}
func (s scheduler) Notify() (<-chan runtime.Event, error) {
 var a = make(chan runtime.Event)
 go func() {
 ticker := time.NewTicker(1 * time.Minute)
for {
 select {
 case <-ticker.C:
 a <- runtime.Event{}
 case <-s.stop:
 return
 }
 }
 }()
 return a, nil
}
func (s scheduler) Close() error {
 s.stop <- true
 return nil
}
srv := micro.NewService(
 micro.Runtime(
 runtime.NewRuntime(
 runtime.WithSource("blog"),
 runtime.WithScheduler(&scheduler{}),
 //runtime.WithType("service"),
 //runtime.WithImage("web:1.0"),
 //runtime.WithClient(nil),
 ),
 ),
 )

Cmd

cmd控制程序的启动参数。go-micro，默认对组件的配置进⾏了参数话。可通过以下两个⽅法来扩展启动参数：

micro.Flags(…cli.Flag)：设置启动参数。

micro.Action(func(*cli.Context) error)：获取参数并处理。

srv := micro.NewService(
 micro.Flags(&cli.StringFlag{
 Name: "ca-cert-file",
 Usage: "ca cert file path",
 EnvVars: []string{"CA_CERT_FILE"},
 }, &cli.StringFlag{
 Name: "ca-key-file",
 Usage: "ca key file path",
 EnvVars: []string{"CA_KEY_FILE"},
 }),
 micro.Action(func(c *cli.Context) error {
caCertFile := c.String("ca-cert-file")
caKeyFile := c.String("ca-key-file")
return nil
 }),
 )

Profile

  • micro.Profile(profile.Profile)：

定义了调试组件。

go-micro将调试插件抽象为profile.Profile接⼝。官⽅⾃带⽀持两种Profile插件：http，pprof。

http：以http的形式，提供⽹⻚地址进⾏访问。访问地址：/debug/pprof

pprof：以⽂件的形式保存在本地⽬录。⽬录路径：系统临时⽬录

  • profile.Name(string)：

设置调试组件的名称。

srv := micro.NewService(
 micro.Profile(http.NewProfile(profile.Name("web"))),
 )

流程控制

  • micro.BeforeStart(func() error)：

服务启动前执⾏的⽅法。可设置多个，先设置的先执⾏。

  • micro.AfterStart(func() error)：

服务启动后执⾏的⽅法。可设置多个，先设置的先执⾏。

  • micro.BefortStop(func() error)：

服务关闭前执⾏的⽅法。可设置多个，先设置的先执⾏。

  • micro.AfterStop(func() error)：

服务关闭后执⾏的⽅法。可设置多个，先设置的先执⾏。

  • micro.HandleSignal(bool)：

是否⽀持通过系统信号来关闭服务。为true时，当收到SIGTERM、SIGINT、SIGQUIT、SIGKILL信号时，关闭服务。

srv := micro.NewService(
 micro.BeforeStart(func() error {
 log.Info("before start 1")
 return nil
 }),
 micro.AfterStart(func() error {
 log.Info("after start 1")
 return nil
 }),
 micro.BeforeStart(func() error {
 log.Info("before stop 1")
 return nil
 }),
 micro.BeforeStart(func() error {
 log.Info("after stop 1")
 return nil
 }),
 micro.HandleSignal(true),
 )

配置执⾏顺序

由上述配置可以看到有许多重复的配置。

go-micro采⽤的是循环加载配置。即放在前⾯的配置会先执⾏，后⾯的配置后执⾏，后执⾏的配置会覆盖先执⾏的配置。

⽐如：

micro.NewService(micro.Server(server.Registry(r1)), micro.Registry(r2))，后配置的注册中⼼r2，会覆盖服务中先配置的注册中⼼r1。

# 云原生 # golang # java
Logo
松山湖开发者村综合服务平台

助力广东及东莞地区开发者，代码托管、在线学习与竞赛、技术交流与分享、资源共享、职业发展，成为松山湖开发者首选的工作与学习平台

更多推荐

cover

Spring高手之路10——解锁Spring组件扫描的新视角

avatar 松山湖开发者村综合服务平台
cover

Spring高手之路2——深入理解注解驱动配置与XML配置的融合与区别

avatar 松山湖开发者村综合服务平台
cover

Spring高手之路4——深度解析Spring内置作用域及其在实践中的应用

avatar 松山湖开发者村综合服务平台