05.echo

1 介绍

1.1 简介

01.Echo框架概述
    a.框架定位
        a.高性能Web框架
            a.核心特性
                Echo是轻量级高性能Go Web框架
                专注于简洁API和极致性能
                适合构建RESTful API和微服务
            b.技术基础
                自研高性能路由器
                优化的内存分配
                零依赖核心设计
        b.开源协议
            a.MIT许可证
                完全开源免费
                商业友好使用
                活跃社区支持
    b.核心特点
        a.高性能路由
            a.路由算法
                基于Radix树的路由匹配
                支持参数和通配符
                快速路由查找
            b.性能优势
                低内存占用
                高并发处理能力
                基准测试优秀
        b.中间件系统
            a.灵活扩展
                丰富的内置中间件
                易于自定义中间件
                链式执行模型
    c.设计理念
        a.简洁API
            a.直观设计
                清晰的方法命名
                链式调用支持
                易于学习使用
            b.最小化依赖
                核心功能独立
                可选功能插件化
                减少项目体积
        b.生产就绪
            a.稳定可靠
                经过大规模生产验证
                完善的错误处理
                详细的文档支持
    d.版本管理
        a.v4稳定版
            a.当前版本
                主流使用版本
                API稳定
                持续维护
            b.社区支持
                活跃的开发者社区
                及时的问题响应
                丰富的第三方扩展

1.2 核心特性

01.路由系统
    a.高性能路由
        a.Radix树路由
            // Echo使用优化的Radix树实现路由
            e := echo.New()

            // 基础路由
            e.GET("/", func(c echo.Context) error {
                return c.String(http.StatusOK, "Hello, Echo!")
            })

            // 路径参数
            e.GET("/users/:id", func(c echo.Context) error {
                id := c.Param("id")
                return c.JSON(200, map[string]string{
                    "user_id": id,
                })
            })

            // 通配符路由
            e.GET("/files/*", func(c echo.Context) error {
                return c.String(200, c.Param("*"))
            })

            // 性能特点：
            // - O(log n)查找时间
            // - 低内存占用
            // - 支持数百万路由
        b.路由分组
            // API版本分组
            v1 := e.Group("/api/v1")
            {
                v1.GET("/users", listUsers)
                v1.POST("/users", createUser)
            }

            v2 := e.Group("/api/v2")
            {
                v2.GET("/users", listUsersV2)
                v2.POST("/users", createUserV2)
            }

            // 带中间件的分组
            admin := e.Group("/admin")
            admin.Use(middleware.BasicAuth(func(username, password string, c echo.Context) (bool, error) {
                return username == "admin" && password == "secret", nil
            }))
            {
                admin.GET("/dashboard", dashboardHandler)
                admin.POST("/settings", settingsHandler)
            }

02.Context对象
    a.请求响应封装
        a.Context接口
            // Echo的Context是接口，提供丰富的方法
            e.GET("/demo", func(c echo.Context) error {
                // 获取请求信息
                method := c.Request().Method
                path := c.Path()
                realIP := c.RealIP()

                // 获取参数
                id := c.Param("id")
                name := c.QueryParam("name")

                // 绑定数据
                var user User
                if err := c.Bind(&user); err != nil {
                    return err
                }

                // 返回响应
                return c.JSON(200, map[string]interface{}{
                    "method": method,
                    "path": path,
                    "ip": realIP,
                })
            })
        b.数据存储
            // 在Context中存储和获取数据
            e.Use(func(next echo.HandlerFunc) echo.HandlerFunc {
                return func(c echo.Context) error {
                    // 存储数据
                    c.Set("user_id", 123)
                    c.Set("username", "alice")
                    return next(c)
                }
            })

            e.GET("/profile", func(c echo.Context) error {
                // 获取数据
                userID := c.Get("user_id").(int)
                username := c.Get("username").(string)

                return c.JSON(200, map[string]interface{}{
                    "user_id": userID,
                    "username": username,
                })
            })

03.中间件
    a.内置中间件
        a.常用中间件
            import "github.com/labstack/echo/v4/middleware"

            e := echo.New()

            // Logger中间件
            e.Use(middleware.Logger())

            // Recover中间件
            e.Use(middleware.Recover())

            // CORS中间件
            e.Use(middleware.CORS())

            // Gzip压缩
            e.Use(middleware.Gzip())

            // 请求限流
            e.Use(middleware.RateLimiter(middleware.NewRateLimiterMemoryStore(20)))

            // JWT认证
            e.Use(middleware.JWT([]byte("secret")))

            // 完整示例
            func main() {
                e := echo.New()

                // 全局中间件
                e.Use(middleware.Logger())
                e.Use(middleware.Recover())
                e.Use(middleware.CORS())

                // 路由
                e.GET("/", homeHandler)

                e.Logger.Fatal(e.Start(":8080"))
            }
        b.自定义中间件
            // 自定义中间件
            func CustomMiddleware() echo.MiddlewareFunc {
                return func(next echo.HandlerFunc) echo.HandlerFunc {
                    return func(c echo.Context) error {
                        // 请求前处理
                        start := time.Now()

                        // 调用下一个处理器
                        err := next(c)

                        // 请求后处理
                        latency := time.Since(start)
                        log.Printf("Request took %v", latency)

                        return err
                    }
                }
            }

            // 使用
            e.Use(CustomMiddleware())

            // 带参数的中间件
            func AuthMiddleware(secret string) echo.MiddlewareFunc {
                return func(next echo.HandlerFunc) echo.HandlerFunc {
                    return func(c echo.Context) error {
                        token := c.Request().Header.Get("Authorization")
                        if token != secret {
                            return echo.NewHTTPError(http.StatusUnauthorized, "Invalid token")
                        }
                        return next(c)
                    }
                }
            }

            e.Use(AuthMiddleware("my-secret-token"))

04.数据处理
    a.数据绑定
        a.JSON绑定
            // 定义结构体
            type User struct {
                Name  string `json:"name" validate:"required"`
                Email string `json:"email" validate:"required,email"`
                Age   int    `json:"age" validate:"gte=0,lte=120"`
            }

            // JSON绑定
            e.POST("/users", func(c echo.Context) error {
                user := new(User)

                // 绑定JSON数据
                if err := c.Bind(user); err != nil {
                    return echo.NewHTTPError(http.StatusBadRequest, err.Error())
                }

                // 验证数据
                if err := c.Validate(user); err != nil {
                    return echo.NewHTTPError(http.StatusBadRequest, err.Error())
                }

                // 处理业务逻辑
                return c.JSON(201, user)
            })

            // 请求示例：
            // POST /users
            // Content-Type: application/json
            // {
            //   "name": "Alice",
            //   "email": "[email protected]",
            //   "age": 25
            // }
        b.自定义验证器
            import "github.com/go-playground/validator/v10"

            // 自定义验证器
            type CustomValidator struct {
                validator *validator.Validate
            }

            func (cv *CustomValidator) Validate(i interface{}) error {
                if err := cv.validator.Struct(i); err != nil {
                    return echo.NewHTTPError(http.StatusBadRequest, err.Error())
                }
                return nil
            }

            // 注册验证器
            e.Validator = &CustomValidator{validator: validator.New()}

1.3 与Gin对比

01.性能对比
    a.基准测试
        // Echo 性能特点：路由查找O(log n)，内存分配更少
        // Gin 性能特点：路由查找O(1)，优化的JSON序列化

        // 实际场景：两者性能差异不大，都能满足高并发需求
        // Echo:    50000 req/s, 内存 ~30MB
        // Gin:     48000 req/s, 内存 ~35MB

02.API设计
    a.代码风格对比
        // Echo 风格 - 返回error
        func getUser(c echo.Context) error {
            id := c.Param("id")
            return c.JSON(200, map[string]string{"id": id})
        }

        // Gin 风格 - 无返回值
        func getUser(c *gin.Context) {
            id := c.Param("id")
            c.JSON(200, gin.H{"id": id})
        }

03.生态系统
    a.中间件对比
        // Echo 内置：Logger, Recover, CORS, JWT, BasicAuth, Gzip
        // Gin 生态：gin-contrib/* 系列，更多第三方中间件

        // 选择建议：
        // Echo - 核心功能够用，代码简洁
        // Gin - 需要丰富的第三方集成

04.选择建议
    a.场景分析
        // 选择 Echo：追求性能、喜欢简洁API、中小型项目
        // 选择 Gin：需要丰富生态、团队有Gin经验、大型项目

1.4 使用场景

01.API服务
    a.RESTful API
        e := echo.New()
        api := e.Group("/api/v1")
        api.GET("/users", listUsers)
        api.POST("/users", createUser)
        api.GET("/users/:id", getUser)

02.Web应用
    a.前后端分离
        e := echo.New()
        e.Use(middleware.CORS())
        e.Static("/", "dist")  // SPA前端
        e.GET("/ws", handleWebSocket)  // WebSocket支持

03.性能要求
    a.高并发配置
        e.Server.ReadTimeout = 10 * time.Second
        e.Server.WriteTimeout = 10 * time.Second
        db.SetMaxOpenConns(100)

04.快速开发
    a.MVP原型
        e := echo.New()
        e.GET("/", func(c echo.Context) error {
            return c.String(200, "Hello!")
        })
        e.Start(":8080")

1.5 快速开始

01.安装配置
    a.环境准备
        go get github.com/labstack/echo/v4
        mkdir echo-demo && cd echo-demo
        go mod init echo-demo

02.Hello World
    a.基础示例
        package main
        import (
            "github.com/labstack/echo/v4"
            "github.com/labstack/echo/v4/middleware"
        )
        func main() {
            e := echo.New()
            e.Use(middleware.Logger())
            e.GET("/", func(c echo.Context) error {
                return c.String(200, "Hello, World!")
            })
            e.Start(":8080")
        }

03.基础路由
    a.HTTP方法
        e.GET("/users", func(c echo.Context) error {
            return c.JSON(200, map[string]string{"method": "GET"})
        })
        e.POST("/users", func(c echo.Context) error {
            return c.JSON(201, map[string]string{"method": "POST"})
        })
        e.PUT("/users/:id", func(c echo.Context) error {
            return c.JSON(200, map[string]string{"id": c.Param("id")})
        })

04.项目结构
    a.标准布局
        project/
        ├── cmd/server/main.go
        ├── internal/handler/
        ├── internal/service/
        └── go.mod

1.6 项目结构

01.目录组织
    a.完整结构
        project/
        ├── cmd/server/main.go
        ├── internal/
        │   ├── handler/
        │   ├── service/
        │   └── repository/
        ├── pkg/config/
        └── config/config.yaml

02.代码分层
    a.分层示例
        // Handler
        func (h *UserHandler) GetUser(c echo.Context) error {
            user, err := h.service.GetUser(c.Param("id"))
            return c.JSON(200, user)
        }
        // Service
        func (s *UserService) GetUser(id string) (*User, error) {
            return s.repo.FindByID(id)
        }

03.配置管理
    a.Viper集成
        import "github.com/spf13/viper"
        viper.SetConfigName("config")
        viper.AddConfigPath("./config")
        viper.ReadInConfig()

04.依赖管理
    a.依赖注入
        type App struct {
            echo *echo.Echo
            db   *sql.DB
        }
        func NewApp() *App {
            e := echo.New()
            db, _ := sql.Open("mysql", dsn)
            return &App{echo: e, db: db}
        }

2 路由与上下文

2.1 汇总：5个

01.路由定义
    HTTP方法、路径定义、处理函数、路由注册

02.路由参数
    路径参数、查询参数、表单参数、参数验证

03.路由分组
    Group方法、中间件共享、版本管理、模块划分

04.Context对象
    请求响应、数据存储、参数获取、生命周期

05.数据绑定
    JSON/XML/Form、结构体绑定、验证器、错误处理

2.2 路由定义

01.HTTP方法
    a.基础方法
        e.GET("/users", listUsers)
        e.POST("/users", createUser)
        e.PUT("/users/:id", updateUser)
        e.DELETE("/users/:id", deleteUser)
        e.PATCH("/users/:id", patchUser)

02.路径定义
    a.路径类型
        e.GET("/static", handler)           // 静态路径
        e.GET("/users/:id", handler)        // 参数路径
        e.GET("/files/*", handler)          // 通配符

03.处理函数
    a.标准处理器
        func getUser(c echo.Context) error {
            id := c.Param("id")
            user := findUser(id)
            return c.JSON(200, user)
        }

04.路由注册
    a.批量注册
        routes := []struct{
            method, path string
            handler echo.HandlerFunc
        }{
            {"GET", "/users", listUsers},
            {"POST", "/users", createUser},
        }
        for _, r := range routes {
            e.Add(r.method, r.path, r.handler)
        }

2.3 路由参数

01.路径参数
    a.参数获取
        e.GET("/users/:id", func(c echo.Context) error {
            id := c.Param("id")
            return c.String(200, "User ID: "+id)
        })

02.查询参数
    a.Query方法
        e.GET("/search", func(c echo.Context) error {
            keyword := c.QueryParam("keyword")
            page := c.QueryParam("page")
            return c.JSON(200, map[string]string{
                "keyword": keyword,
                "page": page,
            })
        })

03.表单参数
    a.Form获取
        e.POST("/login", func(c echo.Context) error {
            username := c.FormValue("username")
            password := c.FormValue("password")
            return c.JSON(200, map[string]string{
                "username": username,
            })
        })

04.参数绑定
    a.结构体绑定
        type User struct {
            Name  string `json:"name"`
            Email string `json:"email"`
        }
        e.POST("/users", func(c echo.Context) error {
            u := new(User)
            if err := c.Bind(u); err != nil {
                return err
            }
            return c.JSON(201, u)
        })

2.4 路由分组

01.Group方法
    a.基础分组
        api := e.Group("/api/v1")
        api.GET("/users", listUsers)
        api.POST("/users", createUser)

02.中间件共享
    a.分组中间件
        admin := e.Group("/admin")
        admin.Use(middleware.BasicAuth(func(username, password string, c echo.Context) (bool, error) {
            return username == "admin" && password == "secret", nil
        }))
        admin.GET("/dashboard", dashboard)

03.版本管理
    a.API版本
        v1 := e.Group("/api/v1")
        v1.GET("/users", listUsersV1)

        v2 := e.Group("/api/v2")
        v2.GET("/users", listUsersV2)

04.嵌套分组
    a.多层嵌套
        api := e.Group("/api")
        v1 := api.Group("/v1")
        users := v1.Group("/users")
        users.GET("", listUsers)
        users.GET("/:id", getUser)

2.5 Context对象

01.请求信息
    a.Request访问
        e.GET("/info", func(c echo.Context) error {
            req := c.Request()
            method := req.Method
            url := req.URL.String()
            return c.JSON(200, map[string]string{"method": method, "url": url})
        })

02.响应处理
    a.多种响应
        e.GET("/json", func(c echo.Context) error {
            return c.JSON(200, map[string]string{"msg": "ok"})
        })
        e.GET("/html", func(c echo.Context) error {
            return c.HTML(200, "<h1>Hello</h1>")
        })
        e.GET("/file", func(c echo.Context) error {
            return c.File("./file.pdf")
        })

03.数据存储
    a.Set/Get
        e.Use(func(next echo.HandlerFunc) echo.HandlerFunc {
            return func(c echo.Context) error {
                c.Set("user_id", 123)
                return next(c)
            }
        })
        e.GET("/profile", func(c echo.Context) error {
            userID := c.Get("user_id").(int)
            return c.JSON(200, map[string]int{"user_id": userID})
        })

04.参数获取
    a.全方位获取
        e.GET("/data/:id", func(c echo.Context) error {
            id := c.Param("id")
            keyword := c.QueryParam("keyword")
            token := c.Request().Header.Get("Authorization")
            cookie, _ := c.Cookie("session")
            return c.JSON(200, map[string]string{
                "id": id, "keyword": keyword, "token": token,
            })
        })

2.6 数据绑定

01.JSON绑定
    a.自动绑定
        type User struct {
            Name  string `json:"name" validate:"required"`
            Email string `json:"email" validate:"required,email"`
        }
        e.POST("/users", func(c echo.Context) error {
            u := new(User)
            if err := c.Bind(u); err != nil {
                return err
            }
            return c.JSON(201, u)
        })

02.验证器
    a.集成validator
        import "github.com/go-playground/validator/v10"
        type CustomValidator struct {
            validator *validator.Validate
        }
        func (cv *CustomValidator) Validate(i interface{}) error {
            return cv.validator.Struct(i)
        }
        e.Validator = &CustomValidator{validator: validator.New()}

03.自定义绑定
    a.Binder接口
        type CustomBinder struct{}
        func (cb *CustomBinder) Bind(i interface{}, c echo.Context) error {
            // 自定义绑定逻辑
            return nil
        }
        e.Binder = &CustomBinder{}

04.错误处理
    a.绑定错误
        e.POST("/users", func(c echo.Context) error {
            u := new(User)
            if err := c.Bind(u); err != nil {
                return echo.NewHTTPError(400, "绑定错误: "+err.Error())
            }
            if err := c.Validate(u); err != nil {
                return echo.NewHTTPError(400, "验证错误: "+err.Error())
            }
            return c.JSON(201, u)
        })

3 中间件系统

3.1 中间件概念

01.执行模型
    a.洋葱模型
        func MyMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
            return func(c echo.Context) error {
                // 请求前
                fmt.Println("Before")
                err := next(c)  // 调用下一个中间件
                // 请求后
                fmt.Println("After")
                return err
            }
        }

02.中间件类型
    a.不同级别
        e.Use(middleware.Logger())  // 全局
        admin := e.Group("/admin")
        admin.Use(AuthMiddleware())  // 分组
        e.GET("/users", getUsers, RateLimitMiddleware())  // 路由

03.执行顺序
    a.注册顺序
        e.Use(Middleware1())  // 第一个执行
        e.Use(Middleware2())  // 第二个执行
        // 执行顺序：M1请求前 -> M2请求前 -> Handler -> M2请求后 -> M1请求后

04.上下文传递
    a.数据共享
        e.Use(func(next echo.HandlerFunc) echo.HandlerFunc {
            return func(c echo.Context) error {
                c.Set("user_id", 123)
                return next(c)
            }
        })

3.2 内置中间件

01.Logger
    a.日志中间件
        e.Use(middleware.Logger())
        e.Use(middleware.LoggerWithConfig(middleware.LoggerConfig{
            Format: "${time_rfc3339} ${method} ${uri} ${status}\n",
        }))

02.Recover
    a.Panic恢复
        e.Use(middleware.Recover())
        e.Use(middleware.RecoverWithConfig(middleware.RecoverConfig{
            StackSize: 1 << 10,
        }))

03.CORS
    a.跨域配置
        e.Use(middleware.CORS())
        e.Use(middleware.CORSWithConfig(middleware.CORSConfig{
            AllowOrigins: []string{"http://localhost:3000"},
            AllowMethods: []string{echo.GET, echo.POST},
        }))

04.其他中间件
    a.常用中间件
        e.Use(middleware.Gzip())
        e.Use(middleware.BasicAuth(func(username, password string, c echo.Context) (bool, error) {
            return username == "admin" && password == "secret", nil
        }))
        e.Use(middleware.JWT([]byte("secret")))
        e.Use(middleware.RateLimiter(middleware.NewRateLimiterMemoryStore(20)))

3.3 自定义中间件

01.中间件结构
    a.基础结构
        func CustomMiddleware() echo.MiddlewareFunc {
            return func(next echo.HandlerFunc) echo.HandlerFunc {
                return func(c echo.Context) error {
                    // 请求前处理
                    return next(c)
                }
            }
        }

02.请求前处理
    a.JWT认证
        func JWTAuth() echo.MiddlewareFunc {
            return func(next echo.HandlerFunc) echo.HandlerFunc {
                return func(c echo.Context) error {
                    token := c.Request().Header.Get("Authorization")
                    if token == "" {
                        return echo.NewHTTPError(401, "未授权")
                    }
                    return next(c)
                }
            }
        }

03.响应后处理
    a.性能统计
        func PerformanceMiddleware() echo.MiddlewareFunc {
            return func(next echo.HandlerFunc) echo.HandlerFunc {
                return func(c echo.Context) error {
                    start := time.Now()
                    err := next(c)
                    latency := time.Since(start)
                    fmt.Printf("耗时: %v\n", latency)
                    return err
                }
            }
        }

04.错误处理
    a.错误捕获
        func ErrorMiddleware() echo.MiddlewareFunc {
            return func(next echo.HandlerFunc) echo.HandlerFunc {
                return func(c echo.Context) error {
                    err := next(c)
                    if err != nil {
                        return echo.NewHTTPError(500, err.Error())
                    }
                    return nil
                }
            }
        }

3.4 中间件顺序

01.注册顺序
    a.执行顺序
        e.Use(middleware.Logger())   // 1
        e.Use(middleware.Recover())  // 2
        e.Use(AuthMiddleware())      // 3

02.中间件组合
    a.功能组合
        api := e.Group("/api")
        api.Use(
            middleware.CORS(),
            middleware.Logger(),
            JWTAuth(),
        )

03.条件中间件
    a.Skipper
        e.Use(middleware.JWTWithConfig(middleware.JWTConfig{
            Skipper: func(c echo.Context) bool {
                return c.Path() == "/login"  // 跳过登录路由
            },
            SigningKey: []byte("secret"),
        }))

04.中间件复用
    a.工厂模式
        func TimeoutMiddleware(timeout time.Duration) echo.MiddlewareFunc {
            return func(next echo.HandlerFunc) echo.HandlerFunc {
                return func(c echo.Context) error {
                    ctx, cancel := context.WithTimeout(c.Request().Context(), timeout)
                    defer cancel()
                    c.SetRequest(c.Request().WithContext(ctx))
                    return next(c)
                }
            }
        }
        e.Use(TimeoutMiddleware(30 * time.Second))

3.5 错误处理

01.HTTPError
    a.创建错误
        return echo.NewHTTPError(404, "用户不存在")
        return echo.NewHTTPError(500).SetInternal(err)

02.错误处理器
    a.自定义处理器
        e.HTTPErrorHandler = func(err error, c echo.Context) {
            code := 500
            message := "服务器错误"
            if he, ok := err.(*echo.HTTPError); ok {
                code = he.Code
                message = he.Message.(string)
            }
            c.JSON(code, map[string]string{"error": message})
        }

03.业务错误
    a.自定义错误
        type BusinessError struct {
            Code    int
            Message string
        }
        func (e *BusinessError) Error() string {
            return e.Message
        }

04.错误响应
    a.统一格式
        type ErrorResponse struct {
            Code    int    `json:"code"`
            Message string `json:"message"`
            Details string `json:"details,omitempty"`
        }

3.6 CORS处理

01.CORS配置
    a.完整配置
        e.Use(middleware.CORSWithConfig(middleware.CORSConfig{
            AllowOrigins: []string{"http://localhost:3000"},
            AllowMethods: []string{echo.GET, echo.POST, echo.PUT, echo.DELETE},
            AllowHeaders: []string{echo.HeaderOrigin, echo.HeaderContentType},
            ExposeHeaders: []string{"X-Total-Count"},
        }))

02.预检请求
    a.OPTIONS处理
        // Echo自动处理OPTIONS预检请求
        e.Use(middleware.CORSWithConfig(middleware.CORSConfig{
            MaxAge: 3600,  // 预检缓存1小时
        }))

03.凭证支持
    a.Cookie支持
        e.Use(middleware.CORSWithConfig(middleware.CORSConfig{
            AllowOrigins: []string{"http://localhost:3000"},
            AllowCredentials: true,
        }))

04.安全实践
    a.白名单
        allowedOrigins := []string{
            "https://example.com",
            "https://app.example.com",
        }
        e.Use(middleware.CORSWithConfig(middleware.CORSConfig{
            AllowOrigins: allowedOrigins,
        }))

4 请求响应

4.1 请求处理

01.请求信息
    a.Request访问
        e.GET("/info", func(c echo.Context) error {
            req := c.Request()
            method := req.Method
            url := req.URL.String()
            userAgent := req.Header.Get("User-Agent")
            return c.JSON(200, map[string]string{
                "method": method,
                "url": url,
                "user_agent": userAgent,
            })
        })

02.参数获取
    a.多种参数
        e.GET("/users/:id", func(c echo.Context) error {
            id := c.Param("id")                    // 路径参数
            page := c.QueryParam("page")          // 查询参数
            sort := c.QueryParam("sort")
            return c.JSON(200, map[string]string{
                "id": id, "page": page, "sort": sort,
            })
        })

03.请求体
    a.JSON绑定
        type User struct {
            Name  string `json:"name" validate:"required"`
            Email string `json:"email" validate:"required,email"`
        }
        e.POST("/users", func(c echo.Context) error {
            u := new(User)
            if err := c.Bind(u); err != nil {
                return err
            }
            if err := c.Validate(u); err != nil {
                return err
            }
            return c.JSON(201, u)
        })

04.请求验证
    a.验证器集成
        import "github.com/go-playground/validator/v10"
        type CustomValidator struct {
            validator *validator.Validate
        }
        func (cv *CustomValidator) Validate(i interface{}) error {
            return cv.validator.Struct(i)
        }
        e.Validator = &CustomValidator{validator: validator.New()}

4.2 响应格式

01.JSON响应
    a.JSON输出
        e.GET("/json", func(c echo.Context) error {
            return c.JSON(200, map[string]interface{}{
                "code": 0,
                "message": "success",
                "data": []string{"item1", "item2"},
            })
        })

02.XML响应
    a.XML输出
        type User struct {
            XMLName xml.Name `xml:"user"`
            Name    string   `xml:"name"`
            Email   string   `xml:"email"`
        }
        e.GET("/xml", func(c echo.Context) error {
            u := User{Name: "Alice", Email: "[email protected]"}
            return c.XML(200, u)
        })

03.String响应
    a.纯文本
        e.GET("/text", func(c echo.Context) error {
            return c.String(200, "Hello, World!")
        })
        e.GET("/html", func(c echo.Context) error {
            return c.HTML(200, "<h1>Hello</h1>")
        })

04.Blob响应
    a.二进制数据
        e.GET("/blob", func(c echo.Context) error {
            data := []byte{0x48, 0x65, 0x6c, 0x6c, 0x6f}
            return c.Blob(200, "application/octet-stream", data)
        })

4.3 模板渲染

01.模板引擎
    a.自定义Renderer
        import "html/template"
        type Template struct {
            templates *template.Template
        }
        func (t *Template) Render(w io.Writer, name string, data interface{}, c echo.Context) error {
            return t.templates.ExecuteTemplate(w, name, data)
        }
        t := &Template{
            templates: template.Must(template.ParseGlob("templates/*.html")),
        }
        e.Renderer = t

02.渲染模板
    a.模板使用
        e.GET("/", func(c echo.Context) error {
            return c.Render(200, "index.html", map[string]interface{}{
                "title": "首页",
                "users": []string{"Alice", "Bob"},
            })
        })

03.静态文件
    a.静态资源
        e.Static("/static", "assets")
        e.File("/favicon.ico", "images/favicon.ico")

04.模板函数
    a.自定义函数
        funcMap := template.FuncMap{
            "upper": strings.ToUpper,
            "formatDate": func(t time.Time) string {
                return t.Format("2006-01-02")
            },
        }
        tmpl := template.New("").Funcs(funcMap)

4.4 文件处理

01.文件上传
    a.单文件上传
        e.POST("/upload", func(c echo.Context) error {
            file, err := c.FormFile("file")
            if err != nil {
                return err
            }
            src, _ := file.Open()
            defer src.Close()
            dst, _ := os.Create(filepath.Join("uploads", file.Filename))
            defer dst.Close()
            io.Copy(dst, src)
            return c.JSON(200, map[string]string{"filename": file.Filename})
        })

02.文件保存
    a.安全保存
        filename := filepath.Base(file.Filename)
        ext := filepath.Ext(filename)
        newName := fmt.Sprintf("%d%s", time.Now().Unix(), ext)
        dst := filepath.Join("uploads", newName)
        c.SaveFile(file, dst)

03.文件下载
    a.文件响应
        e.GET("/download/:file", func(c echo.Context) error {
            return c.File("files/" + c.Param("file"))
        })
        e.GET("/attachment/:file", func(c echo.Context) error {
            return c.Attachment("files/"+c.Param("file"), "download.pdf")
        })

04.文件流
    a.流式传输
        e.GET("/stream", func(c echo.Context) error {
            c.Response().Header().Set(echo.HeaderContentType, "application/octet-stream")
            c.Response().WriteHeader(200)
            for i := 0; i < 10; i++ {
                c.Response().Write([]byte(fmt.Sprintf("chunk %d\n", i)))
                c.Response().Flush()
                time.Sleep(time.Second)
            }
            return nil
        })

4.5 流式处理

01.SSE
    a.Server-Sent Events
        e.GET("/events", func(c echo.Context) error {
            c.Response().Header().Set("Content-Type", "text/event-stream")
            c.Response().Header().Set("Cache-Control", "no-cache")
            c.Response().WriteHeader(200)
            for i := 0; i < 10; i++ {
                fmt.Fprintf(c.Response(), "data: %s\n\n", time.Now())
                c.Response().Flush()
                time.Sleep(time.Second)
            }
            return nil
        })

02.WebSocket
    a.WebSocket连接
        import "github.com/gorilla/websocket"
        var upgrader = websocket.Upgrader{}
        e.GET("/ws", func(c echo.Context) error {
            ws, err := upgrader.Upgrade(c.Response(), c.Request(), nil)
            if err != nil {
                return err
            }
            defer ws.Close()
            for {
                _, msg, err := ws.ReadMessage()
                if err != nil {
                    break
                }
                ws.WriteMessage(websocket.TextMessage, msg)
            }
            return nil
        })

03.分块传输
    a.Chunked编码
        e.GET("/chunked", func(c echo.Context) error {
            c.Response().Header().Set("Transfer-Encoding", "chunked")
            c.Response().WriteHeader(200)
            for i := 0; i < 5; i++ {
                c.Response().Write([]byte(fmt.Sprintf("Chunk %d\n", i)))
                c.Response().Flush()
            }
            return nil
        })

04.性能优化
    a.缓冲控制
        buf := bufio.NewWriter(c.Response())
        buf.WriteString("data")
        buf.Flush()

4.6 Cookie和Session

01.Cookie操作
    a.Cookie设置
        e.GET("/setcookie", func(c echo.Context) error {
            cookie := new(http.Cookie)
            cookie.Name = "session"
            cookie.Value = "abc123"
            cookie.Expires = time.Now().Add(24 * time.Hour)
            c.SetCookie(cookie)
            return c.String(200, "cookie set")
        })
        e.GET("/getcookie", func(c echo.Context) error {
            cookie, _ := c.Cookie("session")
            return c.String(200, cookie.Value)
        })

02.Session管理
    a.Session示例
        import "github.com/gorilla/sessions"
        var store = sessions.NewCookieStore([]byte("secret"))
        e.GET("/login", func(c echo.Context) error {
            session, _ := store.Get(c.Request(), "session")
            session.Values["user_id"] = 123
            session.Save(c.Request(), c.Response())
            return c.String(200, "logged in")
        })

03.安全实践
    a.安全Cookie
        cookie := new(http.Cookie)
        cookie.Name = "token"
        cookie.Value = "secret"
        cookie.HttpOnly = true
        cookie.Secure = true
        cookie.SameSite = http.SameSiteStrictMode
        c.SetCookie(cookie)

04.状态管理
    a.用户状态
        session.Values["cart"] = []string{"item1", "item2"}
        session.Values["logged_in"] = true
        session.Save(c.Request(), c.Response())

5 数据验证

5.1 验证器

01.validator.v10
    a.基础验证
        type User struct {
            Name  string `validate:"required,min=3,max=20"`
            Email string `validate:"required,email"`
            Age   int    `validate:"gte=0,lte=120"`
        }
        validate := validator.New()
        err := validate.Struct(user)

02.内置验证
    a.常用标签
        type Product struct {
            Name  string  `validate:"required"`
            Price float64 `validate:"required,gt=0"`
            Email string  `validate:"omitempty,email"`
            URL   string  `validate:"omitempty,url"`
        }

03.自定义验证
    a.注册验证器
        validate.RegisterValidation("phone", func(fl validator.FieldLevel) bool {
            phone := fl.Field().String()
            matched, _ := regexp.MatchString(`^1[3-9]\d{9}$`, phone)
            return matched
        })

04.验证组
    a.复杂验证
        type Article struct {
            Tags []string `validate:"required,min=1,max=5,dive,min=2,max=20"`
        }

5.2 内置验证

01.基础验证
    a.基础标签
        type User struct {
            Name  string `validate:"required"`
            Email string `validate:"omitempty,email"`
            Age   int    `validate:"-"`  // 忽略验证
        }

02.字符串验证
    a.字符串规则
        type Article struct {
            Title string `validate:"required,min=5,max=100"`
            Slug  string `validate:"required,alpha"`
            Email string `validate:"email"`
            URL   string `validate:"url"`
        }

03.数值验证
    a.数值规则
        type Product struct {
            Price    float64 `validate:"required,gt=0,lt=10000"`
            Stock    int     `validate:"gte=0"`
            Status   string  `validate:"oneof=draft published archived"`
        }

04.时间验证
    a.时间格式
        type Event struct {
            StartTime time.Time `validate:"required"`
            EndTime   time.Time `validate:"required,gtfield=StartTime"`
        }

5.3 自定义验证

01.注册验证器
    a.自定义规则
        validate.RegisterValidation("phone", func(fl validator.FieldLevel) bool {
            phone := fl.Field().String()
            return regexp.MustCompile(`^1[3-9]\d{9}$`).MatchString(phone)
        })

02.验证逻辑
    a.验证函数
        func validateUsername(fl validator.FieldLevel) bool {
            username := fl.Field().String()
            if len(username) < 3 || len(username) > 20 {
                return false
            }
            return regexp.MustCompile(`^[a-zA-Z0-9_]+$`).MatchString(username)
        }

03.错误消息
    a.自定义消息
        if err := validate.Struct(user); err != nil {
            for _, err := range err.(validator.ValidationErrors) {
                fmt.Printf("字段 %s 验证失败: %s\n", err.Field(), err.Tag())
            }
        }

04.复杂验证
    a.跨字段验证
        type PasswordReset struct {
            Password        string `validate:"required,min=6"`
            ConfirmPassword string `validate:"required,eqfield=Password"`
        }

5.4 错误处理

01.验证错误
    a.错误处理
        if err := c.Validate(user); err != nil {
            validationErrors := err.(validator.ValidationErrors)
            errors := make(map[string]string)
            for _, e := range validationErrors {
                errors[e.Field()] = e.Tag()
            }
            return c.JSON(400, errors)
        }

02.错误格式化
    a.格式化输出
        type ErrorResponse struct {
            Code    int               `json:"code"`
            Message string            `json:"message"`
            Errors  map[string]string `json:"errors,omitempty"`
        }

03.国际化
    a.多语言支持
        import "github.com/go-playground/validator/v10/translations/zh"
        translator, _ := ut.New(zh.New()).GetTranslator("zh")
        zh.RegisterDefaultTranslations(validate, translator)

04.统一响应
    a.统一错误
        func handleValidationError(err error) map[string]string {
            errors := make(map[string]string)
            for _, e := range err.(validator.ValidationErrors) {
                errors[e.Field()] = e.Translate(translator)
            }
            return errors
        }

5.5 国际化

01.翻译器
    a.翻译配置
        import ut "github.com/go-playground/universal-translator"
        import "github.com/go-playground/validator/v10/translations/en"
        uni := ut.New(en.New())
        trans, _ := uni.GetTranslator("en")

02.错误翻译
    a.翻译注册
        en.RegisterDefaultTranslations(validate, trans)
        validate.RegisterTranslation("phone", trans, func(ut ut.Translator) error {
            return ut.Add("phone", "{0} 必须是有效的手机号", true)
        }, func(ut ut.Translator, fe validator.FieldError) string {
            t, _ := ut.T("phone", fe.Field())
            return t
        })

03.语言切换
    a.动态语言
        lang := c.Request().Header.Get("Accept-Language")
        trans, _ := uni.GetTranslator(lang)

04.最佳实践
    a.翻译缓存
        var translators = make(map[string]ut.Translator)
        translators["en"], _ = uni.GetTranslator("en")
        translators["zh"], _ = uni.GetTranslator("zh")

6 高级功能

6.1 WebSocket

01.连接升级
    a.WebSocket升级
        var upgrader = websocket.Upgrader{
            CheckOrigin: func(r *http.Request) bool { return true },
        }
        e.GET("/ws", func(c echo.Context) error {
            ws, _ := upgrader.Upgrade(c.Response(), c.Request(), nil)
            defer ws.Close()
            for {
                _, msg, _ := ws.ReadMessage()
                ws.WriteMessage(websocket.TextMessage, msg)
            }
        })

02.消息处理
    a.消息读写
        ws.WriteMessage(websocket.TextMessage, []byte("Hello"))
        msgType, msg, err := ws.ReadMessage()

03.连接管理
    a.心跳检测
        ticker := time.NewTicker(30 * time.Second)
        go func() {
            for range ticker.C {
                ws.WriteMessage(websocket.PingMessage, nil)
            }
        }()

04.广播消息
    a.房间管理
        type Hub struct {
            clients map[*websocket.Conn]bool
            broadcast chan []byte
        }
        func (h *Hub) run() {
            for msg := range h.broadcast {
                for client := range h.clients {
                    client.WriteMessage(websocket.TextMessage, msg)
                }
            }
        }

6.2 HTTP/2

01.HTTP/2支持
    a.启用HTTP/2
        e.StartTLS(":443", "cert.pem", "key.pem")  // 自动启用HTTP/2

02.Server Push
    a.推送资源
        e.GET("/", func(c echo.Context) error {
            pusher, ok := c.Response().Writer.(http.Pusher)
            if ok {
                pusher.Push("/style.css", nil)
            }
            return c.HTML(200, "<html>...</html>")
        })

03.多路复用
    a.并发请求
        // HTTP/2自动支持多路复用，无需额外配置

04.配置优化
    a.性能调优
        s := &http.Server{
            MaxHeaderBytes: 1 << 20,
        }
        e.StartServer(s)

6.3 优雅关闭

01.信号处理
    a.优雅退出
        quit := make(chan os.Signal, 1)
        signal.Notify(quit, os.Interrupt)
        go func() {
            <-quit
            ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
            defer cancel()
            e.Shutdown(ctx)
        }()
        e.Start(":8080")

02.Shutdown
    a.关闭服务
        ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
        defer cancel()
        if err := e.Shutdown(ctx); err != nil {
            e.Logger.Fatal(err)
        }

03.资源清理
    a.清理资源
        defer db.Close()
        defer cache.Close()

04.状态保存
    a.持久化
        // 保存未完成的任务
        saveState()

6.4 性能优化

01.路由优化
    a.路由设计
        // 避免过深嵌套
        e.GET("/api/v1/users/:id", getUser)  // 好
        // 而不是
        api := e.Group("/api")
        v1 := api.Group("/v1")
        users := v1.Group("/users")

02.中间件优化
    a.按需加载
        public := e.Group("/public")
        public.GET("/health", healthCheck)  // 无中间件

        api := e.Group("/api")
        api.Use(middleware.JWT([]byte("secret")))  // 只在API路由

03.序列化优化
    a.使用sonic
        import "github.com/bytedance/sonic"
        data, _ := sonic.Marshal(user)
        c.Blob(200, "application/json", data)

04.连接池
    a.数据库连接池
        db.SetMaxOpenConns(100)
        db.SetMaxIdleConns(10)
        db.SetConnMaxLifetime(time.Hour)

6.5 安全性

01.HTTPS
    a.TLS配置
        e.StartTLS(":443", "cert.pem", "key.pem")
        // 或使用AutoTLS
        e.StartAutoTLS(":443")

02.安全头
    a.安全响应头
        e.Use(middleware.SecureWithConfig(middleware.SecureConfig{
            XSSProtection:      "1; mode=block",
            ContentTypeNosniff: "nosniff",
            XFrameOptions:      "SAMEORIGIN",
            HSTSMaxAge:         3600,
        }))

03.输入验证
    a.XSS防护
        import "html"
        safeInput := html.EscapeString(userInput)

04.限流
    a.速率限制
        e.Use(middleware.RateLimiter(middleware.NewRateLimiterMemoryStore(20)))

7 实战与部署

7.1 API开发

01.RESTful设计
    a.CRUD API
        e.POST("/api/users", createUser)
        e.GET("/api/users", listUsers)
        e.GET("/api/users/:id", getUser)
        e.PUT("/api/users/:id", updateUser)
        e.DELETE("/api/users/:id", deleteUser)

02.CRUD实现
    a.完整示例
        func listUsers(c echo.Context) error {
            page, _ := strconv.Atoi(c.QueryParam("page"))
            users, total := getUsersWithPage(page, 10)
            return c.JSON(200, map[string]interface{}{
                "data": users,
                "total": total,
            })
        }

03.分页排序
    a.分页实现
        type PageQuery struct {
            Page     int    `query:"page"`
            PageSize int    `query:"page_size"`
            Sort     string `query:"sort"`
        }

04.API文档
    a.Swagger集成
        import "github.com/swaggo/echo-swagger"
        e.GET("/swagger/*", echoSwagger.WrapHandler)

7.2 微服务

01.服务拆分
    a.领域划分
        // 用户服务
        userService := e.Group("/user-service")
        // 订单服务
        orderService := e.Group("/order-service")

02.服务通信
    a.HTTP调用
        resp, _ := http.Get("http://user-service/api/users/123")

03.配置管理
    a.配置中心
        import "github.com/spf13/viper"
        viper.SetConfigName("config")
        viper.ReadInConfig()

04.监控告警
    a.日志监控
        e.Use(middleware.Logger())

7.3 测试

01.单元测试
    a.HTTP测试
        func TestGetUser(t *testing.T) {
            e := echo.New()
            req := httptest.NewRequest(http.MethodGet, "/users/1", nil)
            rec := httptest.NewRecorder()
            c := e.NewContext(req, rec)
            c.SetParamNames("id")
            c.SetParamValues("1")

            if assert.NoError(t, getUser(c)) {
                assert.Equal(t, 200, rec.Code)
            }
        }

02.集成测试
    a.完整流程
        func TestUserFlow(t *testing.T) {
            e := setupTestServer()
            // 创建用户
            req := httptest.NewRequest(http.MethodPost, "/users", strings.NewReader(`{"name":"test"}`))
            rec := httptest.NewRecorder()
            e.ServeHTTP(rec, req)
            assert.Equal(t, 201, rec.Code)
        }

03.性能测试
    a.基准测试
        func BenchmarkGetUser(b *testing.B) {
            for i := 0; i < b.N; i++ {
                getUser(c)
            }
        }

04.测试覆盖
    a.覆盖率
        go test -cover ./...
        go test -coverprofile=coverage.out

7.4 部署

01.编译部署
    a.交叉编译
        GOOS=linux GOARCH=amd64 go build -o app

02.容器化
    a.Dockerfile
        FROM golang:1.21-alpine AS builder
        WORKDIR /app
        COPY . .
        RUN go build -o main .

        FROM alpine:latest
        COPY --from=builder /app/main /main
        CMD ["/main"]

03.Kubernetes
    a.Deployment
        apiVersion: apps/v1
        kind: Deployment
        metadata:
          name: echo-app
        spec:
          replicas: 3
          template:
            spec:
              containers:
              - name: app
                image: echo-app:latest
                ports:
                - containerPort: 8080

04.CI/CD
    a.GitHub Actions
        name: Deploy
        on: push
        jobs:
          build:
            runs-on: ubuntu-latest
            steps:
              - uses: actions/checkout@v2
              - run: go build
              - run: docker build -t app .

7.5 最佳实践

01.项目结构
    a.分层架构
        project/
        ├── cmd/server/main.go
        ├── internal/
        │   ├── handler/
        │   ├── service/
        │   └── repository/
        └── pkg/

02.错误处理
    a.统一错误
        type APIError struct {
            Code    int    `json:"code"`
            Message string `json:"message"`
        }
        e.HTTPErrorHandler = customErrorHandler

03.安全实践
    a.安全配置
        e.Use(middleware.Secure())
        e.Use(middleware.CSRF())
        e.Validator = &CustomValidator{}

04.性能实践
    a.缓存策略
        var cache = make(map[string]interface{})
        func getWithCache(key string) interface{} {
            if val, ok := cache[key]; ok {
                return val
            }
            val := fetchFromDB(key)
            cache[key] = val
            return val
        }