【Go入门学习】golang自定义路由控制实现（一）

时间 2019-12-14

原文原文链接

因为本人以前一直是Java Coder，在Java web开发中其实你们都很依赖框架，因此当在学习Golang的时候，本身便想着在Go开发中脱离框架，本身动手造框架来练习。经过学习借鉴Java的思想还有部分框架的源码，在golang上面进行实现，从而达到对Java和Golang的同时学习目的，这就很美滋滋了。
Golang中http的设计很是轻量，又兼具很高的扩展性，初学者均可以轻易的设计出自定义的路由功能，使用上十分简单（这里……来吐槽一下Java的Servlet，虽然我也对Java爱得深沉），下面请看Go的Demo。golang

func HelloServer1(w http.ResponseWriter, req *http.Request) {

    fmt.Fprint(w,"hello world")
}
func main() {
    http.HandleFunc("/test", HelloServer1)
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal("ListenAndServe: ", err.Error())
    }
}

短短的几行代码即可以成功注册一个接口并跑起服务。可是原生的开发方式提供的功能是比较精简的目前几乎全部的Web应用路由实现都是基于http默认的路由器，可是Go自带的路由器有几个限制：web

不支持参数设定，例如/user/:uid 这种泛类型匹配。
没法很好的支持REST模式，没法限制访问的方法，例如上面的例子中，用户访问/foo，能够用GET、POST、DELETE、HEAD等方式访问。
通常网站的路由规则太多了，编写繁琐，能够经过struct的方法进行一种简化。
Go有如此限制跟http提供的默认方式有关，咱们先看下http两个关键的struct

type ServeMux struct {
    mu    sync.RWMutex
    m     map[string]muxEntry
    hosts bool // whether any patterns contain hostnames
}

type muxEntry struct {
    explicit bool
    h        Handler
    pattern  string
}

咱们须要重点关键两个地方，一个是ServeMux 中的参数m，它的类型是 map[string]muxEntry ，这里咱们天然而然能够想到，参数m负责路由分发。第二个重点则是muxEntry，muxEntry的h Handler 对应的就是咱们编写的接口，而围绕这个接口，http并无其余过多的功能，甚至连像Java中制定一套统一web开发标准都没有。所以http中只是提供最基础的功能，用户则须要以这些功能为基础，进而YY出本身想要的框架或者更丰富的功能。
首先咱们问题，可以快速简单的设置Http Method，以方便往后支持RESTFUL的URL规范。有两种简单的作法，第一种作法是使用二维Map ，即map[string]map[string]http.HandlerFunc,其中一维的键String表示请求method好比post, get 等。二维的键string表示要匹配的URL地址， http.HandlerFunc固然就是处理URL请求的具体方法。第二种作法便是笔者采用的作法，实际上是第一种作法演变而来的，HTTP 中Method的种类是固定的，其实咱们彻底能够用一个数组，而值为map[string]http.HandlerFunc来实现。segmentfault

const (
    GET         = iota
    POST
    PUT
    DELETE
    CONNECTIBNG
    HEAD
    OPTIONS
    PATCH
    TRACE
)

看完上面常量的设置，想必读者已经知道了个人意思，e.g:array[0]表示GET方法下全部的接口的集合,array[1]表示POST方法下全部的接口的集合基本原理其实也简单，把Get方法下的全部的接口都存储到array[0]的值中，以此推理其余方法。原理简单，可是一个框架的设计必须高内聚低耦合，一个Web框架中路由分发是基础，在该此处上须要创建更多的功能，好比说过滤器等。在初期设计的时候必须保证要有可扩展性，因此笔者认为难点在于此。下面直接上代码，对应的代码有充分的注释。数组

package odserver

import (
    "net/http"
)
//实现IOdServer的接口，以及http提供ServeHttp方法
type OdServer struct {
    router MethodMaps
}


type IOdServer interface {
    GET(url string, f HandlerFunc)
    POST(url string, f HandlerFunc)
    PUT(url string, f HandlerFunc)
    DELETE(url string, f HandlerFunc)
}

type HandlerMapped struct {
    f HandlerFunc
}
//接口函数单位，即咱们编写代码逻辑的函数
type HandlerFunc func(w http.ResponseWriter, req *http.Request)

func Default() *OdServer {
    return &OdServer{
        router:NewRouter(),
    }
}

//实现Handler接口，匹配方法以及路径
func (o *OdServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    //转发给doHandler进行执行
    o.doHandler(w,req)
}
//判断须要执行的Http Method，从而查找对应的接口而且执行
func (o *OdServer) doHandler(w http.ResponseWriter, req *http.Request) {
    switch req.Method {
    case http.MethodGet:
        {
            if hm, ok := o.router.GetMapping(req.URL.RequestURI()); ok {
                hm.f(w, req)
            }
        }
    case http.MethodPost:
        {
            if hm, ok := o.router.PostMapping(req.URL.RequestURI()); ok {
                hm.f(w, req)
            }

        }
    case http.MethodDelete:
        {
            if hm, ok := o.router.DeleteMapping(req.URL.String()); ok {
                hm.f(w, req)
            }
        }
    case http.MethodPut:
        {
            if hm, ok := o.router.PutMapping(req.URL.String()); ok {
                hm.f(w, req)
            }
        }
    default:
        {

        }
    }
}

func (o *OdServer) GET(url string, f HandlerFunc) {
    o.router.GetAdd(url, HandlerMapped{f: f})
}
func (o *OdServer) POST(url string, f HandlerFunc) {
    o.router.PostAdd(url, HandlerMapped{f: f})
}
func (o *OdServer) PUT(url string, f HandlerFunc) {
    o.router.PutAdd(url, HandlerMapped{f: f})
}
func (o *OdServer) DELETE(url string, f HandlerFunc) {
    o.router.DeleteAdd(url, HandlerMapped{f: f})
}

package odserver

/**
提供基本的路由功能，添加路由，查找路由
 */
const (
    GET         = iota
    POST
    PUT
    DELETE
    CONNECTIBNG
    HEAD
    OPTIONS
    PATCH
    TRACE
)

func NewRouter() MethodMaps {
    return []handler{
        GET:    make(handler),
        POST:   make(handler),
        PUT:    make(handler),
        DELETE: make(handler),
    }
}

type MethodMaps [] handler
type handler map[string]HandlerMapped
//映射路由，获取Get方法下对应的接口
func (m MethodMaps) GetMapping(url string) (HandlerMapped, bool) {
    if hm, ok := m[GET][url]; ok {
        return hm, true
    }
    return HandlerMapped{}, false
}
//映射路由，获取Post方法下对应的接口
func (m MethodMaps) PostMapping(url string) (HandlerMapped, bool) {
    if hm, ok := m[POST][url]; ok {
        return hm, true
    }
    return HandlerMapped{}, false
}
//映射路由，获取Delete方法下对应的接口
func (m MethodMaps) DeleteMapping(url string) (HandlerMapped, bool) {
    if hm, ok := m[DELETE][url]; ok {
        return hm, true
    }
    return HandlerMapped{}, false
}
//映射路由，获取Put方法下对应的接口
func (m MethodMaps) PutMapping(url string) (HandlerMapped, bool) {
    if hm, ok := m[PUT][url]; ok {
        return hm, true
    }
    return HandlerMapped{}, false
}
//增长Get方法下的接口
func (m MethodMaps) GetAdd(url string, mapped HandlerMapped) {
    if _, ok := m.GetMapping(url); ok {
        panic("duplicate url with get method")
    }
    m[GET].SetUrl(url,mapped)
}
//增长Post方法下的接口
func (m MethodMaps) PostAdd(url string, mapped HandlerMapped) {
    if _, ok := m.GetMapping(url); ok {
        panic("duplicate url with Post method")
    }
    m[POST].SetUrl(url,mapped)

}
//增长Put方法下的接口
func (m MethodMaps) PutAdd(url string, mapped HandlerMapped) {
    if _, ok := m.GetMapping(url); ok {
        panic("duplicate url with Put method")
    }
    m[PUT].SetUrl(url,mapped)

}
//增长Delete方法下的接口
func (m MethodMaps) DeleteAdd(url string, mapped HandlerMapped) {
    if _, ok := m.GetMapping(url); ok {
        panic("duplicate url with Delete method")
    }
    m[DELETE].SetUrl(url,mapped)
}
func (h handler) SetUrl(url string, mapped HandlerMapped) {
    h[url] = mapped
}

如我所说，我以为学习Golang比较有意思的是，能够将从Java里学到的东西，转之在Golang里尝试实现，不只学习了Golang，还使得本身对Java的认识进一步提高。若是读者有更好的方法，不吝赐教
参考资料：# Golang学习笔记 - 标准库"net/http"的简析及自制简单路由框架app