Golang web路由實現方式整理總結

時間  2019-11-21
標籤 golang web 路由 實現 方式 整理 總結 欄目 Go 简体版
原文   原文鏈接

1、參考博客文章整理

1.0 連接整理集合

  1. 博客文章代碼下載地址
  2. Go的http包詳解
  3. Go語言經典庫使用分析（七）| 高性能可擴展 HTTP 路由 httprouter
  4. golang自定義路由控制實現（一）
  5. golang自定義路由控制實現（二）-流式註冊接口以及支持RESTFUL
  6. Golang學習筆記 - 標準庫'net/http'的簡析及自制簡單路由框架
  7. go web框架的路由分析
  8. golang實現的簡單http路由器,用於學習理解http.

1.1 連接文章整理

Go的http包詳解

經過對http包的分析以後，如今讓咱們來梳理一下整個的代碼執行過程。html

  • 首先調用Http.HandleFunc

按順序作了幾件事：git

  1. 調用了DefaultServeMux的HandleFunc
  2. 調用了DefaultServeMux的Handle
  3. 往DefaultServeMux的map[string]muxEntry中增長對應的handler和路由規則
  • 其次調用http.ListenAndServe(":9090", nil)

按順序作了幾件事情：github

  1. 實例化Server
  2. 調用Server的ListenAndServe()
  3. 調用net.Listen("tcp", addr)監聽端口
  4. 啓動一個for循環，在循環體中Accept請求
  5. 對每一個請求實例化一個Conn，而且開啓一個goroutine爲這個請求進行服務go c.serve()
  6. 讀取每一個請求的內容w, err := c.readRequest()
  7. 判斷handler是否爲空，若是沒有設置handler（這個例子就沒有設置handler），handler就設置爲DefaultServeMux
  8. 調用handler的ServeHttp
  9. 在這個例子中，下面就進入到DefaultServeMux.ServeHttp
  10. 根據request選擇handler，而且進入到這個handler的ServeHTTP

mux.handler(r).ServeHTTP(w, r)golang

  1. 選擇handler：
  • A 判斷是否有路由能知足這個request（循環遍歷ServeMux的muxEntry）
  • B 若是有路由知足，調用這個路由handler的ServeHTTP
  • C 若是沒有路由知足，調用NotFoundHandler的ServeHTTP

2、Golang Web路由組件實現方式

2.0 實現方式分類

  1. 原生方式

（1）調用http.HandleFunc（2）調用http.ListenAndServe(":8080", nil)web

  1. 路由封裝重寫ServeHTTP方式
  • 路由存儲格式:

（1）map[string]http.HandlerFunc格式，其中的string由method和傳入參數拼接字符串組成（2）map[string]map[string]http.HandlerFunc，,其中一維的鍵String表示請求method好比post, get 等。二維的鍵string表示要匹配的URL地址， http.HandlerFunc固然就是處理URL請求的具體方法。segmentfault

  • 重寫步驟:

2.1 原生方式實現

//http.go
package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", SayhelloName)
    http.ListenAndServe(":8080", nil)
}

func SayhelloName(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "原生HTTP路由測試頁面")
}

/*
package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/", SayhelloName)
    log.Fatal(http.ListenAndServe(":8080", nil))
    //http.ListenAndServe(":8080", nil)
}

func SayhelloName(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "原生HTTP路由測試頁面")
}
*/

原生方式主要是2個操做，第1步使用http.HandleFunc函數導入對應的方法，第二步使用http.ListenAndServe監聽對應的端口app

2.2 路由封裝重寫ServeHTTP方式實現

第1種方式 不存儲對應路由規則、直接在ServeHTTP判斷對應的路由規則方式

你能夠直接使用&結構體方式new一個空對象,來實現:框架

//第一種方式
package main

import (
    "fmt"
    "net/http"
)

type MyMux struct {
}

func (p *MyMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path == "/" {
        sayhelloName(w, r)
        return
    }
    http.NotFound(w, r)
    return
}

func sayhelloName(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello MyMuxRoute!")
}

func main() {
    mux := &MyMux{}                   //&結構體方式
    http.ListenAndServe(":8080", mux) //mux是核心操做代碼
}

第2種方式 你也能夠經過經過一個NewMyMux方法來實現這個功能，而後經過調用當前NewMyMux方法來實現,主流Web框架都使用這種方法實現對應的路由功能，NewMyMux方法代碼:

func NewMyMux() *MyMux {
    return new(MyMux)
}

完整代碼tcp

//第二種方式
package main

import (
    "fmt"
    "net/http"
)

type MyMux struct {
}

func (p *MyMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path == "/" {
        sayhelloName(w, r)
        return
    }
    http.NotFound(w, r)
    return
}

func sayhelloName(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello MyMuxRoute!")
}

//新建的&結構體方法，框架中十分經常使用
func NewMyMux() *MyMux {
    return &MyMux{} //等同於  return new(MyMux)
}

func main() {
    mux := NewMyMux()                 //經過調用一個方法來實現
    http.ListenAndServe(":8080", mux) //mux是核心代碼
}

2.3 路由封裝重寫ServeHTTP方式繼續封裝代碼

咱們繼續封裝代碼，將NewMyMux方法和type MyMux struct以及ServeHTTP封裝到一個Router包裏面，其餘的仍是在main包裏面，03http.go詳細代碼:

//第二種方式代碼封裝
//03http.go
package main

import (
    "GoHTTP/01httpBase/03httpBase/route" //你複製過去的代碼，前面的HTTP/01httpBase/03httpBase/根據須要修改
    "net/http"
)

func main() {
    mux := route.NewMyMux()           //經過調用一個方法來實現
    http.ListenAndServe(":8080", mux) //mux是核心代碼
}

封裝的路由route.go代碼:函數

//route包函數封裝
//route.go
package route

import (
    "fmt"
    "net/http"
)

type MyMux struct {
}

//新建的&結構體方法，框架中十分經常使用
func NewMyMux() *MyMux {
    return &MyMux{} //等同於  return new(MyMux)
}

func sayhelloName(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello MyMuxRoute!")
}

func (p *MyMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    //下面是路由處理，通常web框架會使用一個封裝函數統一處理
    if r.URL.Path == "/" {
        sayhelloName(w, r) //這是全部web框架路由的核心代碼
        return
    }
    http.NotFound(w, r)
    return
}

咱們增長MyMux結構體來存儲http.HandleFunc("/", SayhelloName)和重寫NewMyMux方法，增長路由的多樣性和靈活性，04http.go代碼:

//第二種方式代碼封裝
//增長NewMyMux結構體屬性，方便存儲http.HandleFunc("/", SayhelloName)路由規則
//04http.go
package main

import (
    "GoHTTP/01httpBase/03httpBase/route" //你複製過去的代碼，前面的HTTP/01httpBase/03httpBase/根據須要修改
    "net/http"
)

func main() {
    mux := route.NewMyMux()           //經過調用一個方法來實現
    http.ListenAndServe(":8080", mux) //mux是核心代碼
}

route.go代碼:

//route包函數封裝
//route.go
package route

import (
    "fmt"
    "net/http"
)

/*【對比前代碼】
type MyMux struct {
}
*/

type MyMux struct {
    handlers map[string][]*Handler //用於存儲http.HandleFunc("/", SayhelloName) 格式的路由規則
}

type Handler struct {
    path string
    http.HandlerFunc
}

/*【對比前代碼】
//新建的&結構體方法，框架中十分經常使用
func NewMyMux() *MyMux {
    return &MyMux{} //等同於  return new(MyMux)
}
*/

func NewMyMux() *MyMux {
    return &MyMux{make(map[string][]*Handler)}
}

func sayhelloName(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello MyMuxRoute!")
}

func (p *MyMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    //下面是路由處理，通常web框架會使用一個封裝函數統一處理
    if r.URL.Path == "/" {
        sayhelloName(w, r) //這是全部web框架路由的核心代碼
        return
    }
    http.NotFound(w, r)
    return
}

咱們繼續封裝http.ListenAndServe(":8080", mux)功能，提高代碼的簡潔性，也方便後期其餘封裝操做

//第二種方式代碼封裝
//封裝http.ListenAndServe(":8080", mux)功能
//05http.go
package main

import (
    "GoHTTP/01httpBase/05httpBase/route" //你複製過去的代碼，前面的HTTP/01httpBase/03httpBase/根據須要修改
    //"fmt"
    //"net/http"
)

func main() {
    mux := route.NewMyMux() //經過調用一個方法來實現
    mux.Listen(":8080")     //http.ListenAndServe(":8080", mux)
}

route.go代碼詳情:

//route包函數封裝
//route.go
package route

import (
    "fmt"
    "log"
    "net/http"
)

type MyMux struct {
    handlers map[string][]*Handler //用於存儲http.HandleFunc("/", SayhelloName) 格式的路由規則
}

type Handler struct {
    path string
    http.HandlerFunc
}

//開啓http服務
func (m *MyMux) Listen(port string) {
    err := http.ListenAndServe(port, m)
    if err != nil {
        log.Fatal("開啓http服務錯誤!")
    }
}

func NewMyMux() *MyMux {
    return &MyMux{make(map[string][]*Handler)}
}

func (p *MyMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    //下面是路由處理，通常web框架會使用一個封裝函數統一處理
    if r.URL.Path == "/" {
        sayhelloName(w, r) //這是全部web框架路由的核心代碼
        return
    }
    http.NotFound(w, r)
    return
}

func sayhelloName(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello MyMuxRoute!")
}

咱們繼續封裝存儲路由功能和重寫ServeHTTP()功能，增長路由多樣性和靈活性，方便後期存儲Rest格式接口

//第二種方式代碼封裝
//封裝AddRoute添加路由功能、重寫ServeHTTP功能
//06http.go
package main

import (
    "GoHTTP/01httpBase/06httpBase/route" //你複製過去的代碼，前面的HTTP/01httpBase/03httpBase/根據須要修改
    "fmt"
    "net/http"
)

func main() {
    r := route.NewMyMux() //經過調用一個方法來實現
    r.AddRoute("GET", "/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Hello Get!")
    })
    //mux.Listen(":8080")
    http.ListenAndServe(":8080", r)
}
//route包函數封裝
//route.go
package route

import (
    "fmt"
    "log"
    "net/http"
    "strings"
)

type MyMux struct {
    handlers map[string][]*Handler //用於存儲http.HandleFunc("/", SayhelloName) 格式的路由規則
}

type Handler struct {
    path string
    http.HandlerFunc
}

//開啓http服務
func (m *MyMux) Listen(port string) {
    err := http.ListenAndServe(port, m)
    if err != nil {
        log.Fatal("開啓http服務錯誤!")
    }
}

func NewMyMux() *MyMux {
    return &MyMux{make(map[string][]*Handler)}
}

//添加路由
func (m *MyMux) AddRoute(mode string, path string, fun http.HandlerFunc) {
    m.add(mode, path, fun)
}

//添加路由
/*mode  Post|Get|Put|Delete
 *path  前綴
 *fun    方法
 */
func (m *MyMux) add(mode, path string, fun http.HandlerFunc) {
    h := &Handler{
        strings.ToLower(path),
        fun}

    //fmt調試代碼能夠刪除
    fmt.Println("h ::", &h)
    fmt.Println("strings.ToLower(path) ::", strings.ToLower(path))
    fmt.Println("strings.ToLower(mode) ::", strings.ToLower(mode))

    //下面是存儲路由的核心代碼，這裏的路由m.handlers存儲的格式是Get|Post|Put|Delete:String:http.HandlerFunc
    m.handlers[strings.ToLower(mode)] = append(
        m.handlers[strings.ToLower(mode)],
        h,
    )
    fmt.Println("m.handlers", m.handlers[strings.ToLower(mode)])
}

//優化前代碼
/*
func (p *MyMux) ServeHTTP2(w http.ResponseWriter, r *http.Request) {
    //下面是路由處理，通常web框架會使用一個封裝函數統一處理
    if r.URL.Path == "/" {
        sayhelloName(w, r) //這是全部web框架路由的核心代碼
        return
    }
    http.NotFound(w, r)
    return
}
*/

//進行路由分配

func (m *MyMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    //處理靜態文件
    url := strings.Split(strings.TrimLeft(r.URL.Path, "/"), "/")

    //調試代碼，能夠直接刪除
    fmt.Println("r", fmt.Sprintf("%+v", r))
    fmt.Println("w", fmt.Sprintf("%+v", w))

    for _, handler := range m.handlers[strings.ToLower(r.Method)] {
        if handler.path == "/"+strings.ToLower(url[0]) {
            handler.ServeHTTP(w, r) //調用的是func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) { f(w, r) }
            return
        }
    }
    http.NotFound(w, r)
    return
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程