Gin + 泛型：告别“复制粘贴“的魔法时刻

🎬 开场故事：深夜，工程师小明盯着屏幕，第 10 次复制 CreateUser 代码，改类型名为 CreateProduct… 突然他喃喃自语：“这代码，怎么长得跟我上周写的一模一样？” 就在那一刻，Go 1.18 的泛型之光，照进了他的世界。✨

🔄 第一章：曾经的痛——"复制粘贴工程师"的日常

先看看没有泛型时，我们是怎么写 CRUD 的：

// 创建用户
func CreateUser(c *gin.Context) {
    var user User
    if err := c.ShouldBindJSON(&user); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }
    if err := db.Create(&user).Error; err != nil {
        c.JSON(500, gin.H{"error": "create failed"})
        return
    }
    c.JSON(201, user)
}

// 创建产品（复制上面代码，改 User→Product）
func CreateProduct(c *gin.Context) {
    var product Product  // 👈 只改了这里
    if err := c.ShouldBindJSON(&product); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }
    if err := db.Create(&product).Error; err != nil {
        c.JSON(500, gin.H{"error": "create failed"})
        return
    }
    c.JSON(201, product)
}

// 创建订单...创建文章...创建评论... 🤯

💡 个人经验：我曾经在一个项目里数了数，类似的 Create 函数有 23 个！改一个公共逻辑（比如加日志），要改 23 处… 那酸爽，谁改谁知道。

🪄 第二章：泛型登场——“一套代码，万物通用”

Go 1.18 引入泛型后，我们可以这样"降维打击"：

第一步：定义"能创建自己"的接口

// 任何想被"通用创建"的类型，都要实现这个接口
type Creatable interface {
    // 标记方法，实际创建逻辑在外部（如 GORM）
}

第二步：写一个"万能创建函数"

// 🎯 核心魔法：泛型函数，[T any] 表示 T 可以是任何类型
func CreateHandler[T Creatable]() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 1️⃣ 自动实例化泛型类型（需要工厂函数）
        var entity T
        
        // 2️⃣ 绑定 JSON 到实体（泛型也能用指针！）
        if err := c.ShouldBindJSON(&entity); err != nil {
            c.JSON(400, gin.H{"error": "invalid params"})
            return
        }
        
        // 3️⃣ 创建到数据库（这里假设用 GORM）
        if err := db.Create(&entity).Error; err != nil {
            c.JSON(500, gin.H{"error": "create failed"})
            return
        }
        
        // 4️⃣ 返回结果
        c.JSON(201, entity)
    }
}

💡 关键细节：因为泛型类型 T 在编译时才能确定，我们需要一个"工厂函数"来实例化它，下面会讲。

第三步：注册路由——从 20 行变 1 行！

// 传统写法（每个资源都要写一个函数）
router.POST("/users", CreateUser)
router.POST("/products", CreateProduct)
router.POST("/orders", CreateOrder)

// 🎯 泛型写法（一行一个，清爽！）
router.POST("/users", CreateHandler[User]())
router.POST("/products", CreateHandler[Product]())
router.POST("/orders", CreateHandler[Order]())

🎉 效果：新增一个 Article 资源？只需定义结构体 + 注册一行路由，零重复代码！

🛠️ 第三章：进阶技巧——让泛型更"实用"

技巧1：加"工厂函数"，解决泛型实例化问题

// 改进版：传入工厂函数，自动创建泛型实例
func CreateHandler[T Creatable](factory func() T) gin.HandlerFunc {
    return func(c *gin.Context) {
        entity := factory()  // ✅ 用工厂函数实例化
        if err := c.ShouldBindJSON(&entity); err != nil {
            c.JSON(400, gin.H{"error": err.Error()})
            return
        }
        // ... 创建逻辑
        c.JSON(201, entity)
    }
}

// 使用：传入一个"返回新实例"的函数
router.POST("/users", CreateHandler(func() User { return User{} }))
router.POST("/products", CreateHandler(func() Product { return Product{} }))

💡 为什么需要工厂函数：泛型 T 在编译时才知道具体类型，运行时无法 new(T)，工厂函数是优雅的解决方案。

技巧2：加"类型约束"，确保泛型"能干活的"

// 定义约束：要求类型必须有 ID 字段 + 能验证自己
type Resource interface {
    Creatable
    GetID() uint
    Validate() error  // 自定义验证逻辑
}

// 泛型函数加约束
func CreateHandler[T Resource](factory func() T) gin.HandlerFunc {
    return func(c *gin.Context) {
        entity := factory()
        
        // ✅ 编译期保证：任何传入的 T 都有 Validate() 方法
        if err := entity.Validate(); err != nil {
            c.JSON(400, gin.H{"error": err.Error()})
            return
        }
        // ... 后续逻辑
    }
}

🎯 收益：把业务规则（如"用户名不能为空"）下沉到类型方法，泛型函数只关心"流程"，职责清晰。

技巧3：组合"通用响应"，前端对接更友好

// 统一响应结构
type Response[T any] struct {
    Code    int    `json:"code"`
    Message string `json:"message"`
    Data    T      `json:"data,omitempty"`
}

// 泛型助手函数
func Success[T any](c *gin.Context, data T) {
    c.JSON(200, Response[T]{
        Code: 200, Message: "success", Data: data,
    })
}

func Fail(c *gin.Context, err error) {
    c.JSON(400, Response[any]{
        Code: 400, Message: err.Error(),
    })
}

// 在泛型 Handler 里用
func CreateHandler[T Resource](factory func() T) gin.HandlerFunc {
    return func(c *gin.Context) {
        entity := factory()
        if err := c.ShouldBindJSON(&entity); err != nil {
            Fail(c, err)  // ✅ 泛型也能传 any
            return
        }
        // ...
        Success(c, entity)  // ✅ 类型自动推导
    }
}

💡 效果：前端收到统一格式 {code, message, data}，对接效率翻倍。

🎁 第四章：完整示例——从 0 到 1 实现通用 CRUD

// 1️⃣ 定义资源约束
type Resource interface {
    GetID() uint
    TableName() string  // GORM 需要
}

// 2️⃣ 通用 Create Handler
func Create[T Resource](factory func() T) gin.HandlerFunc {
    return func(c *gin.Context) {
        entity := factory()
        if err := c.ShouldBindJSON(&entity); err != nil {
            c.JSON(400, gin.H{"error": err.Error()})
            return
        }
        if err := db.Create(&entity).Error; err != nil {
            c.JSON(500, gin.H{"error": "create failed"})
            return
        }
        c.JSON(201, entity)
    }
}

// 3️⃣ 通用 Get Handler（按 ID 查询）
func GetByID[T Resource](factory func() T) gin.HandlerFunc {
    return func(c *gin.Context) {
        id := c.Param("id")
        entity := factory()
        if err := db.Where("id = ?", id).First(&entity).Error; err != nil {
            c.JSON(404, gin.H{"error": "not found"})
            return
        }
        c.JSON(200, entity)
    }
}

// 4️⃣ 注册路由（清爽到哭😭）
func RegisterUserRoutes(r *gin.RouterGroup) {
    r.POST("/users", Create(func() User { return User{} }))
    r.GET("/users/:id", GetByID(func() User { return User{} }))
    // Update/Delete 同理...
}

func RegisterProductRoutes(r *gin.RouterGroup) {
    r.POST("/products", Create(func() Product { return Product{} }))
    r.GET("/products/:id", GetByID(func() Product { return Product{} }))
}

🌟 关键心得：泛型不是"炫技"，而是把重复的逻辑抽象成模板，让开发者专注业务差异。

💬 最后

“好的代码，应该像乐高：基础模块通用，组合方式无限。”

• 如果你还在"复制粘贴"写 CRUD → 试试泛型，解放双手
• 如果担心泛型复杂 → 从 CreateHandler 一个函数开始，渐进式改造
• 如果团队有代码审查 → 把泛型约束写清楚，新人也能快速上手

// 下次新增资源时，你可以淡定地说：
// "给我 5 分钟，定义结构体 + 注册一行路由，搞定！" ☕

🌙 彩蛋：泛型 + Gin + GORM 的组合，能让你的 CRUD 代码减少 70%。省下的时间，不如去陪陪家人？❤️