紧接着看看启动都做了什么：

// Start used to start the proxy.
func (p *Proxy) Start() {
    log := p.log
    conf := p.conf
    audit := p.audit
    iptable := p.iptable
    syncer := p.syncer
    router := p.router
    scatter := p.scatter
    plugins := p.plugins
    sessions := p.sessions
    endpoint := conf.Proxy.Endpoint
    throttle := p.throttle
    serverVersion := p.serverVersion

    log.Info("proxy.config[%+v]...", conf.Proxy)
    log.Info("log.config[%+v]...", conf.Log)

    if err := audit.Init(); err != nil {
        log.Panic("proxy.audit.init.panic:%+v", err)
    }
    // 省略了一大堆，为了节省篇幅

    spanner := NewSpanner(log, conf, iptable, router, scatter, sessions, audit, throttle, plugins, serverVersion)
    if err := spanner.Init(); err != nil {
        log.Panic("proxy.spanner.init.panic:%+v", err)
    }
    svr, err := driver.NewListener(log, endpoint, spanner)
    if err != nil {
        log.Panic("proxy.start.error[%+v]", err)
    }
    p.spanner = spanner
    p.listener = svr
    log.Info("proxy.start[%v]...", endpoint)
    go svr.Accept()
}

这个Start函数看起来好像Java中的构造器，做的事情也和构造器有点相似，就是赋值，不过它还能做多的事情，比如说启动了一个监听：

svr, err := driver.NewListener(log, endpoint, spanner)

有了监听之后，就可以启动一个goroutine了，而且是有条件的存活的：

go svr.Accept()

这里的条件就是Accept要做什么：

Accept runs an accept loop until the listener is closed.

在listener关闭之前，Accept将始终运行一个循环，也就是说这个goroutine会一直生存下去。

到这一步proxy就算启动起来了，然后就会去启动Admin了：

    // Admin portal.
    admin := ctl.NewAdmin(log, proxy)
    admin.Start()

按照惯例看看NewAdmin在干什么：

// NewAdmin creates the new admin.
func NewAdmin(log *xlog.Log, proxy *proxy.Proxy) *Admin {
    return &Admin{
        log:   log,
        proxy: proxy,
    }
}

代码逻辑很简单，就是返回一个Admin结构体的指针。而Admin结构体是这样的：

// Admin tuple.
type Admin struct {
    log    *xlog.Log
    proxy  *proxy.Proxy
    server *http.Server
}

看，之前的代码里没有对server进行赋值，这是为什么？答案在Start函数里：

// Start starts http server.
func (admin *Admin) Start() {
    api := rest.NewApi()
    router, err := admin.NewRouter()
    if err != nil {
        panic(err)
    }

    api.SetApp(router)
    handlers := api.MakeHandler()
    admin.server = &http.Server{Addr: admin.proxy.PeerAddress(), Handler: handlers}

    go func() {
        log := admin.log
        log.Info("http.server.start[%v]...", admin.proxy.PeerAddress())
        if err := admin.server.ListenAndServe(); err != http.ErrServerClosed {
            log.Panic("%v", err)
        }
    }()
}

这里是一系列的Http操作，对server的赋值就在其中，此时会把默认IP，端口等等信息都写入到server中：

一看代码我就知道RadonDB要用3308端口进行连接，而起管理端口就注册在8080。

好了，这些都很容易明白，此时Start函数只需要启动一个goroutine就可以了。关键在这里：

看名字就知道这是干什么的，监听并维护一个服务，看看其注释：

那么这样一来，服务就启动起来了，当然后面还会有stop函数，就不再详解了。有意思的是，可以注意这几句：

    // Handle SIGINT and SIGTERM.
    ch := make(chan os.Signal)
    signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
    log.Info("radon.signal:%+v", <-ch)

这几句声明了一个通道，一个Signal类型的通道，可以用于接收系统调用，SIGINT一般是ctrl-c，SIGTERM一般是kill。在发生这两个系统调用后，系统开始关闭。

3. 小结

Go语言还是简单的，至少现在看来，这些代码我是都能看懂的，而我学习Go语言的时间也不过两周。

我希望能借着RadonDB的开源，学会关键的优化器和SQL解析器的思想。