我是如何用 200 行代码写出一个 RESTful 微框架,并将功能拆分成 service(一)

whitekoala 发布于3月前 阅读1321次
0 条评论

由于公司业务原因,最近开始接触Golang,之前都是在写PHP,在学习Golang的过程中有很多不适应,因为和动态脚本语言有一定的差异,但也有惊喜,发现了Golang一些很棒的特性。本文旨在分享我是如何用Golang写一个RESTful微框架 GoGym (这个项目名是因为我喜欢去健身房哈哈),从思路到实现。

如何用 net/http 构建一个简单的web服务

Golang提供了简洁的方法来构建web服务

package main

import (
    "net/http"
)

func HelloResponse(rw http.ResponseWriter, request *http.Request) {
    fmt.Fprintf(w, "Hello world.")
}

func main() {
    http.HandleFunc("/", HelloResponse)
    http.ListenAndServe(":3000", nil)
}

其中核心的两个方法:

  • func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) : HandleFunc 注册一个handler function对应到给定的pattern。
  • func ListenAndServe(addr string, handler Handler) error : ListenAndServe 监听给定的TCP网络地址,接着带上handler调用Serve方法来接收请求。

在 go build 之后,执行编译后的文件就能在客户端看到hello world了

有了web服务,就可以制定小目标了

我认为作为第一版本,不需要复杂的设计,只需要接收到用户的请求,并且找到对应的handler,执行其逻辑,然后返回JSON响应就好了。 我是如何用 200 行代码写出一个 RESTful 微框架,并将功能拆分成 service(一)

小目标有了,那怎么实现呢?

1.设计用户如何注册Controller和Action

据我观察,一些框架是在Controller里预先设定了GET,POST,PUT等一系列方法,负责接收GET,POST,PUT的HTTP请求。我认为这样设计的确有其优势,因为用户只需要实现这些方法就好了,但在业务层面也有其劣势,因为我们没有办法保证负责一个页面或者功能的Controller只接收一个GET请求,如果有2个GET请求,那就需要再建立一个Controller,单单实现其GET方法。 因此我借鉴了PHP社区中Laravel注册Controller和Action的语法: Get("/", "IndexController@Index") 。

用户只需要定义:

type IndexController struct {
}

func (IndexController *IndexController) Index(//params) (//return values) {
}

当然这样思考后,就给框架带入了一点动态脚本语言的特性,肯定会用到Golang的 reflect 库。

2.设计Path和Controller还有Action的关系容器

我运用了Golang的map,定义了 map[string]map[string]map[string]string 这样的数据结构

以 ["/":["GET":["IndexController":"Get"], "POST":["IndexController":"Post"]], "/foo":["GET":["IndexController":"Foo"]]] 举例:

这个说明了在"/"这个PATH下面,有GET和POST请求,分别对应了IndexController下的Get和Post方法,在"/foo"这个PATH下面,有GET请求,对应IndexController下的Foo方法。 在接受请求时候,如果没有找到对应的方法,就返回405。

3.如何将注册了的一系列Method与PATH绑定来接收外部请求

我们可以看到, func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) 要求的handler类型是func(ResponseWriter, *Request)),这和我们设计的function func (IndexController *IndexController) Index(//params) (//return values) {} 有所差距。 这时候我发现由于Golang具备First Class Functions特性,因此我们可以将函数做如下处理:

http.HandleFunc(path, HandleRequest())

func HandleRequest() {
    return func(rw http.ResponseWriter, request *http.Request) {
        // do your logic
    }
}

4.和 encoding/json 说Hi

当我们接收到function的返回值后,我们就需要对结果进行json encode,而 encoding/json 正是负责这个功能。 我用的是 json.Marshal() :

func Marshal(v interface{}) ([]byte, error) : Marshal返回v的encoding结果。

如何使用

package main

import (
    "net/url"
    "net/http"
    "github.com/ZhenhangTung/GoGym"
)

type IndexController struct {
}

func (IndexController *IndexController) Index(request map[string]url.Values, headers http.Header) (statusCode int, response interface{}) {
    return 200, map[string]string{"hello": "world"}
}

type BarController struct {
}

func (*BarController) Bar(request map[string]url.Values, headers http.Header) (statusCode int, response interface{}, responseHeader http.Header) {
    return 200, map[string]string{"GoTo": "Bar"}, http.Header{"Foo": {"Bar", "Baz"}}
}

func main() {
    var apiService = GoGym.Prepare()
    apiService.Get("index", "IndexController@Index")
    apiService.Post("bar", "BarController@Bar")
    controllers := []interface{}{&IndexController{}}
    apiService.RegisterControllers(controllers)
    apiService.RegisterController(&BarController{})
    apiService.Serve(3000)
}

项目完整代码

package GoGym

import (
    "encoding/json"
    "fmt"
    "net/http"
    "net/url"
    "reflect"
    "strings"
)

const (
    GETMethod     = "GET"
    POSTMethod    = "POST"
    PUTMethod     = "PUT"
    PATCHMethod   = "PATCH"
    DELETEMethod  = "DELETE"
    OPTIONSMethod = "OPTIONS"
)

const (
    HTTPMethodNotAllowed = 405
)

// APIService for now is the struct for containing controllerRegistry and registeredPathAndController,
// and it is the core service provider
type APIService struct {
    // controllerRegistry is where all registered controllers exist
    controllerRegistry map[string]interface{}
    //registeredPathAndController is a mapping of paths and controllers
    registeredPathAndController map[string]map[string]map[string]string
    requestForm                 map[string]url.Values
}

func (api *APIService) Get(path, controllerWithActionString string) {
    mapping := api.mappingRequestMethodWithControllerAndActions(GETMethod, path, controllerWithActionString)
    api.registeredPathAndController[path] = mapping
}

func (api *APIService) Post(path, controllerWithActionString string) {
    mapping := api.mappingRequestMethodWithControllerAndActions(POSTMethod, path, controllerWithActionString)
    api.registeredPathAndController[path] = mapping
}

func (api *APIService) Put(path, controllerWithActionString string) {
    mapping := api.mappingRequestMethodWithControllerAndActions(PUTMethod, path, controllerWithActionString)
    api.registeredPathAndController[path] = mapping
}

func (api *APIService) Patch(path, controllerWithActionString string) {
    mapping := api.mappingRequestMethodWithControllerAndActions(PATCHMethod, path, controllerWithActionString)
    api.registeredPathAndController[path] = mapping
}

func (api *APIService) Options(path, controllerWithActionString string) {
    mapping := api.mappingRequestMethodWithControllerAndActions(OPTIONSMethod, path, controllerWithActionString)
    api.registeredPathAndController[path] = mapping
}

func (api *APIService) Delete(path, controllerWithActionString string) {
    mapping := api.mappingRequestMethodWithControllerAndActions(DELETEMethod, path, controllerWithActionString)
    api.registeredPathAndController[path] = mapping
}

// mappingRequestMethodWithControllerAndActions is a function for mapping request method with controllers
// which containing actions
func (api *APIService) mappingRequestMethodWithControllerAndActions(requestMethod, path, controllerWithActionString string) map[string]map[string]string {
    mappingResult := make(map[string]map[string]string)
    if length := len(api.registeredPathAndController[path]); length > 0 {
        mappingResult = api.registeredPathAndController[path]
    }
    controllerAndActionSlice := strings.Split(controllerWithActionString, "@")
    controller := controllerAndActionSlice[0]
    action := controllerAndActionSlice[1]
    controllerAndActionMap := map[string]string{controller: action}
    mappingResult[requestMethod] = controllerAndActionMap
    return mappingResult
}

// HandleRequest is a function to handle http request
func (api *APIService) HandleRequest(controllers map[string]map[string]string) http.HandlerFunc {
    return func(rw http.ResponseWriter, request *http.Request) {
        request.ParseForm()
        method := request.Method
        api.requestForm["query"] = request.Form
        api.requestForm["form"] = request.PostForm
        macthedControllers, ok := controllers[method]
        if !ok {
            rw.WriteHeader(HTTPMethodNotAllowed)
        }
        for k, v := range macthedControllers {
            controllerKey := "*" + k
            controller := api.controllerRegistry[controllerKey]
            in := make([]reflect.Value, 2)
            in[0] = reflect.ValueOf(api.requestForm)
            in[1] = reflect.ValueOf(request.Header)
            returnValues := reflect.ValueOf(controller).MethodByName(v).Call(in)
            statusCode := returnValues[0].Interface()
            intStatusCode := statusCode.(int)
            response := returnValues[1].Interface()
            responseHeaders := http.Header{}
            if len(returnValues) == 3 {
                responseHeaders = returnValues[2].Interface().(http.Header)
            }
            api.JSONResponse(rw, intStatusCode, response, responseHeaders)
        }
    }
}

// RegisterHandleFunc is a function registers a handle function to handle request from path
func (api *APIService) RegisterHandleFunc() {
    for k, v := range api.registeredPathAndController {
        path := k
        if !strings.HasPrefix(k, "/") {
            path = fmt.Sprintf("/%v", k)
        }
        http.HandleFunc(path, api.HandleRequest(v))
    }
}

// RegisterControllers is a function registers a struct of controllers into controllerRegistry
func (api *APIService) RegisterControllers(controllers []interface{}) {
    for _, v := range controllers {
        api.RegisterController(v)
    }
}

// RegisterControllers is a function registers a controller into controllerRegistry
func (api *APIService) RegisterController(controller interface{}) {
    controllerType := getType(controller)
    api.controllerRegistry[controllerType] = controller
}

// getType is a function gets the type of value
func getType(value interface{}) string {
    if t := reflect.TypeOf(value); t.Kind() == reflect.Ptr {
        return "*" + t.Elem().Name()
    } else {
        return t.Name()
    }
}

// Serve is a function
func (api *APIService) Serve(port int) {
    api.RegisterHandleFunc()
    fullPort := fmt.Sprintf(":%d", port)
    http.ListenAndServe(fullPort, nil)
}

// JSONResponse is a function return json response
func (api *APIService) JSONResponse(rw http.ResponseWriter, statusCode int, response interface{}, headers http.Header) {
    for k, v := range headers {
        for _, header := range v {
            rw.Header().Add(k, header)
        }
    }
    rw.Header().Add("Content-Type", "application/json")
    rw.WriteHeader(statusCode)
    rsp, err := json.Marshal(response)
    if err != nil {
        // TODO: logging error
        fmt.Println("JSON err:", err)
    }
    rw.Write(rsp)
}

// Prepare is a fucntion prepare the service and return prepared service to the user
func Prepare() *APIService {
    var apiService = new(APIService)
    apiService.controllerRegistry = make(map[string]interface{})
    apiService.registeredPathAndController = make(map[string]map[string]map[string]string)
    apiService.requestForm = make(map[string]url.Values)
    return apiService
}

下期预告

在下一个篇幅中,我会说明我是如何设计服务,并且将上面的代码拆分的。

GoGym 还在很初期的阶段,我对Golang的理解也有限,肯定有很多问题和不足,欢迎有兴趣的同学欢迎到项目的 Github 发布issue大家一起讨论或者提交PR。

查看原文: 我是如何用 200 行代码写出一个 RESTful 微框架,并将功能拆分成 service(一)

需要 登录 后回复方可回复, 如果你还没有账号你可以 注册 一个帐号。