主要内容：控制器解析、handler注册。

调用方法：

func (app *Application) Handle(controller interface{}) *Application {
    c := newControllerActivator(app.Router, controller, app.Dependencies)
    if before, ok := controller.(interface {
        BeforeActivation(BeforeActivation)
    }); ok {
        before.BeforeActivation(c)
    }

    c.activate()

    if after, okAfter := controller.(interface {
        AfterActivation(AfterActivation)
    }); okAfter {
        after.AfterActivation(c)
    }
    return app
}

go语言接口查询检测自定义handler是否需要加载

对于JAVA，需要检测控制器。一旦继承了某个接口，就要实现其全部的接口方法，因而不需要检测，直接调用重写的方法。

对于JAVA，go语言的的作用域更加开放，所有的变量类型只区分包内可见，或是包外。用变量名的大小写实现。对于接口也是不需要显式指定实现是的哪些接口，可以直接实现接口方法。更加灵活地继承任何接口。这样淡化了接口设计，使类可以灵活实现各种接口。

由于自定义Handler需要重写BeforeActivation方法。用接口查询的方式，检测控制器实现了哪些接口，再调用方法。对应于JAVA显式指明implements哪些接口，调用用接口方法。

ControllerActivator结构体

控制器BeoreActivation传入的实例，是ControllerActivator{}对象。实现了BeforeActivation接口和AfterActivation接口。这些接口形式如下：

type shared interface {
    Name() string
    Router() router.Party
    GetRoute(methodName string) *router.Route
    Handle(httpMethod, path, funcName string, middleware ...context.Handler) *router.Route
}
type BeforeActivation interface {
    shared
    Dependencies() *di.Values
}
type AfterActivation interface {
    shared
    DependenciesReadOnly() ValuesReadOnly
    Singleton() bool
}

ControllerActivator数据结构如下：

type ControllerActivator struct {
    router router.Party

    fullName string

    routes map[string]*router.Route

    dependencies di.Values

    injector *di.StructInjector
}

router.Party接口。其实现类router.Router表示一组具有相同前缀和中间件的routes。router.Router是app（iris实例）的一个字段。最基本的功能：

• 调用Handle HandleMany方法注册路由。
• 调用Get/Post/Put/Delete/Head方法（根据不同的http请求类型）返回http请求Path对应的路由*Route。
• 调用Use方法注册中间件。
• 调用Done为路径下的所有路由，添加后处理handler。
• 其它的信息打印、生成子路由集合等。

所以router.Router就是iris的路由管理器。再用routes map[string]*router.Route保存一份此控制器的路由。fullName字段保存控制器名称，形式user/controller.g，则为user.Controller。以下3字段用来反射调用控制器：

Value reflect.Value
Type  reflect.Type
dependencies di.Values //di.Values是[]reflect.Value的别名

injector di.StructInjector字段，用于注入一个di.StructInjector实例。

ControllerActivator的构建

ControllerActivator的功能是反射获取控制器obj，构建路由并保存到router.Router。

ControllerActivator的构建，传入了app.Router app.Dependencies及控制器obj。其中router字段直接由app拿到。Type Value由控制器反射拿到。

dependencies字段包括了app本身的dependencies，以及controller中的字段。注意到参数并不是引用传递，而是深拷贝的。本例中controller没有字段。

routes的数据结构为map[string]*router.Route，key为控制器中的方法名称。本身会预加载BeforeActivation，AfterActivation两个方法，值为空，作为保留方法。本例中使用了用BeforeActivation来加载自定义的handler。如果实现了BaseController，还应将BeginRequest，EndRequest作为保留方法。后续的handleRequest()方法在解析控制器中的方法，将保存到路由时，会首先校验方法，是不是保留方法，如果是则直接返回，不进行后续的解析和构建、创建路由操作。

“手动”和“自动”化地调用Handle注册路由

由于iris使用了NamingGuide来写处理http请求的方法。不需要每次都写RequestMethod RequestMapping。标准化了这些方法的函数名，含义清晰。框架以“自动”化地方工处理这些函数。而时又支持手动添加自定义的Handle()。

Handle方法API如下：

Handle(httpMethod, path, funcName string, middleware ...context.Handler) *router.Route

只需要指明http请求方法、http请求路径、funcName、Handler。从funcName和controller实体，即可以反射调用对应的方法。handler的实现形式非常简单，只有一个传入参数ctx context，包括了请求信息、响应及其它上下文信息。

自定义的方法，会在BeforeActivation中直接调用Handle中注册路由。

而对于NamingGuide的常规方法，会调用反射遍历控制器中的所有方法。如上面所描述，先依据c.routes检查是否是保护函数名。有一个编程细节是，保留字判断方法c.isReservedMethod，使用了闭包传递。

反射获取m.Name之后调用解析方法：

(p *methodParser) parse() (method, path string, err error) 

其中methodParser：

type methodParser struct {
    lexer *methodLexer
    fn    reflect.Method
}

methodLexer是有状态的数组，由于go标准库，只有container/list的链表实现，没有ArrayList的实现，并且没有iterator。此数据结构完成相同的功能。

解析逻辑流

1、驼峰式转数组

首先将驼峰式转为字串数组，是一道算法题。标准库提供了判断字母大小写的方法unicode.IsUpper(c)

算法：

• 遇到大写，构成一个单词，存到res。
• 处理最后一组。

        end := len(s)
        start := -1

        for i, n := 0, end; i < n; i++ {
            c := rune(s[i])
            if unicode.IsUpper(c) {
                // it doesn't count the last uppercase
                if start != -1 {
                    end = i
                    words = append(words, s[start:end])
                }
                start = i
                continue
            }
            end = i + 1
        }

        if end > 0 && len(s) >= end {
            words = append(words, s[start:end])
        }

2、校验HTTP请求是否合法

从app.router.AllMethod拿字段，列出了合法的HTTP请求，

AllMethods = [...]string{
        "GET",
        "POST",
        "PUT",
        "DELETE",
        "CONNECT",
        "HEAD",
        "PATCH",
        "OPTIONS",
        "TRACE",
    }

并补入了框架自定义的"ALL", "ANY"也是合法的。

3、是否使用了By

功能相当于spring中的RequestParam。即加入了By关键字，框架会从反射方法m *Method中拿输入的形参作为RequestParam。解析http请求方法和路径都不需要*Method，而methodParser写入了*Method字段就是为了解析输入参数之用。调用如下方法解析参数。

(p *methodParser) parsePathParam(path string, w string, funcArgPos int) (string, int, error) 

parse逻辑：

对于通配符Wildcard跳过处理。

从ParamType常中检查请求参数名的类型是否合法。支持如下类型。

func LookupParamTypeFromStd(goType string) ParamType {
    switch goType {
    case "string":
        return ParamTypeString
    case "int":
        return ParamTypeInt
    case "int64":
        return ParamTypeLong
    case "bool":
        return ParamTypeBoolean
    default:
        return ParamTypeUnExpected
    }

把参数追加到路径中，形式/{%s:%s}。

4、解析路径

strings.ToLower(w)转为小写。

如此NamingGuide提供了RequestMapping RequestParam RequestMethod的功能。PathVariable功能，直接在path中用{}，需要自定义控制器方法。

最后仍和BeforeActivation中"手动"调用Handle()一样，调用：

c.Handle(httpMethod, httpPath, m.Name)

路由注册逻辑Handle

Handle的逻辑功能如下：

• 检测上文提到的保留方法。
• 解析路径中的参数名称及类型，实现类似@PathVariable的功能。
• 参数构建
• handler构建
• 注册路由到router.Router

先从c.routes拿已注册路由的方法名，调用c.isReservedMethod(funcName)检测已注册路由。使用了保留字段的检测方法，但功能上还是会检测已注册方法名的。

方法调用用的参数由三部分组成：app.dependencies、controller字段和path路径解析参数。前两个部分的整合已经在构建ControllerActivator时完成，为深复制。这两部分参数的特点是注册时就能确定的参数，而后面的两部分PathVaraible RequestParam是运要运行时才能确定的参数。前文已经提到RequestParam的参数名称和类型（还未获得值）已经以/{%s:%s}的形式解析进path。所以处理path中/{%s:%s}形式的字段，将同时完成从@PathVariable @RequestParam获得参数字段名，存入[]reflect.Value参数表。

由于@PathVariable @RequestParam的值需要在接到http请求之后才能获得。并且未必提供完整的@RequestParam，mvc框架中已添加是否获得符合/{%s:%s}参数要求的校验。在server服务期间，接受到http请求，请求path将通过已注册路由，找到（w,*r）的handlers序列合集，具体逻辑流后面详述。三类参数组合后，交由c.handlerOf()方法创建handler。

上文提到自定义调用Handle方法可以注册两个handler，一个是从Handle()方法传入，一个就是路径对应的控制器方法。mvc规定传入的handler优先执行。

最后注册路由，同时注册到ControllerActivator实例的c.routes用来检测重复注册。Handle逻辑的任务简要：参数获取、handler构建、route构建。

handler构建逻辑

调用handleOf()构建逻辑。ControllerActivator实例会保存一个c.injector字段。每次调用handlerOf，就会将c.injector绑定为当前值。分别将ControllerActivator注册为c.injector，方法注册为funcInjector。

需要说明的是，以上所有的逻辑，对path的解析还只是一个模板，没有填充实际的参数。这里用了闭包和反射的结合使用，注册将来才会调用的handler易于编程，结构清晰。handler的注册只是注册了一个闭包，而在接受请求、处理请求才调用handler时，才执行handler闭包，反射调用获取运行时字段信息。

给出两个injector的数据结构：

StructInjector struct {
                initRef        reflect.Value
                elemType       reflect.Type
                fields []*targetStructField
                Has       bool
                Scope     Scope
}
FuncInjector struct {
                fn       reflect.Value
                typ      reflect.Type
                goodFunc TypeChecker

                inputs []*targetFuncInput
                Length int
                Has bool
}

其中initRef、initRefAsSlice、elemType是同一个信息，区别仅是反射值、反射值切片、反射指针的指向元素。fields用于保存ControllerActivator中的字段。field数据结构：

type field struct {
    Type   reflect.Type
    Name   string 
    Index  []int 
    CanSet bool  
    AnyValue reflect.Value
}

这两个struct的构建过程，完成了http请求参数，向这两个实体的注入。完成第一步的注值之后，第二步进行检查，是否是BaseController，是否注入的控制器字段，是否注入了方式的输入参数。第三步根据不同的情况执行反射调用call([]reflect.Value)。最后一步hero.DispatchFuncResult，将响应相关的http信息写入到ctx。

如果有ControllerActivator的绑定字段，则由ctx注值到c.injector.Acquire().Elem()。情况1:对于BaseController的情况，直接调用BeginRequest，EndRequest后返回。情况2如果方法有形参，则由funcInjector注值。

反射调用结果分发回context

反射调用将获得reflect.Value类型的结果。调用hero.DispatchFuncResult分发结果。先用switch轮循[]reflect.Value处理statusCode、content type、content、其它cuntom类型。

分两种情况，如果反射调用的返回结果是字串，调用ctx.Write(content)。如果是Result类型，调用Dispatch()写入结果。其它情况：contentType为application/javascrip text/xml application/json的情况。

type Result interface {
    Dispatch(ctx context.Context)
}

以上所有无论何种情况最终调用net/http标准库方法，向ctx.Write([]byte)向ResponseWriter写入结果。

ControllerActivator与app实例

最后总结一下路由注册类ControllerActivator与主实例app的关联。在调用Handle()传入了app.Router app.dependencies两个字段。app.dependencies字段指明了从http请求中需要拿参数的类型，在反射调用之前执行。

c.router字段的功能是：

• 提供c.router.Macros()提供http请求路径解析的Macros。
• 调用c.router.Handle注册已经构建的handler。这也是整个逻辑流的最终目的，注册一个传入ctx的闭包到路由。