从零实现 Web 框架 (Gee)

package main

import (
	"elari/elaina"
	"fmt"
	"net/http"
)

func main() {
	e := elaina.New()
	{
		e.GET("/", index)
		e.POST("/", post)
	}
	e.Run(":8080")
}
func index(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "hello elaina")
}
func post(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "hello post")
}

package elaina
import (
	"fmt"
	"net/http"
)
// HandleFunc 是处理 HTTP 请求的函数类型
// 它与 http.HandlerFunc 拥有相同的函数签名，方便框架内部统一使用
type HandleFunc func(w http.ResponseWriter, r *http.Request)
// Elaina 是我们自己实现的极简 Web 框架核心结构体
// 它实现了 http.Handler 接口，因此可以直接传给 http.ListenAndServe
type Elaina struct {
	// router 是路由表：key = "METHOD-PATH"（例如 "GET-/users"），value = 处理函数
	// 使用 map 实现 O(1) 查找，非常简单高效（教学级实现）
	router map[string]HandleFunc
}
// New 创建一个新的 Elaina 实例并初始化路由表
func New() *Elaina {
	return &Elaina{
		router: make(map[string]HandleFunc),
	}
}
// addRoute 是底层添加路由的方法
// method: "GET"、"POST" 等，path: "/users"，handler: 处理函数
func (e *Elaina) addRoute(method, path string, handler HandleFunc) {
	key := method + "-" + path
	e.router[key] = handler
}
// GET 注册 GET 请求路由（语法糖）
func (e *Elaina) GET(path string, handler HandleFunc) {
	e.addRoute("GET", path, handler)
}
// POST 注册 POST 请求路由（语法糖）
func (e *Elaina) POST(path string, handler HandleFunc) {
	e.addRoute("POST", path, handler)
}
// ServeHTTP 实现 http.Handler 接口的核心方法
// 这是框架的“心脏”：每来一个请求都会调用它
func (e *Elaina) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// 构造路由 key，例如 "GET-/api/users"
	key := r.Method + "-" + r.URL.Path
	// 从路由表查找
	handler, ok := e.router[key]
	if !ok {
		// 没找到路由 → 返回 404
		http.Error(w, "404 not found", http.StatusNotFound)
		return
	}
	// 执行对应的处理函数
	handler(w, r)
}
// Run 启动 HTTP 服务器，监听指定地址
// 本质上是调用 http.ListenAndServe(addr, e)，把 Elaina 自己当作 Handler
func (e *Elaina) Run(addr string) error {
	fmt.Printf("🚀 Elaina 服务器启动成功，监听地址: %s\n", addr)
	return http.ListenAndServe(addr, e)
}

GET http://127.0.0.1:8080/ HTTP/1.1

# GET http://127.0.0.1:8080/ HTTP/1.1
HTTP/1.1 200 OK
Date: Thu, 05 Mar 2026 08:28:40 GMT
Content-Length: 12
Content-Type: text/plain; charset=utf-8
Connection: close

hello elaina

POST http://127.0.0.1:8080/ HTTP/1.1

# POST http://127.0.0.1:8080/ HTTP/1.1
HTTP/1.1 200 OK
Date: Thu, 05 Mar 2026 08:29:08 GMT
Content-Length: 10
Content-Type: text/plain; charset=utf-8
Connection: close

hello post

// Elaina.go（现代化版本）
type Elaina struct {
	*http.ServeMux  // 直接嵌入官方最新 mux
}

func New() *Elaina {
	return &Elaina{ServeMux: http.NewServeMux()}
}

// 取消 addRoute 这种方法，因为现在官方的 ServeMux 已经支持路径参数，所以不需要再额外封装 addRoute 了

// GET / POST 现在支持路径参数！
func (e *Elaina) GET(path string, handler HandleFunc) {
	e.HandleFunc("GET "+path, handler)
}

func (e *Elaina) POST(path string, handler HandleFunc) {
	e.HandleFunc("POST "+path, handler)
}

// Run 不变
func (e *Elaina) Run(addr string) error {
	fmt.Printf("🚀 Elaina (基于 Go 1.26 ServeMux) 启动: %s\n", addr)
	return http.ListenAndServe(addr, e.ServeMux)
}

e.GET("/users/{id}", func(w http.ResponseWriter, r *http.Request) {
    id := r.PathValue("id")  // 官方新方法
    // ...
})

package main

import (
	"elari/elaina"
)

func main() {
	r := elaina.New()
	// GET http://127.0.0.1:8080/ HTTP/1.1
	r.GET("/", indexHandler)
	// GET http://127.0.0.1:8080/hello?name=majotabi HTTP/1.1
	r.GET("/hello", helloHandler)
	// POST http://127.0.0.1:8080/login?username=majotabi&password=612866 HTTP/1.1
	r.POST("/login", loginHandler)
	r.Run(":8080")
}

// indexHandler 是处理索引请求的处理函数
func indexHandler(c *elaina.Context) {
	c.HTML(200, "<h1>Hello Elaina</h1>")
}

// loginHandler 是处理登录请求的处理函数
func loginHandler(c *elaina.Context) {
	c.JSON(200, elaina.H{
		"username": c.PostForm("username"),
		"password": c.PostForm("password"),
	})
}

// helloHandler 是处理hello请求的处理函数
func helloHandler(c *elaina.Context) {
	// expect /hello?name=geektutu
	c.String(200, "hello %s, you're at %s\n", c.Query("name"), c.Path)
}

obj = map[string]interface{}{
    "name": "geektutu",
    "password": "1234",
}
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)
}

c.JSON(http.StatusOK, elaina.H{
    "username": c.PostForm("username"),
    "password": c.PostForm("password"),
})

type Context struct {
	// 原始的 ResponseWriter 和 Request
	Writer http.ResponseWriter
	Req    *http.Request
	// 请求路径和方法
	Path   string
	Method string
	// 响应状态码
	StatusCode int
}

type H map[string]any // H 是一个快捷类型，用于构造 JSON 数据

package elaina

import (
	"encoding/json"
	"fmt"
	"net/http"
)

type H map[string]any // H 是一个快捷类型，用于构造 JSON 数据

type Context struct {
	// 中文注释
	// 原始的 ResponseWriter 和 Request
	Writer http.ResponseWriter
	Req    *http.Request
	// 请求路径和方法
	Path   string
	Method string
	// 响应状态码
	StatusCode int
}

// newContext 创建一个新的上下文实例
func newContext(w http.ResponseWriter, req *http.Request) *Context {
	return &Context{
		Writer: w,
		Req:    req,
		Path:   req.URL.Path,
		Method: req.Method,
	}
}

// PostForm方法用于获取POST请求中的表单参数
func (c *Context) PostForm(key string) string {
	return c.Req.FormValue(key)
}

// Query方法用于获取URL查询参数
func (c *Context) Query(key string) string {
	return c.Req.URL.Query().Get(key)
}

// Status方法用于设置响应状态码
func (c *Context) Status(code int) {
	c.StatusCode = code
	c.Writer.WriteHeader(code)
}

// SetHeader方法用于设置响应头
func (c *Context) SetHeader(key, value string) {
	c.Writer.Header().Set(key, value)
}

// String方法用于设置响应体为字符串
func (c *Context) String(code int, format string, values ...interface{}) {
	c.SetHeader("Content-Type", "text/plain")
	c.Status(code)
	c.Writer.Write([]byte(fmt.Sprintf(format, values...)))
}

// JSON方法用于设置响应体为JSON格式
func (c *Context) JSON(code int, obj interface{}) {
	c.SetHeader("Content-Type", "application/json")
	c.Status(code)                              // 设置响应状态码
	encoder := json.NewEncoder(c.Writer)        // 创建JSON编码器
	if err := encoder.Encode(obj); err != nil { // 编码JSON并写入响应体
		http.Error(c.Writer, err.Error(), 500) // 如果编码过程中出错，返回500 Internal Server Error
	}
}

// Data方法用于设置响应体为二进制数据
func (c *Context) Data(code int, data []byte) {
	c.Status(code)
	c.Writer.Write(data)
}

// HTML方法用于设置响应体为HTML格式
func (c *Context) HTML(code int, html string) {
	c.SetHeader("Content-Type", "text/html")
	c.Status(code)
	c.Writer.Write([]byte(html))
}

package elaina

import (
	"log"
	"net/http"
)

// HandlerFunc 定义了 elaina 使用的请求处理函数
type HandlerFunc func(*Context)

// router 结构体是 Elaina 框架的路由管理器。
// 它维护了一个 handlers 映射表，用于存储 HTTP 方法和路径组合到对应处理函数的映射。
type router struct {
	// handlers 存储所有的路由规则。
	// key 的格式是由 "请求方法-路径" 拼接而成的字符串，例如 "GET-/"。
	// value 是对应的 HandlerFunc 处理函数。
	handlers map[string]HandlerFunc
}

// newRouter 是 router 结构体的构造函数，用于初始化并返回一个新的 router 实例。
func newRouter() *router {
	return &router{handlers: make(map[string]HandlerFunc)}
}

// addRoute 向路由管理器中注册一条新的路由规则。
// method: 指定请求的 HTTP 方法，如 "GET"、"POST" 等。
// pattern: 指定请求的路径模式，如 "/"、"/hello" 等。
// handler: 当请求匹配该方法和路径时，将执行的处理函数 HandlerFunc。
func (r *router) addRoute(method string, pattern string, handler HandlerFunc) {
	// 在控制台打印日志，记录新注册的路由信息。
	log.Printf("Route %4s - %s", method, pattern)
	// 将方法和路径拼接成唯一的 key，存入 handlers 映射表中。
	key := method + "-" + pattern
	r.handlers[key] = handler
}

// handle 是 router 的核心处理方法。
// 它根据 Context 中携带的请求方法和路径信息，在 handlers 映射表中查找匹配的处理函数。
// 如果找到匹配的路由，则调用该处理函数并传入 Context。
// 如果未找到匹配的路由，则通过 Context 返回 404 NOT FOUND 响应。
func (r *router) handle(c *Context) {
	// 拼接查找 key，例如 "GET-/"。
	key := c.Method + "-" + c.Path
	// 在 handlers 映射表中尝试查找。
	if handler, ok := r.handlers[key]; ok {
		// 找到路由，执行处理逻辑。
		handler(c)
	} else {
		// 未找到匹配路由，返回 404 状态码和错误提示。
		c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)
	}
}

package elaina

import "net/http"



// Elaina 实现了 ServeHTTP 接口
type Elaina struct {
	router *router
}

// New 是 Elaina 的构造函数
func New() *Elaina {
	return &Elaina{router: newRouter()}
}

func (Elaina *Elaina) addRoute(method string, path string, handler HandlerFunc) {
	Elaina.router.addRoute(method, path, handler)
}

// GET 定义了添加 GET 请求的方法
func (Elaina *Elaina) GET(path string, handler HandlerFunc) {
	Elaina.addRoute("GET", path, handler)
}

// POST 定义了添加 POST 请求的方法
func (Elaina *Elaina) POST(path string, handler HandlerFunc) {
	Elaina.addRoute("POST", path, handler)
}

// Run 定义了启动 HTTP 服务器的方法
func (Elaina *Elaina) Run(addr string) (err error) {
	return http.ListenAndServe(addr, Elaina)
}

func (Elaina *Elaina) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	c := newContext(w, req)
	Elaina.router.handle(c)
}

package main

import (
	"elari/elaina"
)

func main() {
	r := elaina.New()
	// GET http://127.0.0.1:8080/ HTTP/1.1
	r.GET("/", indexHandler)
	// GET http://127.0.0.1:8080/hello?name=majotabi HTTP/1.1
	r.GET("/hello", helloHandler)
	// POST http://127.0.0.1:8080/login?username=majotabi&password=612866 HTTP/1.1
	r.POST("/login", loginHandler)
	r.Run(":8080")
}

// indexHandler 是处理索引请求的处理函数
func indexHandler(c *elaina.Context) {
	c.HTML(200, "<h1>Hello Elaina</h1>")
}

// loginHandler 是处理登录请求的处理函数
func loginHandler(c *elaina.Context) {
	c.JSON(200, elaina.H{
		"username": c.PostForm("username"),
		"password": c.PostForm("password"),
	})
}

// helloHandler 是处理hello请求的处理函数
func helloHandler(c *elaina.Context) {
	// expect /hello?name=majotabi
	c.String(200, "hello %s, you're at %s\n", c.Query("name"), c.Path)
}

GET http://127.0.0.1:8080/ HTTP/1.1

HTTP/1.1 200 OK
Content-Type: text/html
Date: Thu, 05 Mar 2026 09:11:59 GMT
Content-Length: 21
Connection: close

<h1>Hello Elaina</h1>

GET http://127.0.0.1:8080/hello?name=majotabi HTTP/1.1

HTTP/1.1 200 OK
Content-Type: text/plain
Date: Thu, 05 Mar 2026 09:14:16 GMT
Content-Length: 33
Connection: close

hello majotabi, you're at /hello

POST http://127.0.0.1:8080/login?username=majotabi&password=612866 HTTP/1.1
Content-Type: application/x-www-form-urlencoded

HTTP/1.1 200 OK
Content-Type: application/json
Date: Thu, 05 Mar 2026 09:14:40 GMT
Content-Length: 44
Connection: close

{
  "password": "612866",
  "username": "majotabi"
}

package main
import (
	"elari/elaina"
	"net/http"
)
func main() {
	r := elaina.New()
	r.GET("/hello", indexHandler)
	r.GET("/majotabi/:name/:birthday", majoHandler)
	r.GET("/ciallo/*0721", helloHandler)
	r.Run(":8080")
}
func helloHandler(c *elaina.Context) {
	filepath := c.Param("0721")
	c.JSON(http.StatusOK, elaina.H{"filepath": filepath})
}
func indexHandler(c *elaina.Context) {
	c.HTML(200, "<h1>Hello Elaina</h1>")
}
func majoHandler(c *elaina.Context) {
	c.String(200, "%s 你的生日是 %s\n", c.Param("name"), c.Param("birthday"))
}

type node struct {
	pattern  string
	part     string
	children []*node
	isWild   bool 
}

type router struct {
	roots    map[string]*node
	handlers map[string]HandlerFunc
}
func newRouter() *router {
	return &router{
		roots:    make(map[string]*node),
		handlers: make(map[string]HandlerFunc),
	}
}

func parsePattern(pattern string) []string {
	path := strings.Split(pattern, "/")
	parts := make([]string, 0)
	for _, part := range path {
		if part != "" {
			parts = append(parts, part)
			if part[0] == '*' {
				break
			}
		}
	}
	return parts
}

func (n *node) insert(pattern string, parts []string, height int) {
	if len(parts) == height {
		n.pattern = pattern
		return
	}
	part := parts[height]
	child := n.matchChild(part)
	if child == nil {
		child = &node{
			part:   part,
			isWild: part[0] == ':' || part[0] == '*',
		}
		n.children = append(n.children, child)
	}
	child.insert(pattern, parts, height+1)
}

func (n *node) matchChild(part string) *node {
	for _, child := range n.children {
		if child.part == part || child.isWild {
			return child
		}
	}
	return nil
}

func (n *node) search(parts []string, height int) *node {
	if len(parts) == height || strings.HasPrefix(n.part, "*") {
		if n.pattern == "" {
			return nil
		}
		return n
	}
	part := parts[height]
	children := n.matchChildren(part)
	for _, child := range children {
		result := child.search(parts, height+1)
		if result != nil {
			return result
		}
	}
	return nil
}

func (n *node) matchChildren(part string) []*node {
	nodes := make([]*node, 0)
	for _, child := range n.children {
		if child.part == part || child.isWild {
			nodes = append(nodes, child)
		}
	}
	return nodes
}

func (r *router) getRoute(method string, path string) (*node, map[string]string) {
	searchParts := parsePattern(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 := parsePattern(n.pattern)
		for index, part := range parts {
			if part[0] == ':' {
				params[part[1:]] = searchParts[index]
			}
			if part[0] == '*' && len(part) > 1 {
				params[part[1:]] = strings.Join(searchParts[index:], "/") 
				break
			}
		}
		return n, params
	}
	return nil, nil
}

func (r *router) addRoute(method string, pattern string, handler HandlerFunc) {
	parts := parsePattern(pattern)
	key := method + "-" + pattern
	_, ok := r.roots[method]
	if !ok {
		r.roots[method] = &node{}
	}
	r.roots[method].insert(pattern, parts, 0)
	r.handlers[key] = 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
		r.handlers[key](c) 
	} else {
		c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)
	}
}

type Context struct {
	Writer     http.ResponseWriter
	Req        *http.Request
	Path       string
	Method     string
	StatusCode int
	Params map[string]string
}
func (c *Context) Param(key string) string {
	return c.Params[key]
}

GET http://127.0.0.1:8080/hello HTTP/1.1

HTTP/1.1 200 OK
Content-Type: text/html
Date: Fri, 06 Mar 2026 15:12:30 GMT
Content-Length: 21
Connection: close

<h1>Hello Elaina</h1>

GET http://127.0.0.1:8080/majotabi/elaina/1017 HTTP/1.1

HTTP/1.1 200 OK
Content-Type: text/plain
Date: Fri, 06 Mar 2026 15:14:16 GMT
Content-Length: 28
Connection: close

elaina 你的生日是 1017

GET http://127.0.0.1:8080/ciallo/abc/def/ghi.jpg HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
Date: Fri, 06 Mar 2026 15:14:34 GMT
Content-Length: 31
Connection: close

{
  "filepath": "abc/def/ghi.jpg"
}

package main

import (
	"elari/elaina"
	"log"
	"net/http"
)

func main() {
	// 创建框架实例。此时 r 既是引擎，也是根分组。
	r := elaina.New()

	// 注册一个普通根路由。
	r.GET("/index", func(c *elaina.Context) {
		c.HTML(http.StatusOK, "<h1>Hello Elaina</h1>")
	})

	// 创建 /v1 分组，之后这个分组下的所有路由都会自动带上 /v1 前缀。
	v1 := r.Group("/v1")
	{
		// 实际注册的完整路径是 /v1/
		v1.GET("/", func(c *elaina.Context) {
			c.HTML(http.StatusOK, "<h1>Hello Elaina - v1</h1>")
		})
		// 实际注册的完整路径是 /v1/hello
		v1.GET("/hello", func(c *elaina.Context) {
			c.String(http.StatusOK, "你好 %s, you're at %s\n", c.Query("name"), c.Path)
		})
	}

	// 创建 /v2 分组，用于演示动态路由和 POST 表单。
	v2 := r.Group("/v2")
	{
		// 实际注册的完整路径是 /v2/hello/:name
		v2.GET("/hello/:name", func(c *elaina.Context) {
			c.String(http.StatusOK, "你好 %s, 你请求的路径是 %s\n", c.Param("name"), c.Path)
		})
		// 实际注册的完整路径是 /v2/login
		v2.POST("/login", func(c *elaina.Context) {
			c.JSON(http.StatusOK, elaina.H{
				"username": c.PostForm("username"),
				"password": c.PostForm("password"),
			})
		})
	}

	// 在 /v2 下面继续创建子分组，最终前缀会变成 /v2/admin。
	admin := v2.Group("/admin")
	{
		// 实际注册的完整路径是 /v2/admin/stats
		admin.GET("/stats", func(c *elaina.Context) {
			c.JSON(http.StatusOK, elaina.H{
				"group": "v2/admin",
				"path":  c.Path,
			})
		})
	}

	// 启动服务；如果启动失败，log.Fatal 会直接打印错误并退出程序。
	log.Fatal(r.Run(":8080"))
}

type RouterGroup struct {
	// prefix 是当前分组共享的路径前缀，例如 "/v1"、"/v2/admin"。
	prefix string

	// middlewares 用于保存挂在这个分组上的中间件。
	// 这一章先预留，下一章会真正用起来。
	middlewares []HandlerFunc

	// parent 指向父分组，便于维护分组层级关系。
	parent *RouterGroup

	// engine 指向整个框架实例，最终注册路由还是要落到总路由器上。
	engine *Elaina
}

type Elaina struct {
	// 嵌入 RouterGroup 后，Elaina 本身就拥有了 Group/GET/POST 等方法。
	*RouterGroup

	// router 是真正负责路由匹配和分发的核心路由器。
	router *router

	// groups 保存全部分组，后面做中间件匹配时会遍历它。
	groups []*RouterGroup
}

package elaina

import (
	"log"
	"net/http"
)

// HandlerFunc 统一了路由处理函数的签名。
type HandlerFunc func(*Context)

type RouterGroup struct {
	// prefix 是当前分组的公共路径前缀。
	prefix      string

	// middlewares 预留给后续的中间件系统使用。
	middlewares []HandlerFunc

	// parent 指向父分组。
	parent      *RouterGroup

	// engine 指向所属框架实例。
	engine      *Elaina
}

type Elaina struct {
	// 根引擎本身也是一个 RouterGroup。
	*RouterGroup

	// router 保存真正的路由树和处理函数映射。
	router *router

	// groups 记录框架中创建过的所有分组。
	groups []*RouterGroup
}

// New 创建框架实例，并初始化根分组。
func New() *Elaina {
	engine := &Elaina{
		router: newRouter(),
	}

	// 创建根分组。根分组默认没有 prefix。
	engine.RouterGroup = &RouterGroup{
		engine: engine,
	}

	// 把根分组也放进 groups，后续统一遍历。
	engine.groups = []*RouterGroup{engine.RouterGroup}
	return engine
}

// Group 基于当前分组创建一个新的子分组。
func (group *RouterGroup) Group(prefix string) *RouterGroup {
	engine := group.engine
	newGroup := &RouterGroup{
		// 子分组前缀 = 父分组前缀 + 自己的前缀
		prefix: group.prefix + prefix,
		parent: group,
		engine: engine,
	}

	// 新分组创建后，要登记到引擎的 groups 里。
	engine.groups = append(engine.groups, newGroup)
	return newGroup
}

// addRoute 用于把相对路径转换成带分组前缀的完整路径，再注册到路由器。
func (group *RouterGroup) addRoute(method, relativePath string, handler HandlerFunc) {
	// 例如 group.prefix="/v2"，relativePath="/hello/:name"
	// 最终 pattern="/v2/hello/:name"
	pattern := group.prefix + relativePath
	log.Printf("Route %4s - %s", method, pattern)
	group.engine.router.addRoute(method, pattern, handler)
}

// GET 是注册 GET 路由的语法糖。
func (group *RouterGroup) GET(relativePath string, handler HandlerFunc) {
	group.addRoute(http.MethodGet, relativePath, handler)
}

// POST 是注册 POST 路由的语法糖。
func (group *RouterGroup) POST(relativePath string, handler HandlerFunc) {
	group.addRoute(http.MethodPost, relativePath, handler)
}

// Run 启动 HTTP 服务。
func (e *Elaina) Run(addr string) error {
	return http.ListenAndServe(addr, e)
}

// ServeHTTP 实现 http.Handler 接口。
// 每次请求进来时，先创建 Context，再交给 router 处理。
func (e *Elaina) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	c := newContext(w, req)
	e.router.handle(c)
}

GET http://127.0.0.1:8080/index HTTP/1.1

HTTP/1.1 200 OK
Content-Type: text/html

<h1>Hello Elaina</h1>

GET http://127.0.0.1:8080/v1/hello?name=elaina HTTP/1.1

HTTP/1.1 200 OK
Content-Type: text/plain

你好 elaina, you're at /v1/hello

GET http://127.0.0.1:8080/v2/hello/elaina HTTP/1.1

HTTP/1.1 200 OK
Content-Type: text/plain

你好 elaina, 你请求的路径是 /v2/hello/elaina

GET http://127.0.0.1:8080/v2/admin/stats HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json

{
  "group": "v2/admin",
  "path": "/v2/admin/stats"
}

POST http://127.0.0.1:8080/v2/login HTTP/1.1
Content-Type: application/x-www-form-urlencoded

username=elaina&password=0721

HTTP/1.1 200 OK
Content-Type: application/json

{
  "password": "0721",
  "username": "elaina"
}

package main

import (
	"elari/elaina"
	"log"
	"net/http"
	"time"
)

func main() {
	// 创建框架实例。
	r := elaina.New()

	// 把 Logger 安装到根分组上。
	// 这样所有请求都会先经过日志中间件。
	r.Use(elaina.Logger())

	// 注册一个普通首页路由。
	r.GET("/", func(c *elaina.Context) {
		c.HTML(http.StatusOK, "<h1>Hello Elaina</h1>")
	})

	// 创建 /v2 分组，并为它单独挂一个中间件。
	v2 := r.Group("/v2")
	v2.Use(onlyForV2())
	{
		// 只有以 /v2 开头的请求才会进入这个处理函数。
		v2.GET("/hello/:name", func(c *elaina.Context) {
			c.String(http.StatusOK, "hello %s, you're at %s\n", c.Param("name"), c.Path)
		})
	}

	log.Fatal(r.Run(":8080"))
}

// onlyForV2 演示一个典型的分组级中间件：
// 1. 先做前置逻辑
// 2. 满足条件时可以直接中断请求
// 3. 否则继续往后执行
// 4. 最后再做后置逻辑
func onlyForV2() elaina.HandlerFunc {
	return func(c *elaina.Context) {
		// 记录开始时间，用于统计耗时。
		start := time.Now()

		// fail=1 时，直接中断请求并返回错误 JSON。
		if c.Query("fail") == "1" {
			c.Fail(http.StatusInternalServerError, "forced by onlyForV2 middleware")
			log.Printf("[%d] %s in %v for group v2", c.StatusCode, c.Req.RequestURI, time.Since(start))
			return
		}

		// 执行后续中间件和最终路由处理函数。
		c.Next()

		// 后置逻辑：在请求处理完之后记录日志。
		log.Printf("[%d] %s in %v for group v2", c.StatusCode, c.Req.RequestURI, time.Since(start))
	}
}