RouterGroup、Handlers、goroutine并发
// 运行在debug模式
()
{
switch value {
case DebugMode, "":
ginMode = debugCode
case ReleaseMode:
ginMode = releaseCode
case TestMode:
ginMode = testCode
default:
panic("gin mode unknown: " + value)
}
if value == "" {
value = DebugMode
}
modeName = value
}
// 创建路由，没有任何中间件 Creates a router without any middleware by default
var engine *Engine = ()
{
debugPrintWARNINGNew()
{
debugPrint(`[WARNING] Running in "debug" mode. Switch to "release" mode in production.
- using env: export GIN_MODE=release
- using code: ()
`)
}
engine := &{
//type RouterGroup struct {
// Handlers HandlersChain
// basePath string
// engine *Engine // 对engine的依赖
// root bool
//}
// 创建 RouterGroup
RouterGroup: RouterGroup{
Handlers: nil, // 处理器链
basePath: "/",
root: true, // 是根路由
},
// 模版函数
FuncMap: {},
RedirectTrailingSlash: true,
RedirectFixedPath: false,
HandleMethodNotAllowed: false,
ForwardedByClientIP: true,
AppEngine: defaultAppEngine,
UseRawPath: false,
UnescapePathValues: true,
MaxMultipartMemory: defaultMultipartMemory, // 最大Multipart内存数 defaultMultipartMemory = 32 << 20
//type methodTree struct {
// method string
// root *node
//}
//type methodTrees []methodTree
trees: make(methodTrees, 0, 9),
// 渲染引擎分割符
delims: {Left: "{{", Right: "}}"},
secureJsonPrefix: "while(1);",
}
= engine // 对engine的引用
= func() interface{} { // 创建
return ()
}
return engine
}
// 文件上传最大的空间
// Set a lower memory limit for multipart forms (default is 32 MiB)
= int64(3) << 20 // 3 MiB 上传的图片最大允许的大小，3MB
// 中间件 设置到默认的 ，没有路由
{
// 全局中间件，日志记录器， Global middleware
// Logger middleware will write the logs to even if you set with GIN_MODE=release.
// By default =
(())
{
(middleware...)
{
// group === RouterGroup
// append 中间件
= append(, middleware...)
// group === RouterGroup
return ()
{
if {
return
}
return group
}
}
engine.rebuild404Handlers()
{
= ()
}
engine.rebuild405Handlers()
{
= ()
}
return engine
}
// 中间件，错误处理。Recovery middleware recovers from any panics and writes a 500 if there was one.
(())
// 中间件 - api统计
(())
}
// 路由
{
//路由写法：
// 1、必须以“/”开头
// 2、路由中要参数，只要参数前有“*”或“:”即可
//"/module0/ctrl0/action0/:param0/:param1/*"
frontApi := ("/api", ) // 创建一个新的 RouterGroup，并设置一个名为“”的handler
{
// 创建新的RouterGroup
return &{
// 把根 group 的 handlers 拷贝出来，并进行合并
Handlers: (handlers){
finalSize := len() + len(handlers)
if finalSize >= int(abortIndex) {
panic("too many handlers")
}
mergedHandlers := make(HandlersChain, finalSize)
copy(mergedHandlers, )
copy(mergedHandlers[len():], handlers)
return mergedHandlers
}, // handlers ===
// 添加相对路径
basePath: (relativePath), // relativePath === "/api"
{
// return "/api"
return joinPaths(, relativePath)
}
// 对engine的引用
engine: ,
}
}
// 添加路由
("/siteinfo", ) // 访问地址为 “/api/siteinfo” 等价 ("GET","/api/siteinfo", common.SiteInfo0, common.SiteInfo1)
{
return ("GET", relativePath, handlers)
{
absolutePath := (relativePath)
{
//return "/api/siteinfo"
return joinPaths(, relativePath)
}
// 把上级 group 的 handlers 拷贝出来，并进行合并
handlers = (handlers)
{
finalSize := len() + len(handlers)
if finalSize >= int(abortIndex) {
panic("too many handlers")
}
mergedHandlers := make(HandlersChain, finalSize)
copy(mergedHandlers, )
copy(mergedHandlers[len():], handlers)
return mergedHandlers
}
(httpMethod, absolutePath, handlers)
{
// httpMethod === "GET"
// absolutePath === "/api/siteinfo"
// handlers === 处理器列表
assert1(path[0] == '/', "path must begin with '/'")
assert1(method != "", "HTTP method can not be empty")
assert1(len(handlers) > 0, "there must be at least one handler")
debugPrintRoute(method, path, handlers)
{
if IsDebugging() {
nuHandlers := len(handlers)
handlerName := nameOfFunction(())
debugPrint("%-6s %-25s --> %s (%d handlers)\n", httpMethod, absolutePath, handlerName, nuHandlers)
}
}
// 按请求方式method归类
root := (method)
if root == nil {
//type node struct {
// path string
// indices string
// children []*node
// handlers HandlersChain
// priority uint32
// nType nodeType
// maxParams uint8
// wildChild bool
//}
//type methodTree struct {
// method string
// root *node
//}
root = new(node)
= append(, methodTree{method: method, root: root})
}
// 添加路由 root === node（type node struct）
(path, handlers)
{
fullPath := path
++
// 计算"参数"数量
numParams := countParams(path)
{
var n uint
for i := 0; i < len(path); i++ {
if path[i] != ':' && path[i] != '*' {
continue
}
n++
}
if n >= 255 {
return 255
}
return uint8(n)
}
// non-empty tree
if len() > 0 || len() > 0 { // ！！！！！不是空树！！！！！
walk:
for {
// Update maxParams of the current node
if numParams > {
= numParams
}
// Find the longest common prefix.
// This also implies that the common prefix contains no ':' or '*'
// since the existing key can't contain those chars.
i := 0
max := min(len(path), len())
for i < max && path[i] == [i] {
i++
}
// Split edge
if i < len() { // "新地址"比"已有的地址"短，那么提升为父级节点
child := node{
path: [i:],
wildChild: ,
indices: ,
children: ,
handlers: ,
priority: - 1,
}
// Update maxParams (max of all children)
for i := range {
if [i].maxParams > {
= [i].maxParams
}
}
= []*node{&child}
// []byte for proper unicode char conversion, see #65
= string([]byte{[i]})
= path[:i]
= nil
= false
}
// Make new node a child of this node
if i < len(path) { // 作为子节点加入
path = path[i:]
if {
n = [0]
++
// Update maxParams of the child node
if numParams > {
= numParams
}
numParams--
// Check if the wildcard matches
if len(path) >= len() && == path[:len()] {
// check for longer wildcard, . :name and :names
if len() >= len(path) || path[len()] == '/' {
continue walk
}
}
panic("path segment '" + path +
"' conflicts with existing wildcard '" + +
"' in path '" + fullPath + "'")
}
c := path[0]
// slash after param
if == param && c == '/' && len() == 1 {
n = [0]
++
continue walk
}
// Check if a child with the next path byte exists
for i := 0; i < len(); i++ {
if c == [i] {
i = (i)
n = [i]
continue walk
}
}
// Otherwise insert it
if c != ':' && c != '*' {
// []byte for proper unicode char conversion, see #65
+= string([]byte{c})
child := &node{
maxParams: numParams,
}
= append(, child)
(len() - 1)
n = child
}
(numParams, path, fullPath, handlers)
{
// 作为子节点加入 ...
}
return
} else if i == len(path) { // Make node a (in-path) leaf
if != nil {
panic("handlers are already registered for path ''" + fullPath + "'")
}
= handlers
}
return
}
} else { // Empty tree ！！！！！空树！！！！！
// numParams === 地址参数数量
// path === "/api/siteinfo"
// fullPath === "/api/siteinfo"
// handlers === 处理器列表
(numParams, path, fullPath, handlers)
{
var offset int // already handled bytes of the path
// numParams === 地址参数数量
// find prefix until first wildcard (beginning with ':'' or '*'')
for i, max := 0, len(path); numParams > 0; i++ {
c := path[i]
if c != ':' && c != '*' {
continue
}
// find wildcard end (either '/' or path end)
end := i + 1
for end < max && path[end] != '/' {
switch path[end] {
// the wildcard name must not contain ':' and '*'
case ':', '*':
panic("only one wildcard per path segment is allowed, has: '" +
path[i:] + "' in path '" + fullPath + "'")
default:
end++
}
}
// check if this Node existing children which would be
// unreachable if we insert the wildcard here
if len() > 0 {
panic("wildcard route '" + path[i:end] +
"' conflicts with existing children in path '" + fullPath + "'")
}
// check if the wildcard has a name
if end-i < 2 {
panic("wildcards must be named with a non-empty name in path '" + fullPath + "'")
}
if c == ':' { // param
// split path at the beginning of the wildcard
if i > 0 {
= path[offset:i]
offset = i
}
child := &node{
nType: param,
maxParams: numParams,
}
= []*node{child}
= true
n = child
++
numParams--
// if the path doesn't end with the wildcard, then there
// will be another non-wildcard subpath starting with '/'
if end < max {
= path[offset:end]
offset = end
child := &node{
maxParams: numParams,
priority: 1,
}
= []*node{child}
n = child
}
} else { // catchAll
if end != max || numParams > 1 {
panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'")
}
if len() > 0 && [len()-1] == '/' {
panic("catch-all conflicts with existing handle for the path segment root in path '" + fullPath + "'")
}
// currently fixed width 1 for '/'
i--
if path[i] != '/' {
panic("no / before catch-all in path '" + fullPath + "'")
}
= path[offset:i]
// first node: catchAll node with empty path
child := &node{
wildChild: true,
nType: catchAll,
maxParams: 1,
}
= []*node{child}
= string(path[i])
n = child
++
// second node: node holding the variable
child = &node{
path: path[i:],
nType: catchAll,
maxParams: 1,
handlers: handlers,
priority: 1,
}
= []*node{child}
return
}
}
// insert remaining path part and handle to the leaf
= path[offset:]
= handlers
}
= root // node 类型为根 path
}
}
}
return ()
{
if {
return
}
return group
}
}
}
("/action0", )
adminAPI := ("/api/admin", , )
("/ctrl0/action0", )
("/action1", )
}
// 运行
(":8080")
{
defer func() { debugPrintError(err){
if err != nil {
debugPrint("[ERROR] %v\n", err)
{
if IsDebugging() {
("[GIN-debug] "+format, values...)
}
}
}
} }()
address := resolveAddress(addr)
{
switch len(addr) {
case 0: // 没有配置监听地址
if port := ("PORT"); port != "" {
debugPrint("Environment variable PORT=\"%s\"", port)
return ":" + port
}
debugPrint("Environment variable PORT is undefined. Using port :8080 by default")
return ":8080"
case 1: // 有配置监听地址
return addr[0]
default:
panic("too much parameters")
}
}
debugPrint("Listening and serving HTTP on %s\n", address)
// 使用 go 核心的 http 库，(....) 作为处理器
err = (address, engine)
{
// address === ":8080"
// handler === (....)
server := &Server{Addr: addr, Handler: handler}
return ()
{
// addr === ":8080"
addr :=
if addr == "" {
addr = ":http"
}
ln, err := ("tcp", addr)
{
// func Listen(network, address string) (Listener, error)
addrs, err := ((), "listen", network, address, nil)
if err != nil {
return nil, &OpError{Op: "listen", Net: network, Source: nil, Addr: nil, Err: err}
}
var l Listener
switch la := (isIPv4).(type) {
case *TCPAddr:
l, err = ListenTCP(network, la) // Tcp 类型的监听
case *UnixAddr:
l, err = ListenUnix(network, la) // Unix 类型的监听
default:
return nil, &OpError{Op: "listen", Net: network, Source: nil, Addr: la, Err: &AddrError{Err: "unexpected address type", Addr: address}}
}
if err != nil {
return nil, err // l is non-nil interface containing nil pointer
}
return l, nil
}
if err != nil {
return err
}
return (tcpKeepAliveListener{ln.(*)}) // func (srv *Server) Serve(l )
{
//type tcpKeepAliveListener struct {
// *
//}
defer ()
if fn := testHookServerServe; fn != nil {
fn(srv, l)
}
var tempDelay // how long to sleep on accept failure
if err := srv.setupHTTP2_Serve(){
(srv.onceSetNextProtoDefaults_Serve)
return
}; err != nil {
return err
}
(l, true)
{
()
defer ()
if == nil {
= make(map[]struct{})
}
if add {
// If the *Server is being reused after a previous
// Close or Shutdown, reset its doneChan:
if len() == 0 && len() == 0 {
= nil
}
[ln] = struct{}{}
} else {
delete(, ln)
}
}
defer (l, false)
baseCtx := () // base is always background, per Issue 16220
ctx := (baseCtx, ServerContextKey, srv)
for {
// 接受连接
rw, e := ()
{
return func (ln tcpKeepAliveListener) Accept() (, error) {
tc, err := ()
if err != nil {
return nil, err
}
(true)
(3 * )
return tc, nil
}
}
if e != nil {
select {
case <-():
return ErrServerClosed
default:
}
if ne, ok := e.(); ok && () {
if tempDelay == 0 {
tempDelay = 5 *
} else {
tempDelay *= 2
}
if max := 1 * ; tempDelay > max {
tempDelay = max
}
("http: Accept error: %v; retrying in %v", e, tempDelay)
(tempDelay)
continue
}
return e
}
tempDelay = 0
c := (rw) // 创建连接
{
c := &conn{ // ！！！！！！创建连接 ！！！！！！
server: srv, // ------------------------------------ 对Server的引用
rwc: rwc, // 客户端连接
}
if debugServerConnections {
= newLoggingConn("server", )
}
return c
}
(, StateNew) // before Serve can return
{
srv :=
switch state {
case StateNew:
(c, true)
case StateHijacked, StateClosed:
(c, false)
}
(connStateInterface[state])
if hook := ; hook != nil {
hook(nc, state)
}
}
go (ctx) // ------------------------------------------- 创建例程，在此支持高并发
{
// func (c *conn) serve(ctx )
= ().String() // 客户端地址
ctx = (ctx, LocalAddrContextKey, ())
defer func() {
if err := recover(); err != nil && err != ErrAbortHandler {
const size = 64 << 10
buf := make([]byte, size)
buf = buf[:(buf, false)]
("http: panic serving %v: %v\n%s", , err, buf)
}
if !() {
()
(, StateClosed)
}
}()
if tlsConn, ok := .(*); ok { // c === &conn{ server: srv === Server, rwc: rwc === 客户端连接 , }
if d := ; d != 0 { // === Server
(().Add(d))
}
if d := ; d != 0 {
(().Add(d))
}
if err := (); err != nil {
("http: TLS handshake error from %s: %v", (), err)
return
}
= new()
* = ()
if proto := ; validNPN(proto) {
if fn := [proto]; fn != nil {
h := initNPNRequest{tlsConn, serverHandler{}}
fn(, tlsConn, h)
}
return
}
}
// HTTP/ from here on.
ctx, cancelCtx := (ctx)
= cancelCtx
defer cancelCtx()
// !!!!!! c === &conn{ server: srv === Server , rwc: rwc === 客户端连接 , }
= &connReader{conn: c} // !!!!!! Reader
= newBufioReader() // !!!!!! Reader
= newBufioWriterSize(checkConnErrorWriter{c}, 4<<10) // !!!!!! Writer
for {
w, err := (ctx)
{
if () {
return nil, ErrHijacked
}
var (
wholeReqDeadline // or zero if none
hdrDeadline // or zero if none
)
t0 := ()
if d := (); d != 0 {
hdrDeadline = (d)
}
if d := ; d != 0 {
wholeReqDeadline = (d)
}
(hdrDeadline)
if d := ; d != 0 {
defer func() {
(().Add(d))
}()
}
(())
if == "POST" {
// RFC 2616 section 4.1 tolerance for old buggy clients.
peek, _ := (4) // ReadRequest will get err below
(numLeadingCRorLF(peek))
}
// 创建 Request 对象
req, err := readRequest(, keepHostHeader)
{
tp := newTextprotoReader(b)
req = new(Request) // ---------------------------- 创建 Request 对象
// First line: GET / HTTP/1.0
var s string
if s, err = (); err != nil {
return nil, err
}
defer func() {
putTextprotoReader(tp)
if err == {
err =
}
}()
var ok bool
, , , ok = parseRequestLine(s)
if !ok {
return nil, &badStringError{"malformed HTTP request", s}
}
if !validMethod() { // 是否是支持的方法
return nil, &badStringError{"invalid method", }
}
rawurl := // 请求地址
if , , ok = ParseHTTPVersion(); !ok {
return nil, &badStringError{"malformed HTTP version", }
}
// CONNECT requests are used two different ways, and neither uses a full URL:
// The standard use is to tunnel HTTPS through an HTTP proxy.
// It looks like "CONNECT :443 HTTP/1.1", and the parameter is
// just the authority section of a URL. This information should go in .
//
// The net/rpc package also uses CONNECT, but there the parameter is a path
// that starts with a slash. It can be parsed with the regular URL parser,
// and the path will end up in , where it needs to be in order for
// RPC to work.
justAuthority := == "CONNECT" && !(rawurl, "/")
if justAuthority {
rawurl = "http://" + rawurl
}
if , err = (rawurl); err != nil { // 解析成功 对象
return nil, err
}
if justAuthority {
// Strip the bogus "http://" back off.
= ""
}
// Subsequent lines: Key: value.
// 读取 MIME 头
mimeHeader, err := ()
if err != nil {
return nil, err
}
// 请求头
= Header(mimeHeader)
// 请求主机
// RFC 2616: Must treat
// GET / HTTP/1.1
// Host:
// and
// GET / HTTP/1.1
// Host: doesntmatter
// the same. In the second case, any Host line is ignored.
=
if == "" {
= ("Host") // 获取 Host 信息
}
if deleteHostHeader {
delete(, "Host")
}
fixPragmaCacheControl()
= shouldClose(, , , false)
err = readTransfer(req, b)
if err != nil {
return nil, err
}
if req.isH2Upgrade() {
// Because it's neither chunked, nor declared:
= -1
// We want to give handlers a chance to hijack the
// connection, but we need to prevent the Server from
// dealing with the connection further if it's not
// hijacked. Set Close to ensure that:
= true
}
return req, nil
}
if err != nil {
if () {
return nil, errTooLarge
}
return nil, err
}
if !http1ServerSupportsRequest(req) {
return nil, badRequestError("unsupported protocol version")
}
= // 请求方法
()
hosts, haveHost := ["Host"] // 请求头的 Host
isH2Upgrade := req.isH2Upgrade()
if (1, 1) && (!haveHost || len(hosts) == 0) && !isH2Upgrade && != "CONNECT" {
return nil, badRequestError("missing required Host header")
}
if len(hosts) > 1 {
return nil, badRequestError("too many Host headers")
}
if len(hosts) == 1 && !(hosts[0]) {
return nil, badRequestError("malformed Host header")
}
for k, vv := range {
if !(k) {
return nil, badRequestError("invalid header name")
}
for _, v := range vv {
if !(v) {
return nil, badRequestError("invalid header value")
}
}
}
delete(, "Host") // 删除请求头的 Host
ctx, cancelCtx := (ctx)
= ctx
= // 远程
=
if body, ok := .(*body); ok {
= true
}
// Adjust the read deadline if necessary.
if !(wholeReqDeadline) {
(wholeReqDeadline)
}
w = &response{ // ---------------------------- 创建 response 对象
// !!!!!! c === &conn{ server: srv === Server , rwc: rwc === 客户端连接 , }
conn: c,
cancelCtx: cancelCtx,
req: req, // Request 对象
reqBody: , // Request的Body对象
handlerHeader: make(Header),
contentLength: -1,
closeNotifyCh: make(chan bool, 1),
// We populate these ahead of time so we're not
// reading from after their Handler starts
// and maybe mutates it (Issue 14940)
wants10KeepAlive: req.wantsHttp10KeepAlive(),
wantsClose: (),
}
if isH2Upgrade {
= true
}
= w // 对response的引用
= newBufioWriterSize(&, bufferBeforeChunkingSize)
return w, nil
}
if != () {
// If we read any bytes off the wire, we're active.
(, StateActive)
}
if err != nil {
const errorHeaders = "\r\nContent-Type: text/plain; charset=utf-8\r\nConnection: close\r\n\r\n"
if err == errTooLarge {
// Their HTTP client may or may not be
// able to read this if we're
// responding to them and hanging up
// while they're still writing their
// request. Undefined behavior.
const publicErr = "431 Request Header Fields Too Large"
(, "HTTP/1.1 "+publicErr+errorHeaders+publicErr)
()
return
}
if isCommonNetReadError(err) {
return // don't reply
}
publicErr := "400 Bad Request"
if v, ok := err.(badRequestError); ok {
publicErr = publicErr + ": " + string(v)
}
(, "HTTP/1.1 "+publicErr+errorHeaders+publicErr)
return
}
// Expect 100 Continue support
req := // Request 对象
if () {
if (1, 1) && != 0 {
// Wrap the Body reader with one that replies on the connection
= &expectContinueReader{readCloser: , resp: w}
}
} else if ("Expect") != "" {
()
return
}
(w)
if requestBodyRemains() {
registerOnHitEOF(, )
} else {
if () > 0 {
()
}
()
}
// HTTP cannot have multiple simultaneous active requests.[*]
// Until the server replies to this request, it can't read another,
// so we might as well run the handler in this goroutine.
// [*] Not strictly true: HTTP pipelining. We could let them all process
// in parallel even if their responses need to be serialized.
// But we're not going to implement HTTP pipelining because it
// was never deployed in the wild and the answer is HTTP/2.
//type serverHandler struct {
// srv *Server
//}
// ！！！创建 serverHandler 对象，并调用 ServeHTTP(w, ) 方法 ！！！
// w === response 对象
// === Request 对象
serverHandler{}.ServeHTTP(w, )
{
//func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
// handler === engine
handler :=
if handler == nil {
handler = DefaultServeMux
}
if == "*" && == "OPTIONS" {
handler = globalOptionsHandler{}
}
// handler === engine
(rw, req)
{
//func (engine *Engine) ServeHTTP(w , req *) {
// !!! --------------- 创建上下文 --------------
c := ().(*Context) // === ()
{
//type Context struct {
// writermem responseWriter
// Request * // Request 对象
// Writer ResponseWriter
//
// Params Params
// handlers HandlersChain
// index int8
//
// engine *Engine
//
// // Keys is a key/value pair exclusively for the context of each request.
// Keys map[string]interface{}
//
// // Errors is a list of errors attached to all the handlers/middlewares who used this context.
// Errors errorMsgs
//
// // Accepted defines a list of manually accepted formats for content negotiation.
// Accepted []string
//}
return &Context{engine: engine}
}
(w)
{
// ===
//func (w *responseWriter) reset(writer ) {
= writer // !!!!!! response 对象
= noWritten
= defaultStatus
//}
}
= req // !!!!!! Request 对象
()
{
= & // responseWriter 对象
= [0:0]
= nil
= -1
= nil
= [0:0]
= nil
}
(c)
{
// c ==== Context 上下文
//func (engine *Engine) handleHTTPRequest(c *Context) {
httpMethod :=
path := // 如： "/dir0/dir1"
unescape := false
if && len() > 0 { // 使用 RawPath 路径
path =
unescape =
}
// Find root of the tree for the given HTTP method
t :=
for i, tl := 0, len(t); i < tl; i++ {
if t[i].method == httpMethod { // 判断请求方式，如："POST"
root := t[i].root
// Find route in tree ！！！ ---------------------------------------------- 查找路由
handlers, params, tsr := (path, , unescape)
{
// func (n *node) getValue(path string, po Params, unescape bool) (handlers HandlersChain, p Params, tsr bool) {
p = po
walk: // Outer loop for walking the tree
for {
if len(path) > len() { // "请求地址的长度"大于"路由地址长度"
if path[:len()] == { // 前缀匹配
path = path[len():]
// If this node does not have a wildcard (param or catchAll)
// child, we can just look up the next child node and continue
// to walk down the tree
if ! {
c := path[0]
for i := 0; i < len(); i++ {
if c == [i] {
n = [i]
continue walk
}
}
// Nothing found.
// We can recommend to redirect to the same URL without a
// trailing slash if a leaf exists for that path.
tsr = path == "/" && != nil
return
}
// handle wildcard child
n = [0]
switch {
case param:
// find param end (either '/' or path end)
end := 0
for end < len(path) && path[end] != '/' {
end++
}
// save param value
if cap(p) < int() {
p = make(Params, 0, )
}
i := len(p)
p = p[:i+1] // expand slice within preallocated capacity
p[i].Key = [1:]
val := path[:end]
if unescape {
var err error
if p[i].Value, err = (val); err != nil {
p[i].Value = val // fallback, in case of error
}
} else {
p[i].Value = val
}
// we need to go deeper!
if end < len(path) {
if len() > 0 {
path = path[end:]
n = [0]
continue walk
}
// ... but we can't
tsr = len(path) == end+1
return
}
if handlers = ; handlers != nil {
return
}
if len() == 1 {
// No handle found. Check if a handle for this path + a
// trailing slash exists for TSR recommendation
n = [0]
tsr = == "/" && != nil
}
return
case catchAll:
// save param value
if cap(p) < int() {
p = make(Params, 0, )
}
i := len(p)
p = p[:i+1] // expand slice within preallocated capacity
p[i].Key = [2:]
if unescape {
var err error
if p[i].Value, err = (path); err != nil {
p[i].Value = path // fallback, in case of error
}
} else {
p[i].Value = path
}
handlers =
return
default:
panic("invalid node type")
}
}
} else if path == { // ！！！！地址完全匹配 ！！！！
// We should have reached the node containing the handle.
// Check if this node has a handle registered.
if handlers = ; handlers != nil {
return
}
if path == "/" && && != root {
tsr = true
return
}
// No handle found. Check if a handle for this path + a
// trailing slash exists for trailing slash recommendation
for i := 0; i < len(); i++ {
if [i] == '/' {
n = [i]
tsr = (len() == 1 && != nil) ||
( == catchAll && [0].handlers != nil)
return
}
}
return
}
// Nothing found. We can recommend to redirect to the same URL with an
// extra trailing slash if a leaf exists for that path
tsr = (path == "/") ||
(len() == len(path)+1 && [len(path)] == '/' &&
path == [:len()-1] && != nil)
return
}
// }
}
if handlers != nil {
= handlers // 处理器
= params
() // !!!! -------------- 执行处理器链条
{
//func (c *Context) Next() {
++
for s := int8(len()); < s; ++ {
[](c) // !!!! --------------- 执行处理器
}
//}
}
// 写 http 响应头
()
{
// w === responseWriter
if !() {
= 0
// === response 对象
()
}
}
return
}
if httpMethod != "CONNECT" && path != "/" {
if tsr && {
redirectTrailingSlash(c)
return
}
if && redirectFixedPath(c, root, ) {
return
}
}
break
}
}
if { // 被禁止的方法
for _, tree := range {
if != httpMethod { // 查找"请求方法不匹配，但是路由匹配"的handler
if handlers, _, _ := (path, nil, unescape); handlers != nil {
=
// default405Body = []byte("405 method not allowed")
serveError(c, 405, default405Body)
return
}
}
}
}
= // 找不到路由
// default404Body = []byte("404 page not found")
serveError(c, 404, default404Body)
{
//var mimePlain = []string{MIMEPlain}
//func serveError(c *Context, code int, defaultMessage []byte) {
= code
() // !!!! -------------- 执行处理器链条
if !() {
if () == code {
()["Content-Type"] = mimePlain
(defaultMessage)
} else {
()
}
}
// }
}
//}
}
// 放入上下文
(c)
//}
}
//}
}
()
if () {
return
}
()
if !() {
if || () {
()
}
return
}
(, StateIdle)
((*response)(nil))
if !() {
// We're in shutdown mode. We might've replied
// to the user without "Connection: close" and
// they might think they can send another
// request, but such is life with HTTP/1.1.
return
}
if d := (); d != 0 {
(().Add(d))
if _, err := (4); err != nil {
return
}
}
({})
}
}
}
}
}
}
return
}