浅谈go-restful框架的使用和实现
REST（RepresentationalStateTransfer，表现层状态转化）是近几年使用较广泛的分布式结点间同步通信的实现方式。REST原则描述网络中client-server的一种交互形式，即用URL定位资源，用HTTP方法描述操作的交互形式。如果CS之间交互的网络接口满足REST风格，则称为RESTfulAPI。以下是理解RESTful架构总结的REST原则：
- 网络上的资源通过URI统一标示。
- 客户端和服务器之间传递，这种资源的某种表现层。表现层可以是json，文本，二进制或者图片等。
- 客户端通过HTTP的四个动词，对服务端资源进行操作，实现表现层状态转化。
为什么要设计RESTful的API，个人理解原因在于：用HTTP的操作统一数据操作接口，限制URL为资源，即每次请求对应某种资源的某种操作，这种无状态的设计可以实现client-server的解耦分离，保证系统两端都有横向扩展能力。
go-restful
go-restfulisapackageforbuildingREST-styleWebServicesusingGoogleGo。go-restful定义了ContainerWebService和Route三个重要数据结构。
- Route表示一条路由，包含URL/HTTPmethod/输入输出类型/回调处理函数RouteFunction
- WebService表示一个服务，由多个Route组成，他们共享同一个RootPath
- Container表示一个服务器，由多个WebService和一个http.ServerMux组成，使用RouteSelector进行分发
最简单的使用实例，向WebService注册路由，将WebService添加到Container中，由Container负责分发。
funcmain(){
ws:=new(restful.WebService)
ws.Path("/users")
ws.Route(ws.GET("/").To(u.findAllUsers).
Doc("getallusers").
Metadata(restfulspec.KeyOpenAPITags,tags).
Writes([]User{}).
Returns(200,"OK",[]User{}))
container:=restful.NewContainer().Add(ws)
http.ListenAndServe(":8080",container)
}
container
container是根据标准库http的路由器ServeMux写的，并且它通过ServeMux的路由表实现了Handler接口，可参考以前的这篇HTTP协议与Go的实现。
typeContainerstruct{
webServicesLocksync.RWMutex
webServices[]*WebService
ServeMux*http.ServeMux
isRegisteredOnRootbool
containerFilters[]FilterFunction
doNotRecoverbool//defaultistrue
recoverHandleFuncRecoverHandleFunction
serviceErrorHandleFuncServiceErrorHandleFunction
routerRouteSelector//defaultisaCurlyRouter
contentEncodingEnabledbool//defaultisfalse
}
func(c*Container)ServeHTTP(httpwriterhttp.ResponseWriter,httpRequest*http.Request){
c.ServeMux.ServeHTTP(httpwriter,httpRequest)
}
往Container内添加WebService，内部维护的webServices不能有重复的RootPath，
func(c*Container)Add(service*WebService)*Container{
c.webServicesLock.Lock()
deferc.webServicesLock.Unlock()
if!c.isRegisteredOnRoot{
c.isRegisteredOnRoot=c.addHandler(service,c.ServeMux)
}
c.webServices=append(c.webServices,service)
returnc
}
添加到container并注册到mux的是dispatch这个函数，它负责根据不同WebService的rootPath进行分发。
func(c*Container)addHandler(service*WebService,serveMux*http.ServeMux)bool{
pattern:=fixedPrefixPath(service.RootPath())
serveMux.HandleFunc(pattern,c.dispatch)
}
webservice
每组webservice表示一个共享rootPath的服务，其中rootPath通过ws.Path()设置。
typeWebServicestruct{
rootPathstring
pathExpr*pathExpression
routes[]Route
produces[]string
consumes[]string
pathParameters[]*Parameter
filters[]FilterFunction
documentationstring
apiVersionstring
typeNameHandleFuncTypeNameHandleFunction
dynamicRoutesbool
routesLocksync.RWMutex
}
通过Route注册的路由最终构成Route结构体，添加到WebService的routes中。
func(w*WebService)Route(builder*RouteBuilder)*WebService{
w.routesLock.Lock()
deferw.routesLock.Unlock()
builder.copyDefaults(w.produces,w.consumes)
w.routes=append(w.routes,builder.Build())
returnw
}
route
通过RouteBuilder构造Route信息，Path结合了rootPath和subPath。Function是路由Handler，即处理函数，它通过ws.Get(subPath).To(function)的方式加入。Filters实现了个类似gRPC拦截器的东西，也类似go-chassis的chain。
typeRoutestruct{
Methodstring
Produces[]string
Consumes[]string
Pathstring//webservicerootpath+describedpath
FunctionRouteFunction
Filters[]FilterFunction
If[]RouteSelectionConditionFunction
//cachedvaluesfordispatching
relativePathstring
pathParts[]string
pathExpr*pathExpression
//documentation
Docstring
Notesstring
Operationstring
ParameterDocs[]*Parameter
ResponseErrorsmap[int]ResponseError
ReadSample,WriteSampleinterface{}
Metadatamap[string]interface{}
Deprecatedbool
}
dispatch
server侧的主要功能就是路由选择和分发。http包实现了一个ServeMux，go-restful在这个基础上封装了多个服务，如何在从container开始将路由分发给webservice，再由webservice分发给具体处理函数。这些都在dispatch中实现。
- SelectRoute根据Req在注册的WebService中选择匹配的WebService和匹配的Route。其中路由选择器默认是CurlyRouter。
- 解析pathParams，将wrap的请求和相应交给路由的处理函数处理。如果有filters定义，则链式处理。
func(c*Container)dispatch(httpWriterhttp.ResponseWriter,httpRequest*http.Request){
func(){
c.webServicesLock.RLock()
deferc.webServicesLock.RUnlock()
webService,route,err=c.router.SelectRoute(
c.webServices,
httpRequest)
}()
pathProcessor,routerProcessesPath:=c.router.(PathProcessor)
pathParams:=pathProcessor.ExtractParameters(route,webService,httpRequest.URL.Path)
wrappedRequest,wrappedResponse:=route.wrapRequestResponse(writer,
httpRequest,pathParams)
iflen(c.containerFilters)+len(webService.filters)+len(route.Filters)>0{
chain:=FilterChain{Filters:allFilters,Target:func(req*Request,resp*Response){
//handlerequestbyrouteafterpassingallfilters
route.Function(wrappedRequest,wrappedResponse)
}}
chain.ProcessFilter(wrappedRequest,wrappedResponse)
}else{
route.Function(wrappedRequest,wrappedResponse)
}
}
go-chassis
go-chassis实现的rest-server是在go-restful上的一层封装。Register时只要将注册的schema解析成routes，并注册到webService中，Start启动server时container.Add(r.ws)，同时将container作为handler交给http.Server,最后开始ListenAndServe即可。
typerestfulServerstruct{
microServiceNamestring
container*restful.Container
ws*restful.WebService
optsserver.Options
muxsync.RWMutex
exitchanchanerror
server*http.Server
}
根据Method不同，向WebService注册不同方法的handle，从schema读取的routes信息包含Method，Func以及PathPattern。
func(r*restfulServer)Register(schemainterface{},options...server.RegisterOption)(string,error){
schemaType:=reflect.TypeOf(schema)
schemaValue:=reflect.ValueOf(schema)
varschemaNamestring
tokens:=strings.Split(schemaType.String(),".")
iflen(tokens)>=1{
schemaName=tokens[len(tokens)-1]
}
routes,err:=GetRoutes(schema)
for_,route:=rangeroutes{
lager.Logger.Infof("Addroutepath:[%s]Method:[%s]Func:[%s].",
route.Path,route.Method,route.ResourceFuncName)
method,exist:=schemaType.MethodByName(route.ResourceFuncName)
...
handle:=func(req*restful.Request,rep*restful.Response){
c,err:=handler.GetChain(common.Provider,r.opts.ChainName)
inv:=invocation.Invocation{
MicroServiceName:config.SelfServiceName,
SourceMicroService:req.HeaderParameter(common.HeaderSourceName),
Args:req,
Protocol:common.ProtocolRest,
SchemaID:schemaName,
OperationID:method.Name,
}
bs:=NewBaseServer(context.TODO())
bs.req=req
bs.resp=rep
c.Next(&inv,func(ir*invocation.InvocationResponse)error{
ifir.Err!=nil{
returnir.Err
}
method.Func.Call([]reflect.Value{schemaValue,reflect.ValueOf(bs)})
ifbs.resp.StatusCode()>=http.StatusBadRequest{
return...
}
returnnil
})
}
switchroute.Method{
casehttp.MethodGet:
r.ws.Route(r.ws.GET(route.Path).To(handle).
Doc(route.ResourceFuncName).
Operation(route.ResourceFuncName))
...
}
}
returnreflect.TypeOf(schema).String(),nil
}
实在是比较简单，就不写了。今天好困。
遗留问题
- reflect在路由注册中的使用，反射与性能
- routeselect时涉及到模糊匹配如何保证处理速度
- pathParams的解析
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。