Gin + GORM 企业级架构实战：从六边形架构到大规模生产模式

package repo

import (
    "context"
    "enterprise-app/domain/model"
)

// IOrderRepo 是订单仓储的端口（Port）
// 领域层定义"需要什么"，不关心"怎么实现"
type IOrderRepo interface {
    Create(ctx context.Context, order *model.Order) error
    FindByID(ctx context.Context, id string) (*model.Order, error)
    Update(ctx context.Context, order *model.Order) error
    FindByUserID(ctx context.Context, userID string) ([]*model.Order, error)
}

// IOrderCacheRepo 缓存端口
type IOrderCacheRepo interface {
    Get(ctx context.Context, id string) (*model.Order, error)
    Set(ctx context.Context, order *model.Order) error
    Invalidate(ctx context.Context, id string) error
}

package mysql

import (
    "context"
    "enterprise-app/domain/model"
    "enterprise-app/domain/repo"
    "gorm.io/gorm"
)

// 编译期检查：确保 OrderRepo 实现了 IOrderRepo 接口
var _ repo.IOrderRepo = (*OrderRepo)(nil)

type OrderRepo struct {
    db *gorm.DB
}

func NewOrderRepo(db *gorm.DB) *OrderRepo {
    return &OrderRepo{db: db}
}

func (r *OrderRepo) Create(ctx context.Context, order *model.Order) error {
    return r.db.WithContext(ctx).Create(order).Error
}

func (r *OrderRepo) FindByID(ctx context.Context, id string) (*model.Order, error) {
    var order model.Order
    err := r.db.WithContext(ctx).Where("id = ?", id).First(&order).Error
    if err != nil {
        return nil, err
    }
    return &order, nil
}

func (r *OrderRepo) Update(ctx context.Context, order *model.Order) error {
    return r.db.WithContext(ctx).Save(order).Error
}

func (r *OrderRepo) FindByUserID(ctx context.Context, userID string) ([]*model.Order, error) {
    var orders []*model.Order
    err := r.db.WithContext(ctx).Where("user_id = ?", userID).Find(&orders).Error
    return orders, err
}

package aggregate

import (
    "errors"
    "time"
    "enterprise-app/domain/vo"
)

// Order 是订单聚合根
// 所有字段私有化，确保状态始终有效
type Order struct {
    id          string
    userID      string
    items       []OrderItem
    status      vo.OrderStatus
    totalAmount vo.Money
    createdAt   time.Time
    updatedAt   time.Time
}

type OrderItem struct {
    productID string
    quantity  int
    price     vo.Money
}

// NewOrder 创建订单，包含完整校验
func NewOrder(id, userID string, items []OrderItem) (*Order, error) {
    if id == "" {
        return nil, errors.New("order id cannot be empty")
    }
    if userID == "" {
        return nil, errors.New("user id cannot be empty")
    }
    if len(items) == 0 {
        return nil, errors.New("order must have at least one item")
    }

    order := &Order{
        id:        id,
        userID:    userID,
        items:     items,
        status:    vo.OrderStatusPending,
        createdAt: time.Now(),
        updatedAt: time.Now(),
    }
    order.recalculateTotal()
    return order, nil
}

// 行为方法：不暴露数据，而是表达"实体能做什么"
func (o *Order) Confirm() error {
    if o.status != vo.OrderStatusPending {
        return errors.New("only pending orders can be confirmed")
    }
    o.status = vo.OrderStatusConfirmed
    o.updatedAt = time.Now()
    return nil
}

func (o *Order) Cancel() error {
    if o.status == vo.OrderStatusCancelled {
        return errors.New("order is already cancelled")
    }
    if o.status == vo.OrderStatusShipped {
        return errors.New("shipped orders cannot be cancelled")
    }
    o.status = vo.OrderStatusCancelled
    o.updatedAt = time.Now()
    return nil
}

func (o *Order) Ship() error {
    if o.status != vo.OrderStatusConfirmed {
        return errors.New("only confirmed orders can be shipped")
    }
    o.status = vo.OrderStatusShipped
    o.updatedAt = time.Now()
    return nil
}

// 纯业务计算可作为独立函数
func (o *Order) recalculateTotal() {
    var total int64
    for _, item := range o.items {
        total += item.price.Amount() * int64(item.quantity)
    }
    o.totalAmount = vo.NewMoney(total, "USD")
}

// 只读访问器
func (o *Order) ID() string              { return o.id }
func (o *Order) UserID() string           { return o.userID }
func (o *Order) Status() vo.OrderStatus   { return o.status }
func (o *Order) TotalAmount() vo.Money    { return o.totalAmount }

package vo

import "fmt"

// Money 是不可变值对象
type Money struct {
    amount   int64  // 以分为单位，避免浮点精度问题
    currency string
}

func NewMoney(amount int64, currency string) Money {
    return Money{amount: amount, currency: currency}
}

func (m Money) Amount() int64    { return m.amount }
func (m Money) Currency() string { return m.currency }

func (m Money) Add(other Money) (Money, error) {
    if m.currency != other.currency {
        return Money{}, fmt.Errorf("cannot add different currencies: %s and %s",
            m.currency, other.currency)
    }
    return NewMoney(m.amount+other.amount, m.currency), nil
}

func (m Money) Equals(other Money) bool {
    return m.amount == other.amount && m.currency == other.currency
}

// OrderStatus 值对象
type OrderStatus string

const (
    OrderStatusPending   OrderStatus = "pending"
    OrderStatusConfirmed OrderStatus = "confirmed"
    OrderStatusShipped   OrderStatus = "shipped"
    OrderStatusCancelled OrderStatus = "cancelled"
)

func (s OrderStatus) IsZero() bool { return s == "" }

package event

import "time"

// DomainEvent 基础接口
type DomainEvent interface {
    EventName() string
    OccurredAt() time.Time
    AggregateID() string
}

type OrderCreated struct {
    OrderID     string
    UserID      string
    TotalAmount int64
    OccurredOn  time.Time
}

func (e OrderCreated) EventName() string    { return "order.created" }
func (e OrderCreated) OccurredAt() time.Time { return e.OccurredOn }
func (e OrderCreated) AggregateID() string   { return e.OrderID }

type OrderCancelled struct {
    OrderID    string
    Reason     string
    OccurredOn time.Time
}

func (e OrderCancelled) EventName() string    { return "order.cancelled" }
func (e OrderCancelled) OccurredAt() time.Time { return e.OccurredOn }
func (e OrderCancelled) AggregateID() string   { return e.OrderID }

// EventBus 领域事件总线接口
type EventBus interface {
    Publish(ctx context.Context, events ...DomainEvent) error
    Subscribe(eventName string, handler EventHandler) error
}

type EventHandler interface {
    Handle(ctx context.Context, event DomainEvent) error
}

package repo

import "context"

type OrderRepository interface {
    // Create 持久化新订单
    Create(ctx context.Context, order *aggregate.Order) error

    // GetByID 加载订单聚合根
    GetByID(ctx context.Context, id string) (*aggregate.Order, error)

    // Update 使用闭包模式，确保读取-修改-写入的原子性
    // updateFn 接收当前状态，返回修改后的聚合根
    Update(ctx context.Context, id string,
        updateFn func(ctx context.Context, order *aggregate.Order) error,
    ) error
}

go 1.22

use (
    ./services/order
    ./services/payment
    ./services/inventory
    ./services/notification
    ./shared
    ./platform
)

package command

import (
    "context"
    "enterprise-app/domain/event"
    "enterprise-app/domain/repo"
)

// ConfirmOrder 命令对象
type ConfirmOrder struct {
    OrderID string
    UserID  string
}

// ConfirmOrderHandler 命令处理器
type ConfirmOrderHandler struct {
    orderRepo repo.OrderRepository
    eventBus  event.EventBus
}

func NewConfirmOrderHandler(
    orderRepo repo.OrderRepository,
    eventBus event.EventBus,
) ConfirmOrderHandler {
    return ConfirmOrderHandler{
        orderRepo: orderRepo,
        eventBus:  eventBus,
    }
}

func (h ConfirmOrderHandler) Handle(ctx context.Context, cmd ConfirmOrder) error {
    // 使用闭包更新模式
    return h.orderRepo.Update(ctx, cmd.OrderID,
        func(ctx context.Context, order *aggregate.Order) error {
            // 业务逻辑在领域层
            if err := order.Confirm(); err != nil {
                return err
            }

            // 发布领域事件
            return h.eventBus.Publish(ctx, event.OrderConfirmed{
                OrderID:    order.ID(),
                UserID:     order.UserID(),
                OccurredOn: time.Now(),
            })
        },
    )
}

package query

import "context"

// OrderView 读模型（为查询优化的扁平结构）
type OrderView struct {
    ID          string  `json:"id"`
    UserName    string  `json:"user_name"`
    Status      string  `json:"status"`
    TotalAmount float64 `json:"total_amount"`
    ItemCount   int     `json:"item_count"`
    CreatedAt   string  `json:"created_at"`
}

type GetOrderQuery struct {
    OrderID string
}

type GetOrderHandler struct {
    readDB ReadModelDB // 专用读库/缓存
}

func (h GetOrderHandler) Handle(ctx context.Context, q GetOrderQuery) (OrderView, error) {
    return h.readDB.GetOrderView(ctx, q.OrderID)
}

// ListOrdersQuery 分页查询
type ListOrdersQuery struct {
    UserID string
    Page   int
    Size   int
    Status string
}

type ListOrdersHandler struct {
    readDB ReadModelDB
}

func (h ListOrdersHandler) Handle(ctx context.Context, q ListOrdersQuery) ([]OrderView, int64, error) {
    return h.readDB.ListOrderViews(ctx, q.UserID, q.Page, q.Size, q.Status)
}

package messaging

import (
    "github.com/ThreeDotsLabs/watermill"
    "github.com/ThreeDotsLabs/watermill-kafka/v3/pkg/kafka"
    "github.com/ThreeDotsLabs/watermill/components/cqrs"
    "github.com/ThreeDotsLabs/watermill/message"
)

func NewEventBus(
    publisher message.Publisher,
    logger watermill.LoggerAdapter,
) (*cqrs.EventBus, error) {
    return cqrs.NewEventBusWithConfig(publisher, cqrs.EventBusConfig{
        GeneratePublishTopic: func(params cqrs.GenerateEventPublishTopicParams) (string, error) {
            // 按事件名路由到不同 topic
            return "events." + params.EventName, nil
        },
        Marshaler: cqrs.ProtobufMarshaler{},
        Logger:    logger,
    })
}

// 事件处理器：订单确认后自动发送通知
type SendNotificationOnOrderConfirmed struct {
    notificationService NotificationService
}

func (h SendNotificationOnOrderConfirmed) Handle(
    ctx context.Context,
    event *OrderConfirmed,
) error {
    return h.notificationService.SendOrderConfirmation(ctx, event.OrderID, event.UserID)
}

// 事件处理器：订单确认后更新库存
type UpdateInventoryOnOrderConfirmed struct {
    inventoryService InventoryService
}

func (h UpdateInventoryOnOrderConfirmed) Handle(
    ctx context.Context,
    event *OrderConfirmed,
) error {
    return h.inventoryService.ReserveStock(ctx, event.OrderID)
}

package projection

import (
    "context"
    "sync"
)

// OrderReadModel 从事件流构建读模型
type OrderReadModel struct {
    db   *gorm.DB
    lock sync.Mutex
}

// HandleOrderCreated 处理订单创建事件，更新读模型
func (p *OrderReadModel) HandleOrderCreated(
    ctx context.Context,
    event *OrderCreated,
) error {
    p.lock.Lock()
    defer p.lock.Unlock()

    view := OrderView{
        ID:          event.OrderID,
        UserID:      event.UserID,
        Status:      "pending",
        TotalAmount: event.TotalAmount,
        ItemCount:   event.ItemCount,
        CreatedAt:   event.OccurredOn,
    }
    return p.db.WithContext(ctx).Create(&view).Error
}

// HandleOrderConfirmed 处理订单确认事件
func (p *OrderReadModel) HandleOrderConfirmed(
    ctx context.Context,
    event *OrderConfirmed,
) error {
    p.lock.Lock()
    defer p.lock.Unlock()

    return p.db.WithContext(ctx).
        Model(&OrderView{}).
        Where("id = ?", event.OrderID).
        Update("status", "confirmed").Error
}

package observability

import (
    "context"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
    "go.opentelemetry.io/otel/propagation"
    "go.opentelemetry.io/otel/sdk/resource"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
    semconv "go.opentelemetry.io/otel/semconv/v1.21.0"
)

func InitTracer(ctx context.Context, serviceName, otlpEndpoint string) (func(), error) {
    exporter, err := otlptracegrpc.New(ctx,
        otlptracegrpc.WithEndpoint(otlpEndpoint),
        otlptracegrpc.WithInsecure(),
    )
    if err != nil {
        return nil, err
    }

    res, err := resource.New(ctx,
        resource.WithAttributes(
            semconv.ServiceName(serviceName),
            semconv.ServiceVersion("1.0.0"),
            semconv.DeploymentEnvironment("production"),
        ),
    )
    if err != nil {
        return nil, err
    }

    tp := sdktrace.NewTracerProvider(
        sdktrace.WithBatcher(exporter),
        sdktrace.WithResource(res),
        sdktrace.WithSampler(sdktrace.ParentBased(
            sdktrace.TraceIDRatioBased(0.1), // 生产环境采样 10%
        )),
    )

    otel.SetTracerProvider(tp)
    otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(
        propagation.TraceContext{},
        propagation.Baggage{},
    ))

    cleanup := func() {
        _ = tp.Shutdown(context.Background())
    }
    return cleanup, nil
}

package http

import (
    "github.com/gin-gonic/gin"
    "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
    "gorm.io/gorm"
    "gorm.io/plugin/opentelemetry/tracing"
)

func NewRouter(db *gorm.DB) *gin.Engine {
    r := gin.New()

    // OpenTelemetry 追踪中间件
    r.Use(otelgin.Middleware("order-service"))

    // GORM OpenTelemetry 插件
    if err := db.Use(tracing.NewPlugin()); err != nil {
        panic(err)
    }

    return r
}

package observability

import (
    "context"
    "github.com/gin-gonic/gin"
    "github.com/google/uuid"
    "go.opentelemetry.io/otel/trace"
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
)

type contextKey string

const correlationIDKey contextKey = "correlation_id"

// CorrelationIDMiddleware 为每个请求注入 Correlation ID
func CorrelationIDMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 优先从上游请求头获取
        correlationID := c.GetHeader("X-Correlation-ID")
        if correlationID == "" {
            correlationID = uuid.New().String()
        }

        // 存入 context 和 response header
        ctx := context.WithValue(c.Request.Context(), correlationIDKey, correlationID)
        c.Request = c.Request.WithContext(ctx)
        c.Header("X-Correlation-ID", correlationID)

        c.Next()
    }
}

// StructuredLoggerMiddleware 结构化请求日志
func StructuredLoggerMiddleware(logger *zap.Logger) gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        path := c.Request.URL.Path

        c.Next()

        // 从 context 提取 trace 信息
        span := trace.SpanFromContext(c.Request.Context())
        correlationID, _ := c.Request.Context().Value(correlationIDKey).(string)

        logger.Info("request completed",
            zap.String("correlation_id", correlationID),
            zap.String("trace_id", span.SpanContext().TraceID().String()),
            zap.String("span_id", span.SpanContext().SpanID().String()),
            zap.String("method", c.Request.Method),
            zap.String("path", path),
            zap.Int("status", c.Writer.Status()),
            zap.Duration("latency", time.Since(start)),
            zap.String("client_ip", c.ClientIP()),
            zap.String("user_agent", c.Request.UserAgent()),
        )
    }
}

// ContextLogger 从 context 提取 trace 信息，创建带上下文的 logger
func ContextLogger(ctx context.Context, base *zap.Logger) *zap.Logger {
    span := trace.SpanFromContext(ctx)
    correlationID, _ := ctx.Value(correlationIDKey).(string)

    return base.With(
        zap.String("correlation_id", correlationID),
        zap.String("trace_id", span.SpanContext().TraceID().String()),
        zap.String("span_id", span.SpanContext().SpanID().String()),
    )
}

package resilience

import (
    "fmt"
    "time"
    "github.com/sony/gobreaker/v2"
)

// NewServiceBreaker 为外部服务调用创建熔断器
func NewServiceBreaker(name string) *gobreaker.CircuitBreaker[[]byte] {
    return gobreaker.NewCircuitBreaker[[]byte](gobreaker.Settings{
        Name:        name,
        MaxRequests: 3,                // Half-Open 状态最多允许 3 个探测请求
        Interval:    10 * time.Second, // Closed 状态下每 10s 清零计数器
        Timeout:     30 * time.Second, // Open -> Half-Open 的等待时间
        ReadyToTrip: func(counts gobreaker.Counts) bool {
            // 连续失败 5 次或失败率超过 60% 时触发熔断
            return counts.ConsecutiveFailures >= 5 ||
                (counts.Requests > 10 &&
                    float64(counts.TotalFailures)/float64(counts.Requests) > 0.6)
        },
        OnStateChange: func(name string, from, to gobreaker.State) {
            fmt.Printf("circuit breaker %s: %s -> %s\n", name, from, to)
            // 生产环境：接入 Prometheus 指标 + PagerDuty 告警
        },
        IsSuccessful: func(err error) bool {
            // 4xx 客户端错误不算服务失败
            if appErr, ok := err.(*AppError); ok {
                return appErr.StatusCode < 500
            }
            return err == nil
        },
    })
}

// 使用示例：调用支付服务
func (s *PaymentAdapter) ChargeUser(ctx context.Context, req ChargeRequest) ([]byte, error) {
    return s.breaker.Execute(func() ([]byte, error) {
        resp, err := s.httpClient.Post(ctx, s.paymentURL+"/charge", req)
        if err != nil {
            return nil, err
        }
        return resp.Body, nil
    })
}

package ratelimit

import (
    "context"
    "fmt"
    "net/http"
    "time"

    "github.com/gin-gonic/gin"
    "github.com/redis/go-redis/v9"
)

// Lua 脚本保证原子性：读取令牌 -> 扣减 -> 补充，一步完成
var tokenBucketScript = redis.NewScript(`
    local key = KEYS[1]
    local capacity = tonumber(ARGV[1])
    local refill_rate = tonumber(ARGV[2])
    local now = tonumber(ARGV[3])

    local bucket = redis.call("HMGET", key, "tokens", "last_refill")
    local tokens = tonumber(bucket[1])
    local last_refill = tonumber(bucket[2])

    if tokens == nil then
        tokens = capacity
        last_refill = now
    end

    -- 补充令牌
    local elapsed = now - last_refill
    tokens = math.min(capacity, tokens + elapsed * refill_rate)

    local allowed = 0
    if tokens >= 1 then
        tokens = tokens - 1
        allowed = 1
    end

    redis.call("HMSET", key, "tokens", tokens, "last_refill", now)
    redis.call("EXPIRE", key, math.ceil(capacity / refill_rate) * 2)

    return allowed
`)

type RateLimiter struct {
    rdb      *redis.Client
    capacity int      // 桶容量
    rate     float64  // 每秒补充令牌数
}

func NewRateLimiter(rdb *redis.Client, capacity int, ratePerSecond float64) *RateLimiter {
    return &RateLimiter{rdb: rdb, capacity: capacity, rate: ratePerSecond}
}

// Allow 检查是否允许请求
func (rl *RateLimiter) Allow(ctx context.Context, key string) (bool, error) {
    now := float64(time.Now().UnixMilli()) / 1000.0
    result, err := tokenBucketScript.Run(ctx, rl.rdb,
        []string{fmt.Sprintf("ratelimit:%s", key)},
        rl.capacity, rl.rate, now,
    ).Int()
    if err != nil {
        return false, err
    }
    return result == 1, nil
}

// PerUserRateLimitMiddleware 按用户限流
func PerUserRateLimitMiddleware(limiter *RateLimiter) gin.HandlerFunc {
    return func(c *gin.Context) {
        userID := c.GetString("user_id") // 从 JWT 中间件获取
        if userID == "" {
            userID = c.ClientIP() // 未登录用户按 IP 限流
        }

        allowed, err := limiter.Allow(c.Request.Context(), "user:"+userID)
        if err != nil {
            c.AbortWithStatusJSON(http.StatusInternalServerError,
                gin.H{"error": "rate limiter error"})
            return
        }
        if !allowed {
            c.AbortWithStatusJSON(http.StatusTooManyRequests,
                gin.H{"error": "rate limit exceeded", "retry_after": "1s"})
            return
        }

        c.Next()
    }
}

// PerEndpointRateLimitMiddleware 按端点限流
func PerEndpointRateLimitMiddleware(limiter *RateLimiter) gin.HandlerFunc {
    return func(c *gin.Context) {
        key := fmt.Sprintf("endpoint:%s:%s", c.Request.Method, c.FullPath())
        allowed, err := limiter.Allow(c.Request.Context(), key)
        if err != nil || !allowed {
            c.AbortWithStatusJSON(http.StatusTooManyRequests,
                gin.H{"error": "endpoint rate limit exceeded"})
            return
        }
        c.Next()
    }
}

package http

import "github.com/gin-gonic/gin"

func SetupVersionedRoutes(r *gin.Engine) {
    // 策略一：URL Path 版本（最常用）
    v1 := r.Group("/api/v1")
    {
        v1.GET("/orders", v1OrderHandler.List)
        v1.POST("/orders", v1OrderHandler.Create)
    }

    v2 := r.Group("/api/v2")
    {
        v2.GET("/orders", v2OrderHandler.List)    // 新增分页参数
        v2.POST("/orders", v2OrderHandler.Create) // 新增字段校验
    }

    // 策略二：Header 版本协商
    // Accept: application/vnd.myapp.v2+json
    r.GET("/api/orders", func(c *gin.Context) {
        accept := c.GetHeader("Accept")
        switch {
        case strings.Contains(accept, "vnd.myapp.v2"):
            v2OrderHandler.List(c)
        default:
            v1OrderHandler.List(c)
        }
    })
}

//go:build wireinject

package dependency

import (
    "github.com/google/wire"
    "enterprise-app/adapter/repository/mysql"
    "enterprise-app/application/command"
    "enterprise-app/application/query"
    "enterprise-app/domain/service"
)

// 定义 Provider Sets（按模块分组）
var DatabaseSet = wire.NewSet(
    NewGormDB,
    mysql.NewOrderRepo,
    mysql.NewUserRepo,
)

var ServiceSet = wire.NewSet(
    service.NewOrderService,
    service.NewUserService,
)

var CommandSet = wire.NewSet(
    command.NewConfirmOrderHandler,
    command.NewCancelOrderHandler,
    command.NewCreateOrderHandler,
)

var QuerySet = wire.NewSet(
    query.NewGetOrderHandler,
    query.NewListOrdersHandler,
)

var HandlerSet = wire.NewSet(
    NewOrderHandler,
    NewUserHandler,
)

// 接口绑定：将具体类型绑定到接口
var InterfaceSet = wire.NewSet(
    wire.Bind(new(repo.IOrderRepo), new(*mysql.OrderRepo)),
    wire.Bind(new(repo.IUserRepo), new(*mysql.UserRepo)),
)

// 顶层注入函数
func InitializeApp(cfg *config.Config) (*App, func(), error) {
    wire.Build(
        DatabaseSet,
        ServiceSet,
        CommandSet,
        QuerySet,
        HandlerSet,
        InterfaceSet,
        NewRouter,
        NewApp,
    )
    return nil, nil, nil // Wire 自动生成实际代码
}

package main

import (
    "context"
    "net/http"
    "go.uber.org/fx"
    "go.uber.org/fx/fxevent"
    "go.uber.org/zap"
)

func main() {
    fx.New(
        // 模块化组合
        fx.WithLogger(func(log *zap.Logger) fxevent.Logger {
            return &fxevent.ZapLogger{Logger: log}
        }),

        // 基础设施模块
        InfraModule,
        // 业务模块
        OrderModule,
        UserModule,
        PaymentModule,
        // HTTP 服务模块
        HTTPModule,
    ).Run()
}

// InfraModule 基础设施模块
var InfraModule = fx.Module("infra",
    fx.Provide(
        NewConfig,
        NewLogger,
        NewGormDB,
        NewRedisClient,
        NewKafkaPublisher,
    ),
)

// OrderModule 订单业务模块
var OrderModule = fx.Module("order",
    fx.Provide(
        mysql.NewOrderRepo,
        service.NewOrderService,
        command.NewConfirmOrderHandler,
        command.NewCancelOrderHandler,
        query.NewGetOrderHandler,
        NewOrderHandler,
    ),
)

// HTTPModule HTTP 服务模块（生命周期管理）
var HTTPModule = fx.Module("http",
    fx.Provide(NewGinRouter),
    fx.Invoke(RegisterRoutes),
    fx.Invoke(func(lc fx.Lifecycle, r *gin.Engine, cfg *Config) {
        srv := &http.Server{
            Addr:    cfg.HTTPAddr,
            Handler: r,
        }

        lc.Append(fx.Hook{
            OnStart: func(ctx context.Context) error {
                go srv.ListenAndServe()
                return nil
            },
            OnStop: func(ctx context.Context) error {
                return srv.Shutdown(ctx)
            },
        })
    }),
)