手把手和你一起实现一个Web框架实战——EzWeb框架(三)[Go语言笔记]Go项目实战

代码仓库：

github

gitee

中文注释，非常详尽，可以配合食用

本篇代码，请选择demo3

这一篇文章我们进行动态路由解析功能的设计，

如xxx/:id/xxx,xxx/xxx/*mrxuexi.md

实现这处理这两类模式的简单小功能，实现起来不简单，原有的map[path]HandlerFunc数据结构只能存储静态路由与方法对应，而无法处理动态路由，我们使用一种树结构来进行路由表的存储。

一、设计这个数据结构

1、节点结构体设计

type node struct {

	path  string 	/* 需要匹配的整体路由 */

	part     string 	/* 路由中的一部分，例如 :lang */

	children []*node 	/* 存储子节点们 */

	isBlurry   bool 	/* 如果模糊匹配则为true */

}

2、一个传入part后，通过遍历该节点的全部子节点们，找到拥有相同part的子节点的方法（返回首个）

func (n *node) matchChild(part string) *node {

   //遍历子节点们，对比子节点的part和part是否相同，是或者遍历到的子节点支持模糊匹配则返回该子节点

   for _, child := range n.children {

      if child.part == part || child.isBlurry {

         return child

      }

   }

   return nil

}

3、一个返回匹配的子节点们的方法（返回全部，包括动态路由的存储的部分）

func (n *node) matchChildren(part string) []*node {

   nodes := make([]*node, 0)

   //遍历选择满足条件的子节点，加入到nodes中，然后返回

   for _, child := range n.children {

      if child.part == part || child.isBlurry {

         nodes = append(nodes, child)

      }

   }

   return nodes

}

4、构造路由表的插入方法，parts[]存储的是根据路由path分解出来的part们，我们拿到part则取检索子节点是否存在这个part，不存在则新建一个子节点，不停的在这个树上深入，直到遍历完我们的全部part，然后递归返回。

//插入方法，用一个递归实现，找匹配的路径直到找不到匹配当前part的节点，新建

func (n *node) insert(path string, parts []string, height int)  {

   //如果遍历到底部了，则将我们的path存入节点，开始返回。递归的归来条件。

   if len(parts) == height{

      n.path = path

      return

   }

   //获取这一节的part，并进行搜索

   part := parts[height]

   child := n.matchChild(part)

   //若没有搜索到匹配的子节点，则根据目前的part构造一个子节点

   if child == nil {

       child = &node{

         part: part,

         isBlurry: part[0] == ':' || part[0] == '*',

       }

       n.children = append(n.children, child)

   }

   child.insert(path, parts, height+1)

}

5、我们带着part们一个个在存储路由表的树中查找，我们拿到某个节点的全部子节点，找到满足part相同或者isBlurry:true的节点。通过递归再往深处挖，挖下去直到发现某一级节点的子节点们，没有对应匹配的part，又返回来，再去上一层的子节点看，这就是一个深度优先遍历的情况。

//搜索方法

func (n *node) search(parts []string, height int) *node {

	//如果节点到头，或者存在*前缀的节点，开始返回

	if len(parts) == height || strings.HasPrefix(n.part,"*") {

		//如果此时遍历到的n没有存储对应的path，说明未到目标最底层，则返回空

		if n.path == "" {

			return nil

		}

		return n

	}

	//搜索找到满足part的子节点们放入children

	part := parts[height]

	children := n.matchChildren(part)

	//接着遍历子节点们，递归调用获得下一级的子节点们，要走到头的同时，找到了对应的节点，才返回最终我们找到的result

	//这里为什么要遍历子节点们进行深入搜索，因为它还存在满足isBlurry:true的节点，我们也需要在其中深入搜索。

	for _, child := range children {

		result := child.search(parts, height+1)

		if result != nil {

			//返回满足要求的节点

			return result

		}

	}

	return nil

}

二、更新路由表的存储结构和处理方法

1、其中roots中的第一层是roots[method]*node

type router struct {

   //用于存储相关方法

   handlers map[string]HandlerFunc

   //用于存储每种请求方式的树的根节点

   roots map[string]*node

}

2、设计一个parsePath方法，对外部传入的路由根据"/"进行分割，存入parts

// parsePath 用于处理传入的url，先将其分开存储到parts中，当然出现*前缀的部分就可以结束

func parsePath(path string) []string {

   vs := strings.Split(path, "/")

   parts := make([]string, 0)

   for _, v := range vs {

      if v != "" {

         parts = append(parts, v)

         if v[0] == '*' {

            break

         }

      }

   }

   return parts

}

3、router 中 addRoute 方法，在 handlers map[string]HandlerFunc 中存入路由对应处理方法，进行路由注册。存入形式为例如：{ "GET-/index" : 定义的处理方法 }

注意这里的path使我们用来构造路由表要存入的目标path

// router 中 addRoute 方法，在 handlers map[string]HandlerFunc 中存入路由对应处理方法

//存入形式为例如：{ "GET-/index" : 定义的处理方法 }

func (r *router) addRoute(method string, path string, handler HandlerFunc)  {

	parts := parsePath(path)

	log.Printf("Route %4s  -  %s",method,path)

	key := method + "-" + path

	_, ok := r.roots[method]

	//roots中不存在对应的方法入口则注册相应方法入口

	if !ok {

		r.roots[method] = &node{}

	}

	//调用路由表插入方法，在该数据结构中插入该路由

	r.roots[method].insert(path, parts, 0)

	//把method-path作为key，以及handler方法作为value注入数据结构

	r.handlers[key] = handler

}

4、做一个getRoute方法，进入到对应路由树，找到我们的路由，通过哈希表存入处理动态路由拿到param和找到的*node一起返回。

注意代码中的n.path是我们注册在路由表中的路由，path是外部传入的！

func (r *router) getRoute(method string, path string) (*node, map[string]string) {

   searchParts := parsePath(path)

   params := make(map[string]string)

   root, ok := r.roots[method]

   if !ok {

      return nil, nil

   }

   n := root.search(searchParts, 0)//传入全部路径的字符串数组，寻找到最后对应节点

   if n != nil {

      parts := parsePath(n.path) //n.path包含了完整的路由

      for i, part := range parts {//遍历这一条路径

         //拿到:的参数，存入params，方法中的part作为key，外面传入的path中的数据作为value存入

         if part[0] == ':' {

            params[part[1:]] = searchParts[i]

         }

         //拿到*，此时路由表中的存入的part作为key,外面传入的path中的数据作为value传入params，之后也再没有了

         if part[0] == '*' && len(part) > 1{

            params[part[1:]] = strings.Join(searchParts[i:],"/")

            break

         }

      }

      return n, params

   }

   return nil, nil

}

5.同时我们的hanle方法和上一篇文章不同的是，不是直接拿外部传入的path直接在 handlers map[string]HandlerFunc找对应的方法，因为我们外部传入的path是动态的。我们是先通过getRoute方法拿到参数和对应的找到存储节点，用这个节点中存储的path（它是静态的，是我们之前注入的），再在 handlers map[string]HandlerFunc找到对应的方法。

//根据context中存储的 c.Method 和 c.Path 拿到对应的处理方法，进行执行，如果拿到的路由没有注册，则返回404

func (r *router) handle(c *Context)  {

   //获取匹配到的节点，同时也拿到两类动态路由中参数

   n, params := r.getRoute(c.Method, c.Path)

   if n != nil {

      c.Params = params

      //拿目的节点中的path做key来找handlers

      key := c.Method + "-" + n.path

      r.handlers[key](c)

   }else {

      c.String(http.StatusNotFound,"404 NOT FOUND")

   }

}

三、Context变更

1、修改Context结构体，构造Params来存放处理动态路由拿到的参数

// Context 结构体，内部封装了 http.ResponseWriter, *http.Request

type Context struct {

   Writer http.ResponseWriter

   Req *http.Request

   //请求的信息，包括路由和方法

   Path string

   Method string

   Params map[string]string /*用于存储外面拿到的参数 ":xxx" or "*xxx" */

   //响应的状态码

   StatusCode int

}

2、设计Param方法，拿到处理动态路由的获取参数

// Param 是c的Param的value的获取方法

func (c *Context) Param(key string) string {

   value, _ := c.Params[key]

   return value

}

随便做个测试:

/*

@Time : 2021/8/16 下午4:01

@Author : mrxuexi

@File : main

@Software: GoLand

*/

package main

import (

	"Ez"

	"net/http"

)

func main() {

	r := Ez.New()

	r.POST("/hello/:id/*filepath", func(c *Ez.Context) {

		c.JSON(http.StatusOK,Ez.H{

			"name" : c.PostForm("name"),

			"age" : c.PostForm("age"),

			"id" : c.Param("id"),

			"filepath" : c.Param("filepath"),

		})

	})

	r.Run(":9090")

}

成功！

参考：

[1]: https://github.com/geektutu/7days-golang/tree/master/gee-web ""gee""

[2]: https://github.com/gin-gonic/gin ""gin""