「产品矩阵平台」核心技术架构层

type OrderService interface {
    CreateOrder(ctx context.Context, cmd CreateOrderCommand) (*OrderDTO, error)
    CancelOrder(ctx context.Context, cmd CancelOrderCommand) error
}

type UserRepository interface {
    FindByID(ctx context.Context, id string) (*User, error)
    FindByUnionID(ctx context.Context, tenantID string, unionID string) (*User, error)
    Save(ctx context.Context, user *User) error
}

业务事务：写订单 + 写 outbox_events
后台任务：扫描未投递事件 → 发布消息 → 标记已投递
消费端：按 event_id 幂等处理

sign_string = method + "\n" + path + "\n" + timestamp + "\n" + nonce + "\n" + sha256(body)
signature = HMAC-SHA256(app_secret, sign_string)

package gateway

import (
    "context"
    "net/http"
    "strings"
    "time"
)

// GatewayMiddleware 按顺序执行：身份校验 -> 签名校验 -> 限流 -> 路由
func GatewayMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()

        // 1. JWT 身份校验
        user, err := authenticateJWT(r)
        if err != nil {
            respondJSON(w, http.StatusUnauthorized, map[string]string{"error": "unauthorized"})
            return
        }
        ctx = context.WithValue(ctx, "user", user)

        // 2. API 签名校验（开放平台）
        if r.Header.Get("X-Signature") != "" {
            if err := verifySignature(r); err != nil {
                respondJSON(w, http.StatusForbidden, map[string]string{"error": "invalid signature"})
                return
            }
        }

        // 3. 租户上下文注入
        tenant := resolveTenant(r)
        ctx = context.WithValue(ctx, "tenant", tenant)

        // 4. 限流
        if !RateLimiter.Allow(ctx, tenant.ID, r.URL.Path) {
            respondJSON(w, http.StatusTooManyRequests, map[string]string{"error": "rate limited"})
            return
        }

        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

// verifySignature HMAC-SHA256 签名
func verifySignature(r *http.Request) error {
    appID := r.Header.Get("X-App-ID")
    timestamp := r.Header.Get("X-Timestamp")
    nonce := r.Header.Get("X-Nonce")
    sig := r.Header.Get("X-Signature")

    secret := MustGetAppSecret(appID)
    body, _ := io.ReadAll(r.Body)
    r.Body = io.NopCloser(bytes.NewReader(body))

    strToSign := r.Method + "\n" + r.URL.Path + "\n" + timestamp + "\n" + nonce + "\n" + sha256Hex(body)
    expected := hmacSHA256(secret, strToSign)

    if subtle.ConstantTimeCompare([]byte(sig), []byte(expected)) != 1 {
        return fmt.Errorf("signature mismatch")
    }

    // 防重放
    ts, _ := strconv.ParseInt(timestamp, 10, 64)
    if math.Abs(float64(time.Now().Unix()-ts)) > 300 {
        return fmt.Errorf("request expired")
    }
    return nil
}

package repository

type UserRepository struct {
    writer *gorm.DB  // 主库
    reader *gorm.DB  // 从库
}

func (r *UserRepository) FindByID(ctx context.Context, id string) (*User, error) {
    var user User
    err := r.reader.WithContext(ctx).First(&user, "id = ?", id).Error
    return &user, err
}

func (r *UserRepository) Save(ctx context.Context, user *User) error {
    return r.writer.WithContext(ctx).Save(user).Error
}

func (r *UserRepository) FindByUnionID(ctx context.Context, tenantID, unionID string) (*User, error) {
    var user User
    err := r.reader.WithContext(ctx).
        Joins("LEFT JOIN identities ON identities.account_id = users.id").
        Where("users.tenant_id = ? AND identities.provider_id = ?", tenantID, unionID).
        First(&user).Error
    return &user, err
}

// 对于强一致读取（写入后立即读取），强制走主库
func (r *UserRepository) FindByIDStrong(ctx context.Context, id string) (*User, error) {
    var user User
    err := r.writer.WithContext(ctx).First(&user, "id = ?", id).Error
    return &user, err
}

package feature

import (
    "context"
    "hash/fnv"
    "time"
)

type Toggle struct {
    Key       string `json:"key"`
    Enabled   bool   `json:"enabled"`
    Target    string `json:"target"`    // all / tenant / app / user / rollout
    TargetID  string `json:"target_id"` // 目标标识，如租户ID
    Percentage int   `json:"percentage"` // 0-100，rollout 时使用
    StartAt   *time.Time `json:"start_at"`
    EndAt     *time.Time `json:"end_at"`
}

func (t *Toggle) Allow(ctx context.Context, tenantID, appID, userID string) bool {
    if !t.Enabled {
        return false
    }
    now := time.Now()
    if t.StartAt != nil && now.Before(*t.StartAt) {
        return false
    }
    if t.EndAt != nil && now.After(*t.EndAt) {
        return false
    }

    switch t.Target {
    case "all":
        return true
    case "tenant":
        return tenantID == t.TargetID
    case "app":
        return appID == t.TargetID
    case "user":
        return userID == t.TargetID
    case "rollout":
        return hashInRange(userID, t.Percentage)
    }
    return false
}

// 按 userID 哈希决定是否命中灰度
func hashInRange(userID string, percentage int) bool {
    h := fnv.New32a()
    h.Write([]byte(userID))
    return int(h.Sum32()%100) < percentage
}

// 使用示例：决策是否启用新版结算页
func (svc *OrderService) CheckoutPage(ctx context.Context, userID string) (string, error) {
    toggle := svc.cfg.GetToggle("new_checkout_v2")
    if toggle.Allow(ctx, svc.tenantID, svc.appID, userID) {
        return svc.newCheckoutPage(ctx)
    }
    return svc.legacyCheckoutPage(ctx)
}

package scheduler

import (
    "context"
    "fmt"
    "sync"
    "time"
)

type Scheduler struct {
    tasks     map[string]*Task
    mu        sync.RWMutex
    leader    *leader.Election
    stopCh    chan struct{}
    wg        sync.WaitGroup
}

type Task struct {
    ID       string
    Interval time.Duration
    Handler  func(ctx context.Context) error
}

func (s *Scheduler) Register(t *Task) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.tasks[t.ID] = t
}

func (s *Scheduler) Start() {
    for _, t := range s.tasks {
        s.wg.Add(1)
        go s.runTask(t)
    }
}

func (s *Scheduler) runTask(t *Task) {
    defer s.wg.Done()
    ticker := time.NewTicker(t.Interval)
    defer ticker.Stop()
    for {
        select {
        case <-s.stopCh:
            return
        case <-ticker.C:
            if s.leader != nil && !s.leader.IsLeader() {
                continue // 非 Leader 不执行
            }
            ctx, cancel := context.WithTimeout(context.Background(), t.Interval)
            if err := t.Handler(ctx); err != nil {
                // 记录失败日志，支持重试计数与退避
                fmt.Printf("task %s failed: %v\n", t.ID, err)
            }
            cancel()
        }
    }
}

func (s *Scheduler) Stop() {
    close(s.stopCh)
    s.wg.Wait()
}

package hooks

import (
    "context"
    "time"
    "gorm.io/gorm"
)

func RegisterAuditHooks(db *gorm.DB) {
    // 自动写入 tenant_id
    db.Callback().Create().Before("gorm:create").Register("auto_tenant", func(db *gorm.DB) {
        if tenant := GetTenant(db.Statement.Context); tenant != nil {
            if field := db.Statement.Schema.LookUpField("TenantID"); field != nil {
                _ = db.Statement.SetColumn("TenantID", tenant.ID)
            }
            if field := db.Statement.Schema.LookUpField("AppID"); field != nil {
                _ = db.Statement.SetColumn("AppID", tenant.AppID)
            }
        }
    })

    // 审计字段
    now := time.Now()
    db.Callback().Create().Before("gorm:create").Register("auto_created_at", func(db *gorm.DB) {
        if field := db.Statement.Schema.LookUpField("CreatedAt"); field != nil {
            _ = db.Statement.SetColumn("CreatedAt", now)
        }
        if user := GetUserID(db.Statement.Context); user != "" {
            if field := db.Statement.Schema.LookUpField("CreatedBy"); field != nil {
                _ = db.Statement.SetColumn("CreatedBy", user)
            }
        }
    })

    db.Callback().Update().Before("gorm:update").Register("auto_updated_at", func(db *gorm.DB) {
        if field := db.Statement.Schema.LookUpField("UpdatedAt"); field != nil {
            _ = db.Statement.SetColumn("UpdatedAt", now)
        }
    })

    // 禁止物理删除，必须通过软删除
    db.Callback().Delete().Before("gorm:delete").Register("block_hard_delete", func(db *gorm.DB) {
        if db.Statement.Unscoped {
            return // Allow Unscoped() bypass
        }
        // 默认转换为软删除
        db.Statement.SetColumn("DeletedAt", now)
        db.Statement.SQL.Grow(100)
    })
}