go-restful实战与深入分析之源码篇

下面开始介绍go restful源码分析，有了上一篇的铺垫这篇文章讲解起来就很简单了。和go 的http一样启动监听：

    wsContainer := restful.NewContainer()
    server := &http.Server{Addr: ":8080", Handler: wsContainer}

 
 
1
2
3

不用多说这个wsContainer肯定也是实现了Handler接口的。看代码：

func NewContainer() *Container {
    return &Container{
        webServices:            []*WebService{},
        ServeMux:               http.NewServeMux(),
        isRegisteredOnRoot:     false,
        containerFilters:       []FilterFunction{},
        doNotRecover:           true,
        recoverHandleFunc:      logStackOnRecover,
        serviceErrorHandleFunc: writeServiceError,
        router:                 CurlyRouter{},
        contentEncodingEnabled: false}
}

func (c *Container) ServeHTTP(httpwriter http.ResponseWriter, httpRequest *http.Request) {
    c.ServeMux.ServeHTTP(httpwriter, httpRequest)
}

上面有两个方式分别是定义container和实现Handler接口的的ServeHTTP（）方法。那么当服务请求过来后就可以调用这个方法了。这个方法又调用c.ServeMux.ServeHTTP，是不是回到上一篇了，对，就练到一起了。

func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
    if r.RequestURI == "*" {
        if r.ProtoAtLeast(1, 1) {
            w.Header().Set("Connection", "close")
        }
        w.WriteHeader(StatusBadRequest)
        return
    }
    h, _ := mux.Handler(r)
    h.ServeHTTP(w, r)
}

那么先看他是怎么注册和查找方法的呢？

    ws := new(restful.WebService)
    ws.
    Path("/users").
        Consumes(restful.MIME_XML, restful.MIME_JSON).
        Produces(restful.MIME_JSON, restful.MIME_XML) // you can specify this per route as well

    ws.Route(ws.GET("/{user-id}").To(u.findUser))
    ws.Route(ws.POST("").To(u.updateUser))
    ws.Route(ws.PUT("/{user-id}").To(u.createUser))
    ws.Route(ws.DELETE("/{user-id}").To(u.removeUser))

    container.Add(ws)

先看看Route方法，这里面记录所以路径和路径对应的方法，全部放到[]Route这个切片当中。

func (w *WebService) Route(builder *RouteBuilder) *WebService {
    w.routesLock.Lock()
    defer w.routesLock.Unlock()
    builder.copyDefaults(w.produces, w.consumes)
    w.routes = append(w.routes, builder.Build())
    return w
}

一个container里面多个webservice。可以通过Container的Add注册加入到webServices这个切片中。

func (c *Container) Add(service *WebService) *Container {
    c.webServicesLock.Lock()
    defer c.webServicesLock.Unlock()

    // if rootPath was not set then lazy initialize it
    if len(service.rootPath) == 0 {
        service.Path("/")
    }

    // cannot have duplicate root paths
    for _, each := range c.webServices {
        if each.RootPath() == service.RootPath() {
            log.Printf("[restful] WebService with duplicate root path detected:['%v']", each)
            os.Exit(1)
        }
    }

    // If not registered on root then add specific mapping
    if !c.isRegisteredOnRoot {
        c.isRegisteredOnRoot = c.addHandler(service, c.ServeMux)
    }
    c.webServices = append(c.webServices, service)
    return c
}

注册webservice的本质是注册各种handler看addHandler这个方法。

func (c *Container) addHandler(service *WebService, serveMux *http.ServeMux) bool {
    pattern := fixedPrefixPath(service.RootPath())
    // check if root path registration is needed
    if "/" == pattern || "" == pattern {
        serveMux.HandleFunc("/", c.dispatch)
        return true
    }
    // detect if registration already exists
    alreadyMapped := false
    for _, each := range c.webServices {
        if each.RootPath() == service.RootPath() {
            alreadyMapped = true
            break
        }
    }
    if !alreadyMapped {
        serveMux.HandleFunc(pattern, c.dispatch)
        if !strings.HasSuffix(pattern, "/") {
            serveMux.HandleFunc(pattern+"/", c.dispatch)
        }
    }
    return false
}

通过serveMux.HandleFunc注册，这也和上一篇的文章对应。不过这次注册的方法c.dispatch有点特别，具体看下面的方法，

func (c *Container) dispatch(httpWriter http.ResponseWriter, httpRequest *http.Request) {
    writer := httpWriter

    // CompressingResponseWriter should be closed after all operations are done
    defer func() {
        if compressWriter, ok := writer.(*CompressingResponseWriter); ok {
            compressWriter.Close()
        }
    }()

    // Instal panic recovery unless told otherwise
    if !c.doNotRecover { // catch all for 500 response
        defer func() {
            if r := recover(); r != nil {
                c.recoverHandleFunc(r, writer)
                return
            }
        }()
    }
    // Install closing the request body (if any)
    defer func() {
        if nil != httpRequest.Body {
            httpRequest.Body.Close()
        }
    }()

    // Detect if compression is needed
    // assume without compression, test for override
    if c.contentEncodingEnabled {
        doCompress, encoding := wantsCompressedResponse(httpRequest)
        if doCompress {
            var err error
            writer, err = NewCompressingResponseWriter(httpWriter, encoding)
            if err != nil {
                log.Print("[restful] unable to install compressor: ", err)
                httpWriter.WriteHeader(http.StatusInternalServerError)
                return
            }
        }
    }
    // Find best match Route ; err is non nil if no match was found
    var webService *WebService
    var route *Route
    var err error
    func() {
        c.webServicesLock.RLock()
        defer c.webServicesLock.RUnlock()
        webService, route, err = c.router.SelectRoute(
            c.webServices,
            httpRequest)
    }()
    if err != nil {
        // a non-200 response has already been written
        // run container filters anyway ; they should not touch the response...
        chain := FilterChain{Filters: c.containerFilters, Target: func(req *Request, resp *Response) {
            switch err.(type) {
            case ServiceError:
                ser := err.(ServiceError)
                c.serviceErrorHandleFunc(ser, req, resp)
            }
            // TODO
        }}
        chain.ProcessFilter(NewRequest(httpRequest), NewResponse(writer))
        return
    }
    wrappedRequest, wrappedResponse := route.wrapRequestResponse(writer, httpRequest)
    // pass through filters (if any)
    if len(c.containerFilters)+len(webService.filters)+len(route.Filters) > 0 {
        // compose filter chain
        allFilters := []FilterFunction{}
        allFilters = append(allFilters, c.containerFilters...)
        allFilters = append(allFilters, webService.filters...)
        allFilters = append(allFilters, route.Filters...)
        chain := FilterChain{Filters: allFilters, Target: func(req *Request, resp *Response) {
            // handle request by route after passing all filters
            route.Function(wrappedRequest, wrappedResponse)
        }}
        chain.ProcessFilter(wrappedRequest, wrappedResponse)
    } else {
        // no filters, handle request by route
        route.Function(wrappedRequest, wrappedResponse)
    }
}

这个里面方法里面通过SelectRoute选取对应的webservice和route，具体实现在：

func (c CurlyRouter) SelectRoute(
    webServices []*WebService,
    httpRequest *http.Request) (selectedService *WebService, selected *Route, err error) {

    requestTokens := tokenizePath(httpRequest.URL.Path)

    detectedService := c.detectWebService(requestTokens, webServices)
    if detectedService == nil {
        if trace {
            traceLogger.Printf("no WebService was found to match URL path:%s\n", httpRequest.URL.Path)
        }
        return nil, nil, NewError(http.StatusNotFound, "404: Page Not Found")
    }
    candidateRoutes := c.selectRoutes(detectedService, requestTokens)
    if len(candidateRoutes) == 0 {
        if trace {
            traceLogger.Printf("no Route in WebService with path %s was found to match URL path:%s\n", detectedService.rootPath, httpRequest.URL.Path)
        }
        return detectedService, nil, NewError(http.StatusNotFound, "404: Page Not Found")
    }
    selectedRoute, err := c.detectRoute(candidateRoutes, httpRequest)
    if selectedRoute == nil {
        return detectedService, nil, err
    }
    return detectedService, selectedRoute, nil
}

然后通过route.Function(wrappedRequest, wrappedResponse)调用具体的方法。