Go语言如何利用Gin框架与GORM打造电商级高性能的WebAPI

├── config
│   └── config.yaml       # 配置文件
├── internal
│   ├── models            # 数据模型
│   │   └── product.go
│   ├── handlers         # 处理函数
│   │   └── product.go
│   └── middleware       # 自定义中间件
│       └── logger.go
├── main.go
└── go.mod

// main.go
package main

import (
    "github.com/gin-gonic/gin"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
    "project/internal/handlers"
    "project/internal/middleware"
)

func main() {
    // 初始化配置
    config := LoadConfig()
    
    // 数据库连接
    dsn := "host=localhost user=gorm password=gorm dbname=gorm port=5432"
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("数据库连接失败")
    }
    
    // 自动迁移数据结构
    db.AutoMigrate(&models.Product{})
    
    // 创建Gin引擎
    router := gin.Default()
    
    // 注册中间件
    router.Use(middleware.RequestLogger())
    
    // 商品路由组
    productGroup := router.Group("/api/v1/products")
    {
        productGroup.GET("", handlers.GetProducts(db))
        productGroup.GET("/:id", handlers.GetProduct(db))
        productGroup.POST("", handlers.CreateProduct(db))
        productGroup.PUT("/:id", handlers.UpdateProduct(db))
        productGroup.DELETE("/:id", handlers.DeleteProduct(db))
    }
    
    // 启动服务
    router.Run(":8080")
}

// handlers/product.go
package handlers

import (
    "net/http"
    "project/internal/models"
    "github.com/gin-gonic/gin"
    "gorm.io/gorm"
)

func GetProducts(db *gorm.DB) gin.HandlerFunc {
    return func(c *gin.Context) {
        var products []models.Product
        if result := db.Find(&products); result.Error != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": "查询失败"})
            return
        }
        c.JSON(http.StatusOK, products)
    }
}

// 其他处理函数类似，此处省略...

// middleware/logger.go
package middleware

import (
    "github.com/gin-gonic/gin"
    "go.uber.org/zap"
    "time"
)

func RequestLogger() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        
        // 处理请求
        c.Next()
        
        // 记录日志
        latency := time.Since(start)
        logger.Info("request",
            zap.String("method", c.Request.Method),
            zap.String("path", c.Request.URL.Path),
            zap.Int("status", c.Writer.Status()),
            zap.Duration("latency", latency),
        )
    }
}

// 处理批量请求的示例
func ProcessBatch(requests []Request) {
    sem := make(chan struct{}, 100) // 控制并发数
    
    for _, req := range requests {
        sem <- struct{}{}
        go func(r Request) {
            defer func() { <-sem }()
            processSingle(r)
        }(req)
    }
    
    // 等待所有goroutine完成
    for i := 0; i < cap(sem); i++ {
        sem <- struct{}{}
    }
}

// 错误示例：N+1查询问题
var users []User
db.Find(&users)
for _, user := range users {
    var orders []Order
    db.Where("user_id = ?", user.ID).Find(&orders)
}

// 正确方式：预加载关联数据
db.Preload("Orders").Find(&users)

# 更新所有依赖
go get -u ./...
# 清理无用依赖
go mod tidy

if err := db.First(&product).Error; err != nil {
    return fmt.Errorf("查询商品失败: %w", err)
}

type Config struct {
    DBHost     string `mapstructure:"DB_HOST"`
    DBPort     int    `mapstructure:"DB_PORT"`
    JWTSecret  string `mapstructure:"JWT_SECRET"`
}

func LoadConfig() Config {
    viper.AutomaticEnv()
    viper.SetDefault("DB_PORT", 5432)
    
    var config Config
    if err := viper.Unmarshal(&config); err != nil {
        panic("配置加载失败")
    }
    return config
}

func InitializeLogger() *zap.Logger {
    config := zap.NewProductionConfig()
    config.OutputPaths = []string{
        "logs/api.log",
        "stderr",
    }
    logger, _ := config.Build()
    return logger
}