Gee教程2.上下文Context

先来看看Gin框架的简单例子

func main() {engine := gin.Default()engine.GET("/", func(c *gin.Context) {c.String(http.StatusOK, "hello World!")})//监听并启动服务，默认 http://localhost:8080/engine.Run()
}//我们自己写的
func main() {engine := gee.New()engine.GET("/", func(w http.ResponseWriter, req *http.Request) {fmt.Fprintf(w, "URL.Path = %q\n", req.URL.Path)})engine.Run("localhost:10000")
}

对比我们自己写的，Hander方法的参数变成了*gin.Context。

那么这版的主要修改策略是：

• 将路由(Router)独立出来，方便之后增强。
• 设计上下文(Context)，封装 Request 和 Response ，并提供对 JSON、HTML 等返回类型的支持。

 设计Context

必要性

1.web服务，基本就是根据客户的请求*http.Request,构造回应客户的响应http.ResponseWriter。但是这两个对象提供的接口粒度比较细。比如要构造一个完整的响应，需要考虑消息头和消息体，而消息头包含了状态码，消息类型等。那每次构造回复，都要写这些设置的代码。所以，如果不进行有效的封装，那么使用该框架的用户就需要写大量繁琐重复的代码。

通俗点说，就是要让使用框架的用户尽量少写重复的代码，少写代码可以实现同样的功能。

用返回JSON数据进行比较，来感受下封装前后的变化。

封装之前

engine.GET("/", func(w http.ResponseWriter, req *http.Request) {obj := map[string]any{"name": "abc","age":  20,}w.Header().Set("Content-Type", "application/json")w.WriteHeader(http.StatusOK)encoder := json.NewEncoder(w)if err := encoder.Encode(obj); err != nil {http.Error(w, err.Error(), 500)}})

封装后

	engine.GET("/", func(c *gee.Context) {c.JSON(http.StatusOK, gee.H{"username": c.PostForm("username"),"password": c.PostForm("password"),})})

2.针对使用场景，封装*http.Request和http.ResponseWriter的方法，简化了相关接口的调用，这只是设计Context的原因之一。

对应框架来说，还需要支撑额外的功能。例如，之后要解析动态路由/hello/:name,参数:name的值放在哪里？Context随着每一个请求的出现而产生，请求的结束而销毁，和当前请求的强相关的信息都应由Context承载。每一个HTTP请求就会带有一个Context。

因此，设置Context结构，扩展性和复杂性都留在了内部，从而简化了接口。而路由的处理函数，以及之后要实现的中间件，参数都统一使用Context实例。Context就像一次会话的百宝箱，可以找到任何东西。

Context的实现

type H map[string]anytype Context struct {Wrtier http.ResponseWriterReq    *http.RequestPath   stringMethod string//响应的状态码StatusCode int
}func newContext(w http.ResponseWriter, req *http.Request) *Context {return &Context{Wrtier: w,Req:    req,Path:   req.URL.Path,Method: req.Method,}
}func (c *Context) PostForm(key string) string {return c.Req.FormValue(key)
}func (c *Context) Query(key string) string {return c.Req.URL.Query().Get(key)
}func (c *Context) Status(code int) {c.StatusCode = codec.Wrtier.WriteHeader(code)
}func (c *Context) SetHeader(key string, value string) {c.Wrtier.Header().Set(key, value)
}//以下是快速构造Sring/Data/JSON/HTML响应的方法
func (c *Context) String(code int, format string, values ...any) {c.SetHeader("Content-Type", "text/plain")c.Status(code)c.Wrtier.Write([]byte(fmt.Sprintf(format, values...)))
}func (c *Context) JSON(code int, obj any) {c.SetHeader("Content-Type", "application/json")c.Status(code)encoder := json.NewEncoder(c.Wrtier)if err := encoder.Encode(obj); err != nil {http.Error(c.Wrtier, err.Error(), 500)}
}func (c *Context) Data(code int, data []byte) {c.Status(code)c.Wrtier.Write(data)
}func (c *Context) HTML(code int, html string) {c.SetHeader("Content-Type", "text/html")c.Status(code)c.Wrtier.Write([]byte(html))
}

代码开头，给map[string]any起了别名H，构建JSON数据时候，使用gee.H显得更加简洁。

• Context目前包含了http.ResponseWriter和*http.Request,这样为路由函数的参数可以修改成(c *gee.Context)做准备。另外也提供了对Method和Path这两个常用属性的直接访问。
• 提供了访问Query和PostForm参数的方法
• 提供了快速构造Sring/Data/JSON/HTML响应的方法，使用简便。

 路由（Router）

将路由抽取出来，放到一个新的文件router.go，方便我们下次对router功能的增强，录入添加动态路由的支持。而router的hander方法做了一个调整，就是handler的参数变成了前面所说的*Context。

将路由单独抽离出来，那和路由相关的路由方法的操作也会在该文件内。

package geeimport "net/http"
//HandlerFunc的定义在gee.go文件中type router struct {handers map[string]HandlerFunc
}func newRouter() *router {return &router{handers: make(map[string]HandlerFunc)}
}// 添加路由
func (r *router) addRoute(method string, pattern string, handler HandlerFunc) {key := method + "-" + patternr.handers[key] = handler
}func (r *router) handle(c *Context) {key := c.Method + "-" + c.Pathif hander, ok := r.handers[key]; ok {hander(c)} else {c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)}
}

框架入口

gee.go

type Engine struct {router *router
}// 创建enginx实例
func New() *Engine {return &Engine{router: newRouter()}
}func (engine *Engine) addRoute(method string, pattern string, hander HandlerFunc) {engine.router.addRoute(method, pattern, hander)
}func (engine *Engine) GET(pattern string, handler HandlerFunc) {engine.addRoute("GET", pattern, handler)
}
func (engine *Engine) POST(pattern string, handler HandlerFunc) {engine.addRoute("POST", pattern, handler)
}func (engine *Engine) Run(addr string) error {return http.ListenAndServe(addr, engine)
}func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {c := newContext(w, req)engine.router.handle(c)
}

 在将路由router相关的代码独立之后，gee.go相对简单了不少。其中最重要的还是通过实现了ServeHTTP接口，接管了所有的HTTP请求。

这版的改变主要的改变，添加了Context,把路由router独立开来。在此基础上，gee.go中最大变化的是在ServHTTP方法中。

在Context中说了，一个HTTP请求，就带有一个Context。所以一个HTTP请求到来后，就为这个请求创建一个Context实例。

独立router部分后，执行路由方法的代码也在router中了。而路由方法的参数也由(http.ResponseWriter, *http.Request)修改成(*Context)。所以，ServHTTP需要调用router.handle去执行对应的路由方法，并把*context传递进去，给该请求发送响应，由用户自己定义的，但都是调用Context中的api来实现的，例如返回string字符串，Context.String函数。

所以，Context承载了整个会话的生命周期。

测试

到这里，使用的样子已经和Gin相似了。来看看使用例子。

func main() {engine := gee.New()engine.GET("/", func(c *gee.Context) {c.String(http.StatusOK, "ok..")})engine.POST("/hello", func(c *gee.Context) {c.JSON(http.StatusOK, gee.H{"name": "abc","age":  32,})})engine.Run("localhost:10000")
}

 执行 go run main.go查看效果

 完整代码：https://github.com/liwook/Go-projects/tree/main/gee-web/2-context