Go Micro V3源码分析

Micro微服务框架解决了什么问题

• 为微服务业务开发提供了开箱即用的脚手架，包括服务治理、服务发现/注册，服务监控，调用链路追踪等
• 高度插件，支持定制业务开发
• Micro脚手架还提供了简单的网关功能

Micro V3代码目录结构

├── api 
├── auth
├── broker <发布订阅>
├── client <rpc/http客户端>
├── cmd
├── codec <编码解码>
├── config <配置类>
├── logger
├── metadata
├── plugins <自定义插件接口>
├── registry <服务注册&发现>
├── selector <客户端负载均衡选择器>
├── server <服务端>
├── store <自定义存储>
├── transport <http请求翻译成rpc>
└── util <工具集>

Micro V3源码之Service

• Service也是一个接口，service是一个应用程序调用micro服务的最外层入口，一般在main中
  • Service源码

    type Service interface {
       // The service name
       Name() string
       // Init initialises options
       Init(...Option)
       // Options returns the current options
       Options() Options
       // Client is used to call services
       Client() client.Client
       // Server is for handling requests and events
       Server() server.Server
       // Run the service
       Run() error
       // The service implementation
       String() string
    }
    

  • Service实际上是Clien和Server的包装
  • main中引入Service

    func main() {
       // Create order service
       srv := rpc.GetNewOrderService()
    
       // Register handler
       _ = pb.RegisterOrderHandler(srv.Server(), new(handler.Order))
    
       // Run service
       if err := srv.Run(); err != nil {
          library.NewLogger().Fatalf("order-service.main srv.run() error: %v", err)
       }
    }
    

  • Service初始化 - step 1

    func newService(opts ...Option) Service {
       service := new(service)
       // `关键在这一步里实现初始化`
       options := newOptions(opts...)
  
       // service name
       serviceName := options.Server.Options().Name
  
       // wrap client to inject From-Service header on any calls
       options.Client = wrapper.FromService(serviceName, options.Client)
       options.Client = wrapper.TraceCall(serviceName, trace.DefaultTracer, options.Client)
  
       // wrap the server to provide handler stats
       err := options.Server.Init(
          server.WrapHandler(wrapper.HandlerStats(stats.DefaultStats)),
          server.WrapHandler(wrapper.TraceHandler(trace.DefaultTracer)),
       )
       if err != nil {
          logger.Fatal(err)
       }
  
       // set opts
       service.opts = options
  
       return service
    }
  

  • Service初始化 - step 2

    func newOptions(opts ...Option) Options {
       opt := Options{
          // 设置默认组件
          Auth:      auth.DefaultAuth,     // 授权初始化，实现Auth接口
          Broker:    broker.DefaultBroker, // 默认HttpBroker，实现Broker接口
          Cmd:       cmd.DefaultCmd,       // 命令行初始化
          Config:    config.DefaultConfig, // 加载配置，实现Config接口
          Client:    client.DefaultClient, // 默认RpcClient，实现Client接口
          Server:    server.DefaultServer, // 默认RpcServer，实现Server接口
          Store:     store.DefaultStore,   // 默认MemoryStore，实现Store接口
          Registry:  registry.DefaultRegistry, // 默认MdnsRegistry，实现了Registry接口
          Runtime:   runtime.DefaultRuntime,
          Transport: transport.DefaultTransport, // 默认HttpTransport，实现了Transport接口
          Context:   context.Background(),
          Signal:    true,
       }
       
       // 通过中间件函数闭包动态设置各组件
       for _, o := range opts {
          o(&opt)
       }
  
       return opt
    }
  

Micro V3源码之Server

• Server接口源码

  // Server is a simple micro server abstraction
  type Server interface {
     // Initialise options
     Init(...Option) error
     // Retrieve the options
     Options() Options
     // Register a handler
     Handle(Handler) error
     // Create a new handler
     NewHandler(interface{}, ...HandlerOption) Handler
     // Create a new subscriber
     NewSubscriber(string, interface{}, ...SubscriberOption) Subscriber
     // Register a subscriber
     Subscribe(Subscriber) error
     // Start the server
     Start() error
     // Stop the server
     Stop() error
     // Server implementation
     String() string
  }

• 请求Server端时候还会涉及到路由Router

  // Router handle serving messages
  type Router interface {
     // ProcessMessage processes a message
     ProcessMessage(context.Context, Message) error
     // ServeRequest processes a request to completion
     ServeRequest(context.Context, Request, Response) error
  }

• RpcServer

  type rpcServer struct {
     router *router
     exit   chan chan error

     sync.RWMutex
     opts        Options
     handlers    map[string]Handler
     subscribers map[Subscriber][]broker.Subscriber
     // marks the serve as started
     started bool
     // used for first registration
     registered bool
     // subscribe to service name
     subscriber broker.Subscriber
     // graceful exit
     wg *sync.WaitGroup

     rsvc *registry.Service
  }

未完待续...