欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

golang微服务框架go-micro 入门笔记2.4 go-micro service解读

程序员文章站 2022-08-03 21:41:07
本章节阐述go micro 服务发现原理 go micro架构 下图来自go micro官方 阅读本文前你可能需要进行如下知识储备 + "golang分布式微服务框架go micro 入门笔记1:搭建go micro环境," + "golang微服务框架go micro 入门笔记2.1 micro工 ......

本章节阐述go-micro 服务发现原理

go-micro架构

下图来自go-micro官方

阅读本文前你可能需要进行如下知识储备

service

实现如下接口的,都是service

type service interface {
    init(...option)
    options() options
    client() client.client
    server() server.server
    run() error
    string() string
}

我们根据常见的service初始化流程来理解这个接口

func main() {
    // new service
    service := micro.newservice(
        micro.name("go.micro.srv.broker"),
        micro.version("latest"),
    )

    // initialise service
    service.init()

    // register struct as subscriber
    micro.registersubscriber("go.micro.srv.broker", service.server(), new(subscriber.broker))

    // register function as subscriber
    micro.registersubscriber("go.micro.srv.broker", service.server(), subscriber.handler)

    // run service
    if err := service.run(); err != nil {
        log.fatal(err)
    }
}

micro.newservice

micro.newservice的函数调用关系如下
golang微服务框架go-micro 入门笔记2.4  go-micro service解读
该函数主要是初始化一个service并设置service的常用属性属性,代码如下:

opt := micro.options{
    broker: broker.defaultbroker,
    cmd: cmd.defaultcmd,
    client: client.defaultclient,
    server: server.defaultserver,
    registry: registry.defaultregistry
    }

micro.options全部属性包含如下几个方面

type micro.options struct {
    broker    broker.broker  //订阅事件用的
    cmd       cmd.cmd       //命令行用的
    client    client.client  //作为服务消费者,用来发送请求
    server    server.server  //作为服务提供者用来监听请求
    registry  registry.registry //这个是服务发现支持
    transport transport.transport //这是网络传递用的

    // before and after funcs     
    beforestart []func() error //服务start钱的回调函数
    beforestop  []func() error //服务stop后的回调函数
    afterstart  []func() error //服务start后的回调函数
    afterstop   []func() error //服务stop后的回调函数
    // other options for implementations of the interface
    // can be stored in a context
    context context.context   //有时候服务需要携带一些参数,需要规定时间内返回,可以用这个来承载
}

我们可以通过micro.options.server.options获得server的属性,实际上server还有其他的属性,server的全部参数属性如下

type server.options struct {
    codecs       map[string]codec.newcodec //订阅事件用的
    broker       broker.broker             //订阅事件用的
    registry     registry.registry        //这个是服务发现支持
    transport    transport.transport     //节点之间网络传递用的
    metadata     map[string]string       //传递一些k,v数据用
    name         string                  //名称
    address      string                 //服务地址
    advertise    string                  //广播地址
    id           string                //服务id
    version      string                 //处理程序wrapper
    hdlrwrappers []handlerwrapper            //网络处理程序封装
    subwrappers  []subscriberwrapper        //订阅程序封装

    // registercheck runs a check function before registering the service
    registercheck func(context.context) error   //注册服务前的校验函数
    // the register expiry time
    registerttl time.duration                      //注册服务生命周期,过了这么长事件需要重新注册
    // the interval on which to register
    registerinterval time.duration                     //多长时间注册一次

    // the router for requests
    router router     //请求的路由表

    // other options for implementations of the interface
    // can be stored in a context
    context context.context   //有时候服务需要携带一些参数,需要规定时间内返回,可以用这个来承载
}

如果server需要配置额外的属性,则调用属性配置函数来刷新配置。如name()运行结果是返回一个函数,因此最后通过server.name(name)来刷新这个函数,

micro.name("go.micro.srv.broker"),
// name of the service
func name(n string) option {
    return func(o *options) {
        o.server.init(server.name(n))
    }
}

函数关系如下
golang微服务框架go-micro 入门笔记2.4  go-micro service解读

注意最后的o.name即设置service.options.name = name
micro.version("latest")也是一样的

service.init

init 函数原型如下

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

    s.once.do(func() {
        // initialise the command flags, overriding new service
        _ = s.opts.cmd.init(
            cmd.broker(&s.opts.broker),
            cmd.registry(&s.opts.registry),
            cmd.transport(&s.opts.transport),
            cmd.client(&s.opts.client),
            cmd.server(&s.opts.server),
        )
    })
}

for _, o := range opts代码片段的作用是设置service的属性,底层也是通过 类似o.server.init(server.name(n)来实现的。

s.once.do(func) 这里利用了sync.once特性,这里预示着func只会运行1次。

golang微服务框架go-micro 入门笔记2.4  go-micro service解读

两行传入的参数通过c := a.command(name)来获得需要运行的命令行

service.run

源代码如下

func (s *service) run() error {
    // 这一段代码的作用其实只开启调试支持
    s.opts.server.handle(
        s.opts.server.newhandler(
            handler.defaulthandler,//默认处理脚本handler就是调试
            server.internalhandler(true),//把这个标记为成内置的handler
        ),
    )

    if err := s.start(); err != nil {
        return err
    }

    ch := make(chan os.signal, 1)
    signal.notify(ch, syscall.sigterm, syscall.sigint, syscall.sigquit)

    select {
    // wait on kill signal
    case <-ch:
    // wait on context cancel
    case <-s.opts.context.done():
    }

    return s.stop()
}

s.start()作用是启动服务,目前micro支持的rpcservce/httpservice/apiservice/websercice等,他们都实现了这个start()方法。以rpcservice为例,函数流程如下

golang微服务框架go-micro 入门笔记2.4  go-micro service解读

具体代码解读如下

func (s *rpcserver) start() error {
    config := s.options()

    //启动监听
    ts, err := config.transport.listen(config.address)
    if err != nil {
        return err
    }


    // 连接消息代理
    if err := config.broker.connect(); err != nil {
        return err
    }


    // 注册发现,严格校验注册服务,
    if err = s.opts.registercheck(s.opts.context); err != nil {
        log.logf("server %s-%s register check error: %s", config.name, config.id, err)
    } else {
        // 注册发现,匿名注册
        if err = s.register(); err != nil {
            log.logf("server %s-%s register error: %s", config.name, config.id, err)
        }
    }

    exit := make(chan bool)

    //启动监听服务
    go func() {
        for {
            // 监听
            err := ts.accept(s.serveconn)

            // todo: listen for messages
            // msg := broker.exchange(service).consume()

            select {
            // check if we're supposed to exit
            case <-exit:
                return
            // check the error and backoff
            default:
                if err != nil {
                    log.logf("accept error: %v", err)
                    time.sleep(time.second)
                    continue
                }
            }

            // no error just exit
            return
        }
    }()

    //开启定时注册携程
    go func() {
        t := new(time.ticker)

        // only process if it exists
        if s.opts.registerinterval > time.duration(0) {
            // new ticker
            t = time.newticker(s.opts.registerinterval)
        }

        // return error chan
        var ch chan error

    loop:
        for {
            select {
            // register self on interval
            case <-t.c:
                s.rlock()
                registered := s.registered
                s.runlock()
                //校验注册
                if err = s.opts.registercheck(s.opts.context); err != nil && registered {
                    log.logf("server %s-%s register check error: %s, deregister it", config.name, config.id, err)
                    // deregister self in case of error
                    if err := s.deregister(); err != nil {
                        log.logf("server %s-%s deregister error: %s", config.name, config.id, err)
                    }
                } else {
                    //匿名注册
                    if err := s.register(); err != nil {
                        log.logf("server %s-%s register error: %s", config.name, config.id, err)
                    }
                }
            // wait for exit
            case ch = <-s.exit:
                t.stop()
                close(exit)
                break loop
            }
        }

        // 如果退出来了,那么注销服务
        if err := s.deregister(); err != nil {
            log.logf("server %s-%s deregister error: %s", config.name, config.id, err)
        }

        // 等到请求完成
        if s.wg != nil {
            s.wg.wait()
        }

        // 关闭
        ch <- ts.close()

        // 关闭消息代理连接
        config.broker.disconnect()

        // swap back address
        s.lock()
        s.opts.address = addr
        s.unlock()
    }()

    return nil
}

相关代码获得

关注公众号回复micro-broker即可获得

golang微服务框架go-micro 入门笔记2.4  go-micro service解读

推荐阅读