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

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

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

不用多说这个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,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:%sn",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:%sn",detectedService.rootPath,httpRequest.URL.Path)
        }
        return detectedService,"404: Page Not Found")
    }
    selectedRoute,err := c.detectRoute(candidateRoutes,httpRequest)
    if selectedRoute == nil {
        return detectedService,err
    }
    return detectedService,selectedRoute,nil
}

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