Beego源码解析-(三)-HTTP请求处理流程

原文地址:
Beego源码解析-(三)-HTTP请求处理流程

关于上一篇文章Beego源码解析(二)-路由机制中介绍了在 Beego中如注册路由以及如何将我们自定义的路由加入到 Beego的 App实例中
我们知道关于注册的路由都是会加入到路由树的节点中,那么在 HTTP的请求中,查找路由树就是非常关键的一部分了

这篇文章将梳理一遍在 Beego启动后,处理 HTTP请求的流程

关于 Beego的源码注释可以见我的Github

beego.Run()入口

在第一篇文章中就曾提到过,在启动 Beego应用时都是通过调用 beego.Run()方法启动.而这个方法在设置了6个回到调函数后会进入 app.Run()方法(app就是我们 Beego应用程序的一个实例,在 app.go的 init()函数中被初始化)

app.Run()函数

app.Run()函数就是在一切都准备好之后进入 HTTP请求循环的一个启动函数了,函数并不是很长而且逻辑比较简单,结合注释看下即可
beego/app.go:

// beego程序启动函数func (app *App) Run() {    //获得地址    addr := BConfig.Listen.HTTPAddr    if BConfig.Listen.HTTPPort != 0 {        addr = fmt.Sprintf("%s:%d", BConfig.Listen.HTTPAddr, BConfig.Listen.HTTPPort)    }    var (        err        error        l          net.Listener        endRunning = make(chan bool, 1)    )    // 运行 CGI服务器    if BConfig.Listen.EnableFcgi {}    //这里设置标准包中的 http.Server.handler为 app.ServerHandler    //也就是 ContollerRegister类型,因为 ControllerRegister实现了 ServeHTTP()函数    app.Server.Handler = app.Handlers    //设置超时    app.Server.ReadTimeout = time.Duration(BConfig.Listen.ServerTimeOut) * time.Second    app.Server.WriteTimeout = time.Duration(BConfig.Listen.ServerTimeOut) * time.Second    // 运行热编译模式    if BConfig.Listen.Graceful {        httpsAddr := BConfig.Listen.HTTPSAddr        app.Server.Addr = httpsAddr        // 热编译模式下的 HTTPS        if BConfig.Listen.EnableHTTPS {            go func() {                time.Sleep(20 * time.Microsecond)                if BConfig.Listen.HTTPSPort != 0 {                    httpsAddr = fmt.Sprintf("%s:%d", BConfig.Listen.HTTPSAddr, BConfig.Listen.HTTPSPort)                    app.Server.Addr = httpsAddr                }                server := grace.NewServer(httpsAddr, app.Handlers)                server.Server.ReadTimeout = app.Server.ReadTimeout                server.Server.WriteTimeout = app.Server.WriteTimeout                //执行 HTTPS的 ListenAndServerTLS()                if err := server.ListenAndServeTLS(BConfig.Listen.HTTPSCertFile, BConfig.Listen.HTTPSKeyFile); err != nil {                    BeeLogger.Critical("ListenAndServeTLS: ", err, fmt.Sprintf("%d", os.Getpid()))                    time.Sleep(100 * time.Microsecond)                    endRunning <- true                }            }()        }        // 热编译模式下的 HTTP        if BConfig.Listen.EnableHTTP {            go func() {                server := grace.NewServer(addr, app.Handlers)                server.Server.ReadTimeout = app.Server.ReadTimeout                server.Server.WriteTimeout = app.Server.WriteTimeout                if BConfig.Listen.ListenTCP4 {                    server.Network = "tcp4"                }                // 执行 HTTP的 ListenAndServe()                if err := server.ListenAndServe(); err != nil {                    BeeLogger.Critical("ListenAndServe: ", err, fmt.Sprintf("%d", os.Getpid()))                    time.Sleep(100 * time.Microsecond)                    endRunning <- true                }            }()        }        <-endRunning        return    }    // 运行普通模式    app.Server.Addr = addr    // HTTPS    if BConfig.Listen.EnableHTTPS {        go func() {            time.Sleep(20 * time.Microsecond)            if BConfig.Listen.HTTPSPort != 0 {                app.Server.Addr = fmt.Sprintf("%s:%d", BConfig.Listen.HTTPSAddr, BConfig.Listen.HTTPSPort)            }            BeeLogger.Info("https server Running on %s", app.Server.Addr)            // 运行 ListenAndServeTLS            if err := app.Server.ListenAndServeTLS(BConfig.Listen.HTTPSCertFile, BConfig.Listen.HTTPSKeyFile); err != nil {                BeeLogger.Critical("ListenAndServeTLS: ", err)                time.Sleep(100 * time.Microsecond)                endRunning <- true            }        }()    }    // HTTP    if BConfig.Listen.EnableHTTP {        go func() {            app.Server.Addr = addr            BeeLogger.Info("http server Running on %s", app.Server.Addr)            if BConfig.Listen.ListenTCP4 {                //TCP4                ln, err := net.Listen("tcp4", app.Server.Addr)                if err != nil {                    BeeLogger.Critical("ListenAndServe: ", err)                    time.Sleep(100 * time.Microsecond)                    endRunning <- true                    return                }                if err = app.Server.Serve(ln); err != nil {                    BeeLogger.Critical("ListenAndServe: ", err)                    time.Sleep(100 * time.Microsecond)                    endRunning <- true                    return                }            } else {                // 运行 ListenAndServe()                if err := app.Server.ListenAndServe(); err != nil {                    BeeLogger.Critical("ListenAndServe: ", err)                    time.Sleep(100 * time.Microsecond)                    endRunning <- true                }            }        }()    }    <-endRunning}

这里需要注意的因为主要讲 HTTP的请求处理,所以为了代码更短我将 CGI部分的代码删掉了
想看的可以去看 app.Run()的源码 :D

这个函数的逻辑也比较简单,因为在运行到这个函数之前该初始化的地方已经都做好了
所以这个函数只需要根据不同的配置启动不同的服务就行,不同的是根据不同的服务需要调用
* serve.Server() 对应TCP4
* server.ListenAndServe() 对应HTTP
* serve.ListenAndServeLTS() 对应HTTPS

另外我们也注意到在 热编译的模式中, app.server被 grace.NewServer()函数的返回值给重写了
因为主要研究 HTTP的处理,所以这里对 grace包不做深究

ServeHTTP()

了解 http包的都应该知道,在 http.Server.ListenAndServe()被调用后,每当有 HTTP请求来到时就会开启一个新的 goroutine并且调用对应 Server的 Handler接口处理(Handler接口包含了 ServeHTTP()方法).而且我们看到在 app.Run()方法中有一句

app.Server.Handler = app.Handlers

而这个 app.Handlers也就是我们在第二篇文章中介绍到的 ControllerRegister类型的结构体了
在 beego/router.go:622行我们也可以发现 ControllerRegister类型实现了 ServeHTTP()方法,那么这个方法就是我们的重中之重了!
这个函数的实现有258行,所以就不贴代码了,让我们可以一点一点看

func (p *ControllerRegister) ServeHTTP(rw http.ResponseWriter, r *http.Request) {startTime := time.Now()var (    runRouter  reflect.Type    findRouter bool//是否找到路由    runMethod  string    routerInfo *controllerInfo)    context := p.pool.Get().(*beecontext.Context)    context.Reset(rw, r)    defer p.pool.Put(context)    defer p.recoverPanic(context)

函数的开始就是先获得时间,然后从 ControllerRegister中的pool对象池获得一个　Context对象
Context对象是对HTTP连接的封装,我们暂时可以理解为 Context中的输入就是客户端发来的信息,输出就是服务器向客户端要发送的信息,所以获得 Context对象后调用 context.Reset()传入当前的 http连接初始化它,可以方便以后的使用

// 路由大小写敏感    if !BConfig.RouterCaseSensitive {        urlPath = strings.ToLower(r.URL.Path)    } else {        urlPath = r.URL.Path    }    // 检查请求中的方法是否支持    if _, ok := HTTPMETHOD[r.Method]; !ok {        // 不支持则返回405状态        http.Error(rw, "Method Not Allowed", 405)        // 记录        goto Admin    }    // 检查对应 url的的 filter    if p.execFilter(context, BeforeStatic, urlPath) {        goto Admin    }    // 查找静态文件    serverStaticRouter(context)//只对于 "GET"和"HEAD"请求方法有效    if context.ResponseWriter.Started {        //路由找到并且发送了相应的文件则修改 findRouter标志位并且跳转到记录        findRouter = true        goto Admin    }

这里可以看到先根据大小写敏感配置设定 URL的大小写,然后检查传过来的方法是否支持
HTTPMETHOD是一个全局类型的 map[string]string类型,主要保存了支持的方法
然后调用 p.execFilter()方法,执行对应的Filter,注意这里的 p.execFilter()会在每个阶段被调用能够,这里的阶段有5个,被定义在 beego/router.go:36

const (    BeforeStatic = iota    BeforeRouter    BeforeExec    AfterExec    FinishRouter)

这里的5个阶段同时也对应着 ControllerRegister.filters中的 key,在　p.execFilters()方法中也正是用了不同阶段作为参数而在 ControllerRegister.filters成员总寻找相应的 Filter的

接下来
就是调用 serverStaticRouter(方法查找静态文件,如果找到,并且 context.ResponseWriter.Started标志位被置位,表示已经开始发送文件,这时只需要跳转到 Admin处记录下这次连接的信息就可以结束了,否则继续执行)

    //对于非 "GET"和"HEAD"的请求方法开始解析参数    if r.Method != "GET" && r.Method != "HEAD" {        if BConfig.CopyRequestBody && !context.Input.IsUpload() {            context.Input.CopyBody(BConfig.MaxMemory)        }        context.Input.ParseFormOrMulitForm(BConfig.MaxMemory)    }    // session初始化    if BConfig.WebConfig.Session.SessionOn { //...省略}    //检查 Filter,与659行相似,但是会查找不同的 filters数组    if p.execFilter(context, BeforeRouter, urlPath) {        goto Admin    }    //前面的静态文件未找到,开始查找路由的过程    if !findRouter {        httpMethod := r.Method        if t, ok := p.routers[httpMethod]; ok {            //这里通过 p.routers[httpMethod]进入路由树            runObject := t.Match(urlPath, context)//找到路由树中对应的 runObject变量            if r, ok := runObject.(*controllerInfo); ok {                //将 runObject变量还原回 controllerInfo结构体                routerInfo = r                findRouter = true                if splat := context.Input.Param(":splat"); splat != "" {                    //如果为全匹配方式,再进行分割                    for k, v := range strings.Split(splat, "/") {                        context.Input.SetParam(strconv.Itoa(k), v)                    }                }            }        }    }  // 如果程序执行到这里还没有找到路由则抛出一个异常并跳转到记录    if !findRouter {        exception("404", context)        goto Admin    }

如果前面请求的不是静态文件,则开始解析请求的参数
然后初始化 session,也就是利用 Session管理器开始一个 Session会话,并且用 defer关键字关闭会话
接下来开始执行 BeforeRouter阶段的 Filter
可以看到,在 findRouter标志位未被置位的情况下开始路由的查找,这里的逻辑是先通过 ControllerRegister的 routers成员(也就是第二篇文章中向里面注册路由的变量)通过请求的方法名找到对应的路由树,然后通过 Tree.Match()方法找到对应URL的Tree节点中的 runnObject对象(忘掉 runObject的话可以去看Beego源码解析(二)-路由机制中那篇文章)

只要找到了 runObject,我们就获得了当初注册路由时的自定义 Controller对象的信息,当然如果查找路由还找不到就向客户端返回”404”错误

当完成路由的查找后,接下来就应该是执行对应的方法了,这也是比较重要的一段代码

    //找到了路由,进行动作    if findRouter {        //查找对应的 Filter        if p.execFilter(context, BeforeExec, urlPath) {            goto Admin        }        isRunnable := false        //找到了 routerInfo        if routerInfo != nil {            //RESTFul路由,执行对应的方法            if routerInfo.routerType == routerTypeRESTFul {                //查找到了对应的方法,所以调用回调函数                if _, ok := routerInfo.methods[r.Method]; ok {                    isRunnable = true                    routerInfo.runFunction(context)//执行对应的回调方法                } else {                    exception("405", context)                    goto Admin                }            } else if routerInfo.routerType == routerTypeHandler {                //Handler类型的路由                isRunnable = true                routerInfo.handler.ServeHTTP(rw, r)//执行　Handler类型的路由回调方法            } else {                //其他类型的请求                runRouter = routerInfo.controllerType                method := r.Method                if r.Method == "POST" && context.Input.Query("_method") == "PUT" {                    method = "PUT"                }                if r.Method == "POST" && context.Input.Query("_method") == "DELETE" {                    method = "DELETE"                }                if m, ok := routerInfo.methods[method]; ok {                    //如果找到注册过的方法,则赋值                    runMethod = m                } else if m, ok = routerInfo.methods["*"]; ok {                    //如果支持通配符'*',则赋值                    runMethod = m                } else {                    runMethod = method                }            }        }        // also defined runRouter & runMethod from filter        //没有正在运行的情况,即在732行的两个 if都没有匹配到        if !isRunnable {            //Invoke the request handler            vc := reflect.New(runRouter)            execController, ok := vc.Interface().(ControllerInterface)//这是为了还原出注册时的 Controller结构体变量            if !ok {                panic("controller is not ControllerInterface")            }            //call the controller init function            //调用 Controller的 init()函数            execController.Init(context, runRouter.Name(), runMethod, vc.Interface())            //call prepare function            //调用 Controller的 Prepare()函数            execController.Prepare()            //if XSRF is Enable then check cookie where there has any cookie in the  request's cookie _csrf            if BConfig.WebConfig.EnableXSRF {                execController.XSRFToken()                if r.Method == "POST" || r.Method == "DELETE" || r.Method == "PUT" ||                    (r.Method == "POST" && (context.Input.Query("_method") == "DELETE" || context.Input.Query("_method") == "PUT")) {                    execController.CheckXSRFCookie()                }            }            execController.URLMapping()            //根据方法调用不同的处理函数            if !context.ResponseWriter.Started {                //exec main logic                switch runMethod {                case "GET":                    execController.Get()                case "POST":                    execController.Post()                case "DELETE":                    execController.Delete()                case "PUT":                    execController.Put()                case "HEAD":                    execController.Head()                case "PATCH":                    execController.Patch()                case "OPTIONS":                    execController.Options()                default:                    if !execController.HandlerFunc(runMethod) {                        var in []reflect.Value                        method := vc.MethodByName(runMethod)                        method.Call(in)                    }                }                //render template                if !context.ResponseWriter.Started && context.Output.Status == 0 {                    if BConfig.WebConfig.AutoRender {                        if err := execController.Render(); err != nil {                            panic(err)                        }                    }                }            }            // finish all runRouter. release resource            //处理完,进行资源的释放            execController.Finish()        }        //execute middleware filters        //执行对应的 Filters        if p.execFilter(context, AfterExec, urlPath) {            goto Admin        }    }    //在处理完请求后,执行对应的 Filters    p.execFilter(context, FinishRouter, urlPath)

可以看到中间有几个 if else用来判断注册的路由是什么类型
* 如果类型是 routerTypeRESTFul并且支持请求的方法,则执行 ControllerInfo的runFunction()方法,否则返回”405”
* 如果类型是 routerTypeHandler,则执行 Controller.handler的ServeHTTP()方法
* 其他类型的路由,则继续往下执行,注意有两行 “POST”方法的判断,但是 method又改为其他的方法,这是为了用同一个接口实现不同的请求,既将真实的请求放在参数 _method里面

下面的 if !isRunnable{…} 是当上面匹配到其他类型路由时而执行的流程
可以发现通过反射获得了当初注册路由时的 Controller结构体,并依次调用 ControllerInterface接口所定义的方法(这些方法正在在自定义 Controller时需要实现的方法)
整个 ServeHTTP()函数的最后调用了 AfterExec阶段和 FinishRouter阶段两个阶段的 Filter

在后面就是整个请求结束后的记录过程了,逻辑比较简单只贴上代码就好了~

/* * 记录此次请求的一些信息 */Admin:    timeDur := time.Since(startTime)    //admin module record QPS    if BConfig.Listen.EnableAdmin {        if FilterMonitorFunc(r.Method, r.URL.Path, timeDur) {            if runRouter != nil {                go toolbox.StatisticsMap.AddStatistics(r.Method, r.URL.Path, runRouter.Name(), timeDur)            } else {                go toolbox.StatisticsMap.AddStatistics(r.Method, r.URL.Path, "", timeDur)            }        }    }    if BConfig.RunMode == DEV || BConfig.Log.AccessLogs {        var devInfo string        if findRouter {            if routerInfo != nil {                devInfo = fmt.Sprintf("| % -10s | % -40s | % -16s | % -10s | % -40s |", r.Method, r.URL.Path, timeDur.String(), "match", routerInfo.pattern)            } else {                devInfo = fmt.Sprintf("| % -10s | % -40s | % -16s | % -10s |", r.Method, r.URL.Path, timeDur.String(), "match")            }        } else {            devInfo = fmt.Sprintf("| % -10s | % -40s | % -16s | % -10s |", r.Method, r.URL.Path, timeDur.String(), "notmatch")        }        if DefaultAccessLogFilter == nil || !DefaultAccessLogFilter.Filter(context) {            Debug(devInfo)        }    }    // Call WriteHeader if status code has been set changed    if context.Output.Status != 0 {        context.ResponseWriter.WriteHeader(context.Output.Status)    }}

一个HTTP请求的处理流程大概就是这个样子,先查找静态路由让后再查找用户定义的路由规则,调用相应规则的处理函数

如有错误,非常希望您能联系我并让我加以改进 :D