Go 微服务框架 | 路由实现

文章目录

    • 不用框架实现web接口
    • 实现简单的路由
    • 实现分组路由
    • 支持不同的请求方式
    • 支持同一个路径的不同请求方式
    • 前缀树
    • 应用前缀树
    • 完善路由代码

不用框架实现web接口

// blog main.go 文件
package mainimport ("fmt""log""net/http"
)func main() {fmt.Println("Hello World!")// 注册 HTTP 路由 /hellohttp.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {fmt.Fprintf(w, "Hello Go!")})// 启动 HTTP 服务器err := http.ListenAndServe("8111", nil)if err != nil {log.Fatal(err)}
}
  • http.HandleFunc 注册一个路由 /hello 并绑定处理函数。
  • 当用户访问 http://localhost:8111/hello 时，执行匿名函数：
    • w http.ResponseWriter：用于向客户端发送 HTTP 响应。
    • r *http.Request：包含客户端发来的请求信息（如 URL、Headers 等）。
  • fmt.Fprintf(w, "Hello Go!")：
    • 向 HTTP 响应写入 "Hello Go!"（相当于 w.Write([]byte("Hello Go!"))）。
    • 默认状态码是 200 OK。
  • http.ListenAndServe(":8111", nil)：
    • 启动 HTTP 服务器，监听 8111 端口（: 表示监听所有网络接口）。
    • nil 表示使用默认的 DefaultServeMux 路由器（即之前用 http.HandleFunc 注册的路由）。
  • if err != nil { log.Fatal(err) }：如果服务器启动失败（如端口被占用），打印错误并终止程序。
  • fmt.Fprintf 是 Go 语言 fmt 包提供的一个格式化输出函数，用于将格式化后的字符串写入指定的 io.Writer 接口（如文件、HTTP 响应、标准输出等）。它的作用类似于 fmt.Printf，但不是输出到终端，而是写入到任意实现了 io.Writer 的对象。
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)
  • w io.Writer：目标写入器（如 http.ResponseWriter、文件、缓冲区等）。
  • format string：格式化字符串（包含占位符，如 %s, %d, %v 等）。
  • a ...interface{}：可变参数，用于填充格式化字符串中的占位符。
  • 返回值：
    • n int：成功写入的字节数。
    • err error：写入过程中遇到的错误（如写入失败）。

实现简单的路由

// zjgo ms.go 文件package zjgoimport ("log""net/http"
)type Engine struct {
}func New() *Engine {return &Engine{}
}func (e *Engine) Run() {err := http.ListenAndServe("8111", nil)if err != nil {log.Fatal(err)}
}
  • 经过封装之后，原来的 main 函数可以简洁为如下：
package mainimport ("fmt""github.com/ErizJ/ZJGo/zjgo"
)func main() {fmt.Println("Hello World!")// // 注册 HTTP 路由 /hello// http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {// 	fmt.Fprintf(w, "Hello Go!")// })// // 启动 HTTP 服务器// err := http.ListenAndServe("8111", nil)// if err != nil {// 	log.Fatal(err)// }engine := zjgo.New()engine.Run()
}
  • 注意这里服务启动后会 404 Not Found，因为我们没有实现对应的响应函数 Handler。
package zjgoimport ("log""net/http"
)// 定义处理响应函数
type HandleFunc func(w http.ResponseWriter, r *http.Request)// 定义路由结构体
type router struct {handleFuncMap map[string]HandleFunc
}// 给路由结构体添加一个添加路由功能的函数
func (r *router) Add(name string, handleFunc HandleFunc) {r.handleFuncMap[name] = handleFunc
}// 定义一个引擎结构体
type Engine struct {router
}// 引擎结构体的初始化方法
func New() *Engine {return &Engine{router: router{handleFuncMap: make(map[string]HandleFunc),},}
}// 引擎的启动方法
func (e *Engine) Run() {for key, value := range e.handleFuncMap {http.HandleFunc(key, value)}err := http.ListenAndServe("8111", nil)if err != nil {log.Fatal(err)}
}
  • 在 Go 语言中，当你将一个类型（如 router）嵌入到另一个结构体（如 Engine）中时，这被称为类型嵌入（Embedded Type）。这是一种组合的方式，它允许 Engine 直接访问 router 的字段和方法，而不需要显式地通过一个字段名来访问。
package mainimport ("fmt""net/http""github.com/ErizJ/ZJGo/zjgo"
)func main() {fmt.Println("Hello World!")// // 注册 HTTP 路由 /hello// http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {// 	fmt.Fprintf(w, "Hello Go!")// })// // 启动 HTTP 服务器// err := http.ListenAndServe("8111", nil)// if err != nil {// 	log.Fatal(err)// }engine := zjgo.New()engine.Add("/hello", func(w http.ResponseWriter, r *http.Request) {fmt.Fprintf(w, "Hello Go!")})engine.Run()
}
  • 这样我们就实现了一个简单的路由功能，下面进行进一步完善。

实现分组路由

  • 大多数情况下我们希望写的接口归属于某一个模块，这样便于管理以及维护，代码也会更为清晰。
  • 例如：/user/getUser 和 /user/createUser 都同属于 user 模块。
// zj.gopackage zjgoimport ("log""net/http"
)// 定义处理响应函数
type HandleFunc func(w http.ResponseWriter, r *http.Request)// 抽象出路由的概念
type routerGroup struct {name          string                // 组名handleFuncMap map[string]HandleFunc // 映射关系应该由每个路由组去维护
}// 定义路由结构体
type router struct {routerGroups []*routerGroup // 路由下面应该维护着不同的组
}// 添加路由组
func (r *router) Group(name string) *routerGroup {routerGroup := &routerGroup{name:          name,handleFuncMap: make(map[string]HandleFunc),}r.routerGroups = append(r.routerGroups, routerGroup)return routerGroup
}// 给路由结构体添加一个添加路由功能的函数
func (routerGroup *routerGroup) Add(name string, handleFunc HandleFunc) {routerGroup.handleFuncMap[name] = handleFunc
}// 定义一个引擎结构体
type Engine struct {router
}// 引擎结构体的初始化方法
func New() *Engine {return &Engine{router: router{},}
}// 引擎的启动方法
func (e *Engine) Run() {for _, group := range e.routerGroups {for name, value := range group.handleFuncMap {http.HandleFunc("/"+group.name+name, value)}}err := http.ListenAndServe(":3986", nil)if err != nil {log.Fatal(err)}
}

// main.gopackage mainimport ("fmt""net/http""github.com/ErizJ/ZJGo/zjgo"
)func main() {fmt.Println("Hello World!")// // 注册 HTTP 路由 /hello// http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {// 	fmt.Fprintf(w, "Hello Go!")// })// // 启动 HTTP 服务器// err := http.ListenAndServe("8111", nil)// if err != nil {// 	log.Fatal(err)// }engine := zjgo.New()g1 := engine.Group("user")g1.Add("/hello", func(w http.ResponseWriter, r *http.Request) {fmt.Fprintf(w, "Hello Go!——user/hello")})g1.Add("/info", func(w http.ResponseWriter, r *http.Request) {fmt.Fprintf(w, "Hello Go!——user/info")})g2 := engine.Group("order")g2.Add("/hello", func(w http.ResponseWriter, r *http.Request) {fmt.Fprintf(w, "Hello Go!——order/hello")})g2.Add("/info", func(w http.ResponseWriter, r *http.Request) {fmt.Fprintf(w, "Hello Go!——order/info")})fmt.Println("Starting...")engine.Run()}

支持不同的请求方式

  • net / http下的路由，只要路径匹配，就可以进入处理方法。
  • 但是在我们实际应用之中，比如我们使用 Restful 风格的接口在同一路径下，会使用 GET、POST、DELETE、PUT来代替增删改查，所以我们要对不同的请求方式做相应的支持。
// zj.gopackage zjgoimport ("fmt""log""net/http"
)// 定义处理响应函数
type HandleFunc func(w http.ResponseWriter, r *http.Request)// 抽象出路由的概念
type routerGroup struct {name             string                // 组名handleFuncMap    map[string]HandleFunc // 映射关系应该由每个路由组去维护handlerMethodMap map[string][]string   // 记录GET，POST等请求方式所记录的路由，实现对同一路由不同请求方式的支持
}// 定义路由结构体
type router struct {routerGroups []*routerGroup // 路由下面应该维护着不同的组
}// 添加路由组
func (r *router) Group(name string) *routerGroup {routerGroup := &routerGroup{name:             name,handleFuncMap:    make(map[string]HandleFunc),handlerMethodMap: make(map[string][]string),}r.routerGroups = append(r.routerGroups, routerGroup)return routerGroup
}// 给路由结构体添加一个添加路由功能的函数
// func (routerGroup *routerGroup) Add(name string, handleFunc HandleFunc) {
// 	routerGroup.handleFuncMap[name] = handleFunc
// }// Any代表支持任意的请求方式
func (routerGroup *routerGroup) Any(name string, handleFunc HandleFunc) {routerGroup.handleFuncMap[name] = handleFuncrouterGroup.handlerMethodMap["ANY"] = append(routerGroup.handlerMethodMap["ANY"], name)
}// POST代表支持POST请求方式
func (routerGroup *routerGroup) Post(name string, handleFunc HandleFunc) {routerGroup.handleFuncMap[name] = handleFuncrouterGroup.handlerMethodMap[http.MethodPost] = append(routerGroup.handlerMethodMap[http.MethodPost], name)
}// GET代表支持GET请求方式
func (routerGroup *routerGroup) Get(name string, handleFunc HandleFunc) {routerGroup.handleFuncMap[name] = handleFuncrouterGroup.handlerMethodMap[http.MethodGet] = append(routerGroup.handlerMethodMap[http.MethodGet], name)
}// 只要实现 ServeHTTP 这个方法，就相当于实现了对应的 HTTP 处理器
// 结构体 Engine 实现了 ServeHTTP(w http.ResponseWriter, r *http.Request) 方法
// 所以它就自动实现了 http.Handler 接口，因此可以直接被用于 http.ListenAndServe
// Engine 实现了 ServeHTTP，它就是一个合法的 http.Handler，可以用 http.Handle 来绑定它到某个具体的路由路径上！
func (e *Engine) ServeHTTP(w http.ResponseWriter, r *http.Request) {// 在 Go 的 net/http 包中，r *http.Request 代表了客户端发来的 HTTP 请求对象。// 可以通过 r.Method 来获取这次请求使用的是什么方法（Method），例如：GET、POST、PUT、DELETE 等。if r.Method == http.MethodGet {fmt.Fprintf(w, "这是一个 GET 请求")} else if r.Method == http.MethodPost {fmt.Fprintf(w, "这是一个 POST 请求")} else {fmt.Fprintf(w, "这是一个其他类型的请求：%s", r.Method)}for _, group := range e.routerGroups {for name, methodHandle := range group.handleFuncMap {url := "/" + group.name + name//判断一下当前的url是否等于请求的url，即路由匹配if r.RequestURI == url {// 先判断当前请求路由是否在支持任意请求方式的 Any map里面if routers, exist := group.handlerMethodMap["ANY"]; exist {for _, routerName := range routers {// 确实支持 Any 请求方式if routerName == name {methodHandle(w, r)return}}}// 不支持 Any，去该请求所对应的请求方式对应的 Map 里面去找是否有对应的路由if routers, exist := group.handlerMethodMap[r.Method]; exist {for _, routerName := range routers {// 确实支持对应请求方式if routerName == name {methodHandle(w, r)return}}}// 没找到对应的路由，说明该请求方式不允许w.WriteHeader(http.StatusMethodNotAllowed)fmt.Fprintf(w, "%s %s not allowed!!!\n", r.Method, r.RequestURI)return}}}w.WriteHeader(http.StatusNotFound)fmt.Fprintf(w, "%s %s not found!!!\n", r.Method, r.RequestURI)return
}// 定义一个引擎结构体
type Engine struct {router
}// 引擎结构体的初始化方法
func New() *Engine {return &Engine{router: router{},}
}// 引擎的启动方法
func (e *Engine) Run() {// for _, group := range e.routerGroups {// 	for name, value := range group.handleFuncMap {// 		http.HandleFunc("/"+group.name+name, value)// 	}// }// 把 e 这个http处理器绑定到对应路由下http.Handle("/", e)err := http.ListenAndServe(":3986", nil)if err != nil {log.Fatal(err)}
}

// main.gopackage mainimport ("fmt""net/http""github.com/ErizJ/ZJGo/zjgo"
)func main() {fmt.Println("Hello World!")// // 注册 HTTP 路由 /hello// http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {// 	fmt.Fprintf(w, "Hello Go!")// })// // 启动 HTTP 服务器// err := http.ListenAndServe("8111", nil)// if err != nil {// 	log.Fatal(err)// }engine := zjgo.New()g1 := engine.Group("user")g1.Get("/hello", func(w http.ResponseWriter, r *http.Request) {fmt.Fprintf(w, http.MethodGet+" Hello Go!——user/hello")})// 浏览器地址栏输入的都是 GET 请求// 需要用 curl 或 Postman 来发一个真正的 POST 请求，才会命中 Post handlerg1.Post("/info", func(w http.ResponseWriter, r *http.Request) {fmt.Fprintf(w, http.MethodPost+" Hello Go!——user/info")})// 只要路由匹配，就会执行对应的处理函数g1.Any("/any", func(w http.ResponseWriter, r *http.Request) {fmt.Fprintf(w, " Hello Go!——user/any")})// g2 := engine.Group("order")// g2.Add("/hello", func(w http.ResponseWriter, r *http.Request) {// 	fmt.Fprintf(w, "Hello Go!——order/hello")// })// g2.Add("/info", func(w http.ResponseWriter, r *http.Request) {// 	fmt.Fprintf(w, "Hello Go!——order/info")// })fmt.Println("Starting...")engine.Run()
}
  • 但是目前还是存在一些问题的，目前不支持同一个路由进行 GET 和 POST，因为在 map 里面会被覆盖。
  • routerGroup.handleFuncMap[name] = handleFunc，在 Post 和 Get 方法下都有这段代码，这就会造成方法的覆盖。

支持同一个路径的不同请求方式

  • 标准库 net/http 本身只提供了最基础的路由匹配机制，也就是通过：http.HandleFunc("/path", handler)，它的匹配机制非常简单：只根据请求路径匹配，不区分请求方法（GET/POST）。
  • 如果在方法中这样写，是手动在 handler 里面区分请求方法，net/http 本身并不会替你区分。
http.HandleFunc("/info", func(w http.ResponseWriter, r *http.Request) {if r.Method == http.MethodPost {// 处理 POST} else if r.Method == http.MethodGet {// 处理 GET} else {http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)}
})
  • 要限制不同请求方法（GET、POST 分别调用不同的 handler），就得框架（或者你自己）在 ServeHTTP 里手动实现。
  • 像 Gin、Echo、Fiber 等这些 Web 框架，都是在它们内部封装了：
    • 请求方法和路径的双重匹配机制
    • 路由注册表，支持多种请求方式绑定不同 handler
    • 匹配失败时返回 405 Method Not Allowed 或 404 Not Found
  • 考虑在每个路由组 routerGroup 的 handleFuncMap 上做文章，原先是 map[name]HandleFunc，现在可以加入 map 中 map，也即 map[name]map[method]HandleFunc。
// context.gopackage zjgoimport "net/http"// context 用于保存上下文的信息，用于传递信息
type Context struct {W http.ResponseWriterR *http.Request
}

// zj.gopackage zjgoimport ("fmt""log""net/http"
)const ANY = "ANY"// 定义处理响应函数
type HandleFunc func(ctx *Context)// 抽象出路由的概念
type routerGroup struct {name             string                           // 组名handleFuncMap    map[string]map[string]HandleFunc // 映射关系应该由每个路由组去维护handlerMethodMap map[string][]string              // 记录GET，POST等请求方式所记录的路由，实现对同一路由不同请求方式的支持
}// 定义路由结构体
type router struct {routerGroups []*routerGroup // 路由下面应该维护着不同的组
}// 添加路由组
func (r *router) Group(name string) *routerGroup {routerGroup := &routerGroup{name:             name,handleFuncMap:    make(map[string]map[string]HandleFunc),handlerMethodMap: make(map[string][]string),}r.routerGroups = append(r.routerGroups, routerGroup)return routerGroup
}// 给路由结构体添加一个添加路由功能的函数
// func (routerGroup *routerGroup) Add(name string, handleFunc HandleFunc) {
// 	routerGroup.handleFuncMap[name] = handleFunc
// }// 由于 ANY POST GET 都需要重复相同的逻辑代码，所以做一个提取操作
func (routerGroup *routerGroup) handleRequest(name string, method string, handleFunc HandleFunc) {if _, exist := routerGroup.handleFuncMap[name]; !exist {routerGroup.handleFuncMap[name] = make(map[string]HandleFunc)}if _, exist := routerGroup.handleFuncMap[name][method]; !exist {routerGroup.handleFuncMap[name][method] = handleFuncrouterGroup.handlerMethodMap[method] = append(routerGroup.handlerMethodMap[method], name)} else {panic("Under the same route, duplication is not allowed!!!")}
}// Any代表支持任意的请求方式
func (routerGroup *routerGroup) Any(name string, handleFunc HandleFunc) {routerGroup.handleRequest(name, ANY, handleFunc)
}// POST代表支持POST请求方式
func (routerGroup *routerGroup) Post(name string, handleFunc HandleFunc) {routerGroup.handleRequest(name, http.MethodPost, handleFunc)
}// GET代表支持GET请求方式
func (routerGroup *routerGroup) Get(name string, handleFunc HandleFunc) {routerGroup.handleRequest(name, http.MethodGet, handleFunc)
}// 只要实现 ServeHTTP 这个方法，就相当于实现了对应的 HTTP 处理器
// 结构体 Engine 实现了 ServeHTTP(w http.ResponseWriter, r *http.Request) 方法
// 所以它就自动实现了 http.Handler 接口，因此可以直接被用于 http.ListenAndServe
// Engine 实现了 ServeHTTP，它就是一个合法的 http.Handler，可以用 http.Handle 来绑定它到某个具体的路由路径上！
func (e *Engine) ServeHTTP(w http.ResponseWriter, r *http.Request) {// 在 Go 的 net/http 包中，r *http.Request 代表了客户端发来的 HTTP 请求对象。// 可以通过 r.Method 来获取这次请求使用的是什么方法（Method），例如：GET、POST、PUT、DELETE 等。if r.Method == http.MethodGet {fmt.Fprintf(w, "这是一个 GET 请求!!!")} else if r.Method == http.MethodPost {fmt.Fprintf(w, "这是一个 POST 请求!!!")} else {fmt.Fprintf(w, "这是一个其他类型的请求：%s", r.Method)}for _, group := range e.routerGroups {for name, methodHandleMap := range group.handleFuncMap {url := "/" + group.name + name//判断一下当前的url是否等于请求的url，即路由匹配if r.RequestURI == url {ctx := &Context{W: w, R: r}// 先判断当前请求路由是否支持任意请求方式的Anyif handle, exist := methodHandleMap[ANY]; exist {handle(ctx)return}// 不支持 Any，去该请求所对应的请求方式对应的 Map 里面去找是否有对应的路由if handle, exist := methodHandleMap[r.Method]; exist {handle(ctx)return}// 没找到对应的路由，说明该请求方式不允许w.WriteHeader(http.StatusMethodNotAllowed)fmt.Fprintf(w, "%s %s not allowed!!!\n", r.Method, r.RequestURI)return}}}w.WriteHeader(http.StatusNotFound)fmt.Fprintf(w, "%s %s not found!!!\n", r.Method, r.RequestURI)return
}// 定义一个引擎结构体
type Engine struct {router
}// 引擎结构体的初始化方法
func New() *Engine {return &Engine{router: router{},}
}// 引擎的启动方法
func (e *Engine) Run() {// for _, group := range e.routerGroups {// 	for name, value := range group.handleFuncMap {// 		http.HandleFunc("/"+group.name+name, value)// 	}// }// 把 e 这个http处理器绑定到对应路由下http.Handle("/", e)err := http.ListenAndServe(":3986", nil)if err != nil {log.Fatal(err)}
}

// main.gopackage mainimport ("fmt""net/http""github.com/ErizJ/ZJGo/zjgo"
)func main() {fmt.Println("Hello World!")// // 注册 HTTP 路由 /hello// http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {// 	fmt.Fprintf(w, "Hello Go!")// })// // 启动 HTTP 服务器// err := http.ListenAndServe("8111", nil)// if err != nil {// 	log.Fatal(err)// }engine := zjgo.New()g1 := engine.Group("user")g1.Get("/hello", func(ctx *zjgo.Context) {fmt.Fprintf(ctx.W, http.MethodGet+" Hello Go!——user/hello")})// 浏览器地址栏输入的都是 GET 请求// 需要用 curl 或 Postman 来发一个真正的 POST 请求，才会命中 Post handlerg1.Post("/info", func(ctx *zjgo.Context) {fmt.Fprintf(ctx.W, http.MethodPost+" Hello Go!——user/info——POST")})g1.Get("/info", func(ctx *zjgo.Context) {fmt.Fprintf(ctx.W, http.MethodGet+" Hello Go!——user/info——GET")})// 只要路由匹配，就会执行对应的处理函数g1.Any("/any", func(ctx *zjgo.Context) {fmt.Fprintf(ctx.W, " Hello Go!——user/any")})// g2 := engine.Group("order")// g2.Add("/hello", func(w http.ResponseWriter, r *http.Request) {// 	fmt.Fprintf(w, "Hello Go!——order/hello")// })// g2.Add("/info", func(w http.ResponseWriter, r *http.Request) {// 	fmt.Fprintf(w, "Hello Go!——order/info")// })fmt.Println("Starting...")engine.Run()}

前缀树

  • 前面的实现，我们只是实现了静态路由，不能实现更为复杂的需求，比如 /user/get/:id 这种才有参数的。
  • 带有参数的路由路径，成为动态路由。
  • 除了带有参数的，一般情况下我们还希望有更多支持，比如希望支持通配符 **，比如 /static/**，可以匹配 /static/vue.js，/static/css/index.css 这些。
// 简单的前缀树实现代码思路type Trie struct {next    [26]*Trieend     bool
}func Constructor() Trie {myTrie := Trie{}return myTrie
}func (this *Trie) Insert(word string) {if this.Search(word) {return}node := thisfor _, ch := range word {if node.next[ch-'a'] == nil {node.next[ch-'a'] = &Trie{}}node = node.next[ch-'a']}node.end = true
}func (this *Trie) Search(word string) bool {node := this.search(word)return node != nil && (*node).end
}func (this *Trie) search(word string) *Trie {node := thisfor _, ch := range word {if node.next[ch-'a'] == nil {return nil}node = node.next[ch-'a']}return node
}func (this *Trie) StartsWith(prefix string) bool {node := this.search(prefix)return node != nil
}

在这里插入图片描述

// tree.gopackage zjgoimport "strings"type TreeNode struct {name     string      // 用 '/' 分割路径后的每个路由名称children []*TreeNode // 子节点
}// Put path --> /user/get/:id
// PUT 一般用于“更新”
// :id 是一种路由参数（Path Parameter）占位符
// /user/get/123 会匹配 /user/get/:id，并提取出 id = 123
// /user/get/abc 会匹配 /user/get/:id，提取出 id = abc
func (t *TreeNode) Put(path string) {root := tstrs := strings.Split(path, "/")for index, name := range strs {// 忽略第一个斜杠前的那个空格if index == 0 {continue}isMatch := falsefor _, node := range t.children {if node.name == name {isMatch = truet = nodebreak}}if !isMatch {node := &TreeNode{name:     name,children: make([]*TreeNode, 0),}t.children = append(t.children, node)t = node}}t = root
}// Get path --> /user/get/1
// GET 一般用于“查”
func (t *TreeNode) Get(path string) *TreeNode {strs := strings.Split(path, "/")for index, name := range strs {// 忽略第一个斜杠前的那个空格if index == 0 {continue}isMatch := falsefor _, node := range t.children {if node.name == name || node.name == "*" || strings.Contains(node.name, ":") {isMatch = truet = nodeif index == len(strs)-1 {return node}break}}if !isMatch {for _, node := range t.children {// /user/**// /user/get/userInfo// /user/aa/bbif node.name == "**" {// only onereturn node}}}}return nil
}// test_tree.go
package zjgoimport ("fmt""testing"
)func TestTreeNode(t *testing.T) {root := &TreeNode{name: "/", children: make([]*TreeNode, 0)}root.Put("/user/get/:id")root.Put("/user/info/hello")root.Put("/user/create/aaa")root.Put("/order/get/aaa")node := root.Get("/user/get/1")fmt.Println(node)node = root.Get("/user/info/hello")fmt.Println(node)node = root.Get("/user/create/aaa")fmt.Println(node)node = root.Get("/order/get/aaa")fmt.Println(node)
}=== RUN   TestTreeNode
&{:id []}
&{hello []}
&{aaa []}
&{aaa []}
--- PASS: TestTreeNode (0.00s)
PASS
ok      github.com/ErizJ/ZJGo/zjgo      (cached)

应用前缀树

// utils.gopackage zjgoimport "strings"// 分割字符串，只留下去掉了路由组名字后的字路由的路径
func SubStringLast(name string, groupName string) string {if index := strings.Index(name, groupName); index < 0 {return ""} else {return name[index+len(groupName):]}
}

// tree.gopackage zjgoimport "strings"type TreeNode struct {name       string      // 用 '/' 分割路径后的每个路由名称children   []*TreeNode // 子节点routerName string      // 前缀树到当前节点所走过的路径isEnd      bool        // 对bug的修正，防止 /user/hello/xx 这样的路由 /user/hello 访问这个路径也一样能从前缀树查找出来，并不会报404
}// Put path --> /user/get/:id
// PUT 一般用于“更新”
// :id 是一种路由参数（Path Parameter）占位符
// /user/get/123 会匹配 /user/get/:id，并提取出 id = 123
// /user/get/abc 会匹配 /user/get/:id，提取出 id = abc
func (t *TreeNode) Put(path string) {strs := strings.Split(path, "/")for index, name := range strs {// 忽略第一个斜杠前的那个空格if index == 0 {continue}isMatch := falsefor _, node := range t.children {if node.name == name {isMatch = truet = nodebreak}}if !isMatch {node := &TreeNode{name:     name,children: make([]*TreeNode, 0),isEnd:    index == len(strs)-1,}t.children = append(t.children, node)t = node}}t.isEnd = true
}// Get path --> /user/get/1
// GET 一般用于“查”
func (t *TreeNode) Get(path string) *TreeNode {strs := strings.Split(path, "/")routerName := ""for index, name := range strs {// 忽略第一个斜杠前的那个空格if index == 0 {continue}isMatch := falsefor _, node := range t.children {if node.name == name || node.name == "*" || strings.Contains(node.name, ":") {isMatch = truerouterName += "/" + node.namenode.routerName = routerNamet = nodeif index == len(strs)-1 {return node}break}}if !isMatch {for _, node := range t.children {// /user/**// /user/get/userInfo// /user/aa/bbif node.name == "**" {// only onerouterName += "/" + node.namenode.routerName = routerNamereturn node}}}}return nil
}

// zj.gopackage zjgoimport ("fmt""log""net/http"
)const ANY = "ANY"// 定义处理响应函数
type HandleFunc func(ctx *Context)// 抽象出路由的概念
type routerGroup struct {name             string                           // 组名handleFuncMap    map[string]map[string]HandleFunc // 映射关系应该由每个路由组去维护handlerMethodMap map[string][]string              // 记录GET，POST等请求方式所记录的路由，实现对同一路由不同请求方式的支持TreeNode         *TreeNode                        // 记录该路由组下的路由前缀树
}// 定义路由结构体
type router struct {routerGroups []*routerGroup // 路由下面应该维护着不同的组
}// 添加路由组
func (r *router) Group(name string) *routerGroup {routerGroup := &routerGroup{name:             name,handleFuncMap:    make(map[string]map[string]HandleFunc),handlerMethodMap: make(map[string][]string),TreeNode:         &TreeNode{name: "/", children: make([]*TreeNode, 0)},}r.routerGroups = append(r.routerGroups, routerGroup)return routerGroup
}// 给路由结构体添加一个添加路由功能的函数
// func (routerGroup *routerGroup) Add(name string, handleFunc HandleFunc) {
// 	routerGroup.handleFuncMap[name] = handleFunc
// }// 由于 ANY POST GET 都需要重复相同的逻辑代码，所以做一个提取操作
func (routerGroup *routerGroup) handleRequest(name string, method string, handleFunc HandleFunc) {if _, exist := routerGroup.handleFuncMap[name]; !exist {routerGroup.handleFuncMap[name] = make(map[string]HandleFunc)}if _, exist := routerGroup.handleFuncMap[name][method]; !exist {routerGroup.handleFuncMap[name][method] = handleFuncrouterGroup.handlerMethodMap[method] = append(routerGroup.handlerMethodMap[method], name)} else {panic("Under the same route, duplication is not allowed!!!")}routerGroup.TreeNode.Put(name)
}// Any代表支持任意的请求方式
func (routerGroup *routerGroup) Any(name string, handleFunc HandleFunc) {routerGroup.handleRequest(name, ANY, handleFunc)
}// POST代表支持POST请求方式
func (routerGroup *routerGroup) Post(name string, handleFunc HandleFunc) {routerGroup.handleRequest(name, http.MethodPost, handleFunc)
}// GET代表支持GET请求方式
func (routerGroup *routerGroup) Get(name string, handleFunc HandleFunc) {routerGroup.handleRequest(name, http.MethodGet, handleFunc)
}// 只要实现 ServeHTTP 这个方法，就相当于实现了对应的 HTTP 处理器
// 结构体 Engine 实现了 ServeHTTP(w http.ResponseWriter, r *http.Request) 方法
// 所以它就自动实现了 http.Handler 接口，因此可以直接被用于 http.ListenAndServe
// Engine 实现了 ServeHTTP，它就是一个合法的 http.Handler，可以用 http.Handle 来绑定它到某个具体的路由路径上！
func (e *Engine) ServeHTTP(w http.ResponseWriter, r *http.Request) {// 在 Go 的 net/http 包中，r *http.Request 代表了客户端发来的 HTTP 请求对象。// 可以通过 r.Method 来获取这次请求使用的是什么方法（Method），例如：GET、POST、PUT、DELETE 等。if r.Method == http.MethodGet {fmt.Fprintf(w, "这是一个 GET 请求!!! ")} else if r.Method == http.MethodPost {fmt.Fprintf(w, "这是一个 POST 请求!!! ")} else {fmt.Fprintf(w, "这是一个其他类型的请求：%s!!! ", r.Method)}for _, group := range e.routerGroups {routerName := SubStringLast(r.RequestURI, "/"+group.name)if node := group.TreeNode.Get(routerName); node != nil && node.isEnd {// 路由匹配上了ctx := &Context{W: w, R: r}// 先判断当前请求路由是否支持任意请求方式的Anyif handle, exist := group.handleFuncMap[node.routerName][ANY]; exist {handle(ctx)return}// 不支持 Any，去该请求所对应的请求方式对应的 Map 里面去找是否有对应的路由if handle, exist := group.handleFuncMap[node.routerName][r.Method]; exist {handle(ctx)return}// 没找到对应的路由，说明该请求方式不允许w.WriteHeader(http.StatusMethodNotAllowed)fmt.Fprintf(w, "%s %s not allowed!!!\n", r.Method, r.RequestURI)return}// for name, methodHandleMap := range group.handleFuncMap {// 	url := "/" + group.name + name// 	//判断一下当前的url是否等于请求的url，即路由匹配// 	if r.RequestURI == url {// 	}// }}w.WriteHeader(http.StatusNotFound)fmt.Fprintf(w, "%s %s not found!!!\n", r.Method, r.RequestURI)return
}// 定义一个引擎结构体
type Engine struct {router
}// 引擎结构体的初始化方法
func New() *Engine {return &Engine{router: router{},}
}// 引擎的启动方法
func (e *Engine) Run() {// for _, group := range e.routerGroups {// 	for name, value := range group.handleFuncMap {// 		http.HandleFunc("/"+group.name+name, value)// 	}// }// 把 e 这个http处理器绑定到对应路由下http.Handle("/", e)err := http.ListenAndServe(":3986", nil)if err != nil {log.Fatal(err)}
}

// main.gopackage mainimport ("fmt""net/http""github.com/ErizJ/ZJGo/zjgo"
)func main() {fmt.Println("Hello World!")// // 注册 HTTP 路由 /hello// http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {// 	fmt.Fprintf(w, "Hello Go!")// })// // 启动 HTTP 服务器// err := http.ListenAndServe("8111", nil)// if err != nil {// 	log.Fatal(err)// }engine := zjgo.New()g1 := engine.Group("user")g1.Get("/hello", func(ctx *zjgo.Context) {fmt.Fprintf(ctx.W, http.MethodGet+" Hello Go!——user/hello")})// 浏览器地址栏输入的都是 GET 请求// 需要用 curl 或 Postman 来发一个真正的 POST 请求，才会命中 Post handlerg1.Post("/info", func(ctx *zjgo.Context) {fmt.Fprintf(ctx.W, http.MethodPost+" Hello Go!——user/info——POST")})g1.Get("/info", func(ctx *zjgo.Context) {fmt.Fprintf(ctx.W, http.MethodGet+" Hello Go!——user/info——GET")})g1.Get("/get/:id", func(ctx *zjgo.Context) {fmt.Fprintf(ctx.W, http.MethodGet+" Hello Go!——user/get/:id——GET")})g1.Get("/isEnd/get", func(ctx *zjgo.Context) {fmt.Fprintf(ctx.W, http.MethodGet+" Hello Go!——user/isEnd/get——GET")})// 只要路由匹配，就会执行对应的处理函数g1.Any("/any", func(ctx *zjgo.Context) {fmt.Fprintf(ctx.W, " Hello Go!——user/any")})// g2 := engine.Group("order")// g2.Add("/hello", func(w http.ResponseWriter, r *http.Request) {// 	fmt.Fprintf(w, "Hello Go!——order/hello")// })// g2.Add("/info", func(w http.ResponseWriter, r *http.Request) {// 	fmt.Fprintf(w, "Hello Go!——order/info")// })fmt.Println("Starting...")engine.Run()}

完善路由代码

// zj.gopackage zjgoimport ("fmt""log""net/http"
)const ANY = "ANY"// 定义处理响应函数
type HandleFunc func(ctx *Context)// 抽象出路由的概念
type routerGroup struct {name             string                           // 组名handleFuncMap    map[string]map[string]HandleFunc // 映射关系应该由每个路由组去维护handlerMethodMap map[string][]string              // 记录GET，POST等请求方式所记录的路由，实现对同一路由不同请求方式的支持TreeNode         *TreeNode                        // 记录该路由组下的路由前缀树
}// 定义路由结构体
type router struct {routerGroups []*routerGroup // 路由下面应该维护着不同的组
}// 添加路由组
func (r *router) Group(name string) *routerGroup {routerGroup := &routerGroup{name:             name,handleFuncMap:    make(map[string]map[string]HandleFunc),handlerMethodMap: make(map[string][]string),TreeNode:         &TreeNode{name: "/", children: make([]*TreeNode, 0)},}r.routerGroups = append(r.routerGroups, routerGroup)return routerGroup
}// 给路由结构体添加一个添加路由功能的函数
// func (routerGroup *routerGroup) Add(name string, handleFunc HandleFunc) {
// 	routerGroup.handleFuncMap[name] = handleFunc
// }// 由于 ANY POST GET 都需要重复相同的逻辑代码，所以做一个提取操作
func (routerGroup *routerGroup) handleRequest(name string, method string, handleFunc HandleFunc) {if _, exist := routerGroup.handleFuncMap[name]; !exist {routerGroup.handleFuncMap[name] = make(map[string]HandleFunc)}if _, exist := routerGroup.handleFuncMap[name][method]; !exist {routerGroup.handleFuncMap[name][method] = handleFuncrouterGroup.handlerMethodMap[method] = append(routerGroup.handlerMethodMap[method], name)} else {panic("Under the same route, duplication is not allowed!!!")}routerGroup.TreeNode.Put(name)
}// Any代表支持任意的请求方式
func (routerGroup *routerGroup) Any(name string, handleFunc HandleFunc) {routerGroup.handleRequest(name, ANY, handleFunc)
}// POST代表支持POST请求方式
func (routerGroup *routerGroup) Post(name string, handleFunc HandleFunc) {routerGroup.handleRequest(name, http.MethodPost, handleFunc)
}// GET代表支持GET请求方式
func (routerGroup *routerGroup) Get(name string, handleFunc HandleFunc) {routerGroup.handleRequest(name, http.MethodGet, handleFunc)
}// DELETE代表支持DELETE请求方式
func (routerGroup *routerGroup) Delete(name string, handleFunc HandleFunc) {routerGroup.handleRequest(name, http.MethodDelete, handleFunc)
}// PUT代表支持PUT请求方式
func (routerGroup *routerGroup) Put(name string, handleFunc HandleFunc) {routerGroup.handleRequest(name, http.MethodPut, handleFunc)
}// PATCH代表支持PATCH请求方式
func (routerGroup *routerGroup) Patch(name string, handleFunc HandleFunc) {routerGroup.handleRequest(name, http.MethodPatch, handleFunc)
}// 只要实现 ServeHTTP 这个方法，就相当于实现了对应的 HTTP 处理器
// 结构体 Engine 实现了 ServeHTTP(w http.ResponseWriter, r *http.Request) 方法
// 所以它就自动实现了 http.Handler 接口，因此可以直接被用于 http.ListenAndServe
// Engine 实现了 ServeHTTP，它就是一个合法的 http.Handler，可以用 http.Handle 来绑定它到某个具体的路由路径上！
func (e *Engine) ServeHTTP(w http.ResponseWriter, r *http.Request) {// 在 Go 的 net/http 包中，r *http.Request 代表了客户端发来的 HTTP 请求对象。// 可以通过 r.Method 来获取这次请求使用的是什么方法（Method），例如：GET、POST、PUT、DELETE 等。if r.Method == http.MethodGet {fmt.Fprintf(w, "这是一个 GET 请求!!! ")} else if r.Method == http.MethodPost {fmt.Fprintf(w, "这是一个 POST 请求!!! ")} else {fmt.Fprintf(w, "这是一个其他类型的请求：%s!!! ", r.Method)}for _, group := range e.routerGroups {routerName := SubStringLast(r.RequestURI, "/"+group.name)if node := group.TreeNode.Get(routerName); node != nil && node.isEnd {// 路由匹配上了ctx := &Context{W: w, R: r}// 先判断当前请求路由是否支持任意请求方式的Anyif handle, exist := group.handleFuncMap[node.routerName][ANY]; exist {handle(ctx)return}// 不支持 Any，去该请求所对应的请求方式对应的 Map 里面去找是否有对应的路由if handle, exist := group.handleFuncMap[node.routerName][r.Method]; exist {handle(ctx)return}// 没找到对应的路由，说明该请求方式不允许w.WriteHeader(http.StatusMethodNotAllowed)fmt.Fprintf(w, "%s %s not allowed!!!\n", r.Method, r.RequestURI)return}// for name, methodHandleMap := range group.handleFuncMap {// 	url := "/" + group.name + name// 	//判断一下当前的url是否等于请求的url，即路由匹配// 	if r.RequestURI == url {// 	}// }}w.WriteHeader(http.StatusNotFound)fmt.Fprintf(w, "%s %s not found!!!\n", r.Method, r.RequestURI)return
}// 定义一个引擎结构体
type Engine struct {router
}// 引擎结构体的初始化方法
func New() *Engine {return &Engine{router: router{},}
}// 引擎的启动方法
func (e *Engine) Run() {// for _, group := range e.routerGroups {// 	for name, value := range group.handleFuncMap {// 		http.HandleFunc("/"+group.name+name, value)// 	}// }// 把 e 这个http处理器绑定到对应路由下http.Handle("/", e)err := http.ListenAndServe(":3986", nil)if err != nil {log.Fatal(err)}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/pingmian/76154.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

zabbix中通过模板实现自动发现对tcp端口批量监控

zabbix中通过模板实现自动发现对tcp端口批量监控

主要为了解决监控大量端口&#xff0c;避免繁琐的重复操作监控项和触发器 诸位~ 仅供参考哈 自动发现监控参考地址: https://blog.csdn.net/qq_37510195/article/details/130893655 模板 首先创建一个模板 自定义名称和群组 创建自动发现规则 模板——自动发现——创建发现规则…
阅读更多...
Mysql备忘记录

Mysql备忘记录

1、简介 Mysql操作经常忘记命令&#xff0c;本文将持续记录Mysql一些常用操作。 2、常见问题 2.1、忘记密码 # 1、首先停止Mysql服务 systemctl stop mysqld # windows 从任务管理器里面停 # 2、更改配置文件 my.cnf (windows是 ini文件) vim /etc/my.cnf 在[mysqld]下面添…
阅读更多...
【蓝桥杯】15届JAVA研究生组F回文字符串

【蓝桥杯】15届JAVA研究生组F回文字符串

一、思路 1.这题去年考的时候想的是使用全排列进行尝试&#xff0c;实际不用这么麻烦&#xff0c;只用找到第一个和最后一个非特殊字符串的位置&#xff0c;然后分别向内检查是否对称&#xff0c;向外检查是否对称直到左指针小于0(可以通过添加使其对称) 2.至于如何找到第一个…
阅读更多...
X 进制减法

X 进制减法

题目链接&#xff1a; 思路&#xff1a; X进制数321怎么转换为十进制数为65&#xff1f;如下图&#xff1a; ①题目要求我们求 A - B 的最小值&#xff0c;对第 i 位&#xff0c;要求 A[i] - B[i] 的最小值&#xff0c;当进制越小的时候差值越小&#xff0c;但进制要比 max&…
阅读更多...
java线程安全-单例模式-线程通信

java线程安全-单例模式-线程通信

首先看看单例模式的写法 首先我们先来回顾一下饿汉式单例模式&#xff1a; class Singleton{private static Singleton singletonnew Singleton();private Singleton(){}public static Singleton getInstrance(){return singleton;} } public class Test{public static void …
阅读更多...
大数据技术之SPARK

大数据技术之SPARK

Spark Core 什么是 RDD 代码中是一个抽象类&#xff0c;它代表一个弹性的、不可变、可分区、里面的元素可并行计算的集合 弹性 存储的弹性&#xff1a;内存与磁盘的自动切换&#xff1b; 容错的弹性&#xff1a;数据丢失可以自动恢复&#xff1b; 计算的弹性&#xff1a;…
阅读更多...
Go 语言范围 (Range)

Go 语言范围 (Range)

Go 语言范围 (Range) Go 语言是一种静态强类型、编译型、并发型编程语言&#xff0c;由 Google 开发。它的简洁性和高效性使其成为众多开发者的首选。在 Go 语言中&#xff0c;range 是一个非常有用的关键字&#xff0c;用于遍历数组、切片、字符串以及通道&#xff08;channe…
阅读更多...
VUE中数据绑定之OptionAPI

VUE中数据绑定之OptionAPI

<template> <div> 姓名：<input v-model="userName" /> {{ userName }} <br /> 薪水：<input type="number" v-model="salary" /> <br /> <button v-on:click="submit">提交</button>…
阅读更多...
react动态路由

react动态路由

框架的权限控制&#xff08;在config.ts中配置&#xff09; export default {access: {}, }; 权限配置文件&#xff08;access.ts&#xff09; 新建 src/access.ts &#xff0c;在该文件中 export default 一个函数&#xff0c;定义用户拥有的权限 该文件需要返回一个 functi…
阅读更多...
Android里面如何优化xml布局

Android里面如何优化xml布局

在 Android 开发中&#xff0c;以下是系统化的优化方案&#xff0c;从基础到高级分层解析&#xff1a; 一、基础优化策略 1. 减少布局层级 问题&#xff1a;每增加一层布局&#xff0c;测量/布局时间增加 1-2ms 解决方案&#xff1a; <!-- 避免嵌套 --> <LinearLayo…
阅读更多...
基于STM32、HAL库的IP6525S快充协议芯片简介及驱动程序设计

基于STM32、HAL库的IP6525S快充协议芯片简介及驱动程序设计

一、简介： IP6525S是一款高性能的同步降压DC-DC转换器芯片，具有以下特点： 输入电压范围：4.5V至32V 输出电压范围：0.8V至30V 最大输出电流：5A 效率高达95% 可编程开关频率（100kHz-1MHz） 支持PWM和PFM模式 内置过流保护、过温保护等功能 该芯片常用于工业控制、通信设备…
阅读更多...
二分算法的入门笔记

二分算法的入门笔记

二分查找 使用前提&#xff1a;有序。可理解为枚举的一种技巧。时间复杂度&#xff1a; l o g ( n ) log(n) log(n) 基础模版代码 使用时根据情景进行相应的变化。注意跳出条件and分支处理方式and返回答案&#xff0c;三者之间的配合&#xff0c;不要进入死循环。可以在模拟…
阅读更多...
轻量级Java跨包调用(完全解耦)

轻量级Java跨包调用(完全解耦)

Java函数式命令模式 轻量级跨包调用解耦方案&#xff0c;让跨包调用就像调用本地接口那样简单。适用与具有公共依赖的两个jar包&#xff0c;但是又不想相互引入对方作为依赖。 函数式命令模式&#xff0c;很好地实现了跨包调用解耦的目标&#xff0c;并且通过泛型JSON动态转换保…
阅读更多...
离散数学问题集--问题5.9

离散数学问题集--问题5.9

问题 5.9 综合了计算机组成原理、数字逻辑和离散数学中的关键概念&#xff0c;旨在帮助学生理解二进制算术运算的硬件实现、逻辑门与算术运算的关系&#xff0c;以及如何使用数学方法来验证数字系统的正确性。它强调了从规范到实现再到验证的完整过程。 思想 函数抽象&#xf…
阅读更多...
OpenLayers：海量图形渲染之矢量切片

OpenLayers：海量图形渲染之矢量切片

最近由于在工作中涉及到了海量图形渲染的问题&#xff0c;因此我开始研究相关的解决方案。在咨询了许多朋友之后发现矢量切片似乎是行业内最常用的一种解决方案&#xff0c;于是我便开始研究它该如何使用。 一、什么是矢量切片 矢量切片按照我的理解就是用栅格切片的方式把矢…
阅读更多...
神经网络入门—自定义网络

神经网络入门—自定义网络

网络模型 定义一个两层网络 import torch import torch.nn as nn import torch.optim as optim import torch.nn.functional as F# 定义神经网络模型 class Net(nn.Module):def __init__(self, init_x0.0):super().__init__()self.fc1 nn.Linear(1, 10)self.fc2 nn.Linear(…
阅读更多...
无人机装调与测试

无人机装调与测试

文章目录 前言一、无人机基本常识/预备知识&#xff08;一&#xff09;无人机飞行原理无人机硬件组成/各组件作用1.飞控2.GPS3.接收机4.电流计5.电调6.电机7.电池8.螺旋桨9.UBEC&#xff08;稳压模块&#xff09; &#xff08;二&#xff09;飞控硬件简介&#xff08;三&#x…
阅读更多...
2024年-全国大学生数学建模竞赛(CUMCM)试题速浏、分类及浅析

2024年-全国大学生数学建模竞赛(CUMCM)试题速浏、分类及浅析

2024年-全国大学生数学建模竞赛(CUMCM)试题速浏、分类及浅析 全国大学生数学建模竞赛&#xff08;China Undergraduate Mathematical Contest in Modeling&#xff09;是国家教委高教司和中国工业与应用数学学会共同主办的面向全国大学生的群众性科技活动&#xff0c;目的在于激…
阅读更多...
Linux入门指南：从零开始探索开源世界

Linux入门指南：从零开始探索开源世界

&#x1f680; 前言 大家好&#xff01;今天我们来聊一聊Linux这个神奇的操作系统~ &#x1f916; 很多小伙伴可能觉得Linux是程序员专属&#xff0c;其实它早已渗透到我们生活的各个角落&#xff01;本文将带你了解Linux的诞生故事、发行版选择攻略、应用领域&#xff0c;还有…
阅读更多...
记录vscode连接不上wsl子系统下ubuntu18.04问题解决方法

记录vscode连接不上wsl子系统下ubuntu18.04问题解决方法

记录vscode连接不上wsl子系统下ubuntu18.04问题解决方法 报错内容尝试第一次解决方法尝试第二次解决方法注意事项参考连接 报错内容 Unable to download server on client side: Error: Request downloadRequest failed unexpectedly without providing any details… Will tr…
阅读更多...
最新文章

Copyright @ 2022~2023