Gee微框架学习记录(第五天)

type {
    // Group结构体
    RouterGroup struct {
        // 当前路由前缀，用于区分分组
        prefix      string
        // 组级别中间件
        middlewares []HandlerFunc // support middleware
        // 类似树结构，父节点
        parent      *RouterGroup  // support nesting
        // 设定Engine，所有Group都应该指向同一个Engine
        engine      *Engine       // all groups share a Engine instance
	}
    // Engine结构体
    Engine struct {
        // 继承来自RouterGroup的参数，共享内存，Engine是最顶层Group
		*RouterGroup
        // router 路由树
		router        *router
		// 存储groups数组，group不可能只有一个
         groups        []*RouterGroup // store all groups
	}
}

type Context struct {
	// origin objects
	Writer http.ResponseWriter
	Req    *http.Request
	// request info
	Path   string
	Method string
	Params map[string]string
	// response info
	StatusCode int
	// middleware
    // 中间件需要参数 
	handlers []HandlerFunc
	index    int
}

// 初始化修改
func newContext(w http.ResponseWriter, req *http.Request) *Context {
	return &Context{
		Path:   req.URL.Path,
		Method: req.Method,
		Req:    req,
		Writer: w,
		// 中间件index 为 -1
         index:  -1,
	}
}

// 处理中间件方法链
func (c *Context) Next() {
	c.index++
	s := len(c.handlers)
	for ; c.index < s; c.index++ {
		c.handlers[c.index](c)
	}
}

func Middleware1(c *Context) {
   fmt.Println("M1-Start")
   c.Next() // 有的调用，有的不调用
   fmt.Println("M1-End")
}

func Middleware2(c *Context) {
   fmt.Println("M2-Start") // 这里故意不调用 Next()
   fmt.Println("M2-End")
}

func Middleware3(c *Context) {
   fmt.Println("M3-Start")
   c.Next()
   fmt.Println("M3-End")
}

// Use is defined to add middleware to the group
// 对组添加定义的中间件
func (group *RouterGroup) Use(middlewares ...HandlerFunc) {
	group.middlewares = append(group.middlewares, middlewares...)
}

// 增加中间件调用处理
func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    // 暂存中间件数组
	var middlewares []HandlerFunc
	// 请求判断属于哪个组，根据前缀进行判断，添加对应的中间件到暂存数组
    for _, group := range engine.groups {
		if strings.HasPrefix(req.URL.Path, group.prefix) {
			middlewares = append(middlewares, group.middlewares...)
		}
	}
	c := newContext(w, req)
	// 给context中定义的handler中间件数组添加 组需要处理的中间件数组
    c.handlers = middlewares
	engine.router.handle(c)
}

// handle， 让当前handler加入中间件的处理链中执行。一种中间件
func (r *router) handle(c *Context) {
	n, params := r.getRoute(c.Method, c.Path)
	if n != nil {
		c.Params = params
		key := c.Method + "-" + n.pattern
		// 方法的处理逻辑追加到处理链中
		c.handlers = append(c.handlers, r.handlers[key])
	} else {
		c.handlers = append(c.handlers, func(c *Context) {
			c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)
		})
	}
	// 手动指定 Next()
	c.Next()
}

func Logger() HandlerFunc {
	return func(c *Context) {
		// Start timer
		t := time.Now()
		// Process request
		c.Next()
		// Calculate resolution time
		log.Printf("[%d] %s in %v", c.StatusCode, c.Req.RequestURI, time.Since(t))
	}
}

// 测试功能
func onlyForV2() gee.HandlerFunc {
	return func(c *gee.Context) {
		// Start timer
		t := time.Now()
		// if a server error occurred
		c.Fail(500, "Internal Server Error")
		// Calculate resolution time
		log.Printf("[%d] %s in %v for group v2", c.StatusCode, c.Req.RequestURI, time.Since(t))
	}
}

func main() {
	r := gee.New()
    // 中间件使用
	r.Use(gee.Logger()) // global midlleware
	r.GET("/", func(c *gee.Context) {
		c.HTML(http.StatusOK, "<h1>Hello Gee</h1>")
	})

	v2 := r.Group("/v2")
    // 中间件使用
	v2.Use(onlyForV2()) // v2 group middleware
	{
		v2.GET("/hello/:name", func(c *gee.Context) {
			// expect /hello/geektutu
			c.String(http.StatusOK, "hello %s, you're at %s\n", c.Param("name"), c.Path)
		})
	}

	r.Run(":9999")
}