「产品矩阵平台」多租户与多应用设计

CREATE INDEX idx_contents_tenant_app_status_time
ON contents (tenant_id, app_id, status, published_at);

created -> configured -> verified -> active -> suspended -> archived

platform default
  -> tenant default
  -> app config
  -> namespace config
  -> runtime override

package middleware

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

func TenantContext(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        tenant := &TenantContext{
            TenantID: "default",
            AppID:    "",
        }

        // 优先级：自定义域名 > Header > JWT > 路径
        host := r.Host
        if strings.HasSuffix(host, ".acme.com") {
            tenant.TenantID = strings.TrimSuffix(host, ".acme.com")
        } else if appID := r.Header.Get("X-App-ID"); appID != "" {
            tenant.AppID = appID
            // 从缓存或数据库解析 tenant_id
            tenant.TenantID = resolveTenantByAppID(appID)
        }

        ctx := context.WithValue(r.Context(), tenantKey, tenant)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

// 从上下文中读取租户信息
type tenantKey struct{}

type TenantContext struct {
    TenantID string
    AppID    string
}

func GetTenant(ctx context.Context) *TenantContext {
    if v := ctx.Value(tenantKey); v != nil {
        return v.(*TenantContext)
    }
    return nil
}

package database

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

// TenantIDModel 嵌入到所有共享 model 中
type TenantIDModel struct {
    TenantID string `gorm:"index;not null" json:"tenant_id"`
    AppID    string `gorm:"index;not null" json:"app_id"`
}

// RegisterTenantHooks 在数据库初始化时调用
func RegisterTenantHooks(db *gorm.DB) {
    // Create 时自动注入 tenant_id 和 app_id
    db.Callback().Create().Before("gorm:create").Register("auto_tenant", func(db *gorm.DB) {
        if tenant := GetTenant(db.Statement.Context); tenant != nil {
            if db.Statement.Schema != nil {
                if field := db.Statement.Schema.LookUpField("TenantID"); field != nil {
                    _ = db.Statement.SetColumn("TenantID", tenant.TenantID)
                }
                if field := db.Statement.Schema.LookUpField("AppID"); field != nil {
                    _ = db.Statement.SetColumn("AppID", tenant.AppID)
                }
            }
        }
    })

    // 软删除默认使用 DeletedAt，已有 gorm 支持
    // 审计字段通过另一个 Hook 注入
    db.Callback().Create().Before("gorm:create").Register("auto_audit", func(db *gorm.DB) {
        if db.Statement.Schema != nil {
            if field := db.Statement.Schema.LookUpField("CreatedBy"); field != nil {
                if userID := GetUserID(db.Statement.Context); userID != "" {
                    _ = db.Statement.SetColumn("CreatedBy", userID)
                }
            }
        }
    })
}

package database

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

// ScopeTenant 自动过滤当前租户数据
func ScopeTenant(ctx context.Context) func(db *gorm.DB) *gorm.DB {
    return func(db *gorm.DB) *gorm.DB {
        if tenant := GetTenant(ctx); tenant != nil {
            return db.Where("tenant_id = ?", tenant.TenantID)
        }
        return db
    }
}

// ScopeTenantApp 同时过滤租户和应用
func ScopeTenantApp(ctx context.Context) func(db *gorm.DB) *gorm.DB {
    return func(db *gorm.DB) *gorm.DB {
        if tenant := GetTenant(ctx); tenant != nil {
            return db.Where("tenant_id = ? AND app_id = ?", tenant.TenantID, tenant.AppID)
        }
        return db
    }
}

// 在 Repository 中使用 Scope 封装（零侵入业务查询）
type ContentRepository struct {
    db *gorm.DB
}

func (r *ContentRepository) ListByStatus(ctx context.Context, status string) ([]Content, error) {
    var contents []Content
    // ScopeTenant 自动附加 WHERE tenant_id = ?
    err := r.db.WithContext(ctx).
        Scopes(ScopeTenant(ctx)).
        Where("status = ?", status).
        Order("published_at DESC").
        Find(&contents).Error
    return contents, err
}

func (r *ContentRepository) GetByID(ctx context.Context, id string) (*Content, error) {
    var content Content
    err := r.db.WithContext(ctx).
        Scopes(ScopeTenant(ctx)).
        First(&content, "id = ?", id).Error
    return &content, err
}

package cache

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

// TenantKey 生成带租户前缀的 Redis key
// 格式：tenant:{tenant_id}:app:{app_id}:{entity}:{id}:v{version}
func TenantKey(ctx context.Context, entity, id string, version int) string {
    tenant := GetTenant(ctx)
    if tenant == nil {
        return fmt.Sprintf("%s:%s:v%d", entity, id, version)
    }
    return fmt.Sprintf("tenant:%s:app:%s:%s:%s:v%d",
        tenant.TenantID, tenant.AppID, entity, id, version)
}

// 使用示例：缓存商品详情
func CacheProductDetail(ctx context.Context, productID string, data []byte, ttl time.Duration) error {
    key := TenantKey(ctx, "product", productID, 1) // v1 表示当前版本
    return redisClient.Set(ctx, key, data, ttl).Err()
}

// 批量失效同一租户下的缓存（例如配置变更后）
func InvalidateTenantCache(ctx context.Context, pattern string) error {
    tenant := GetTenant(ctx)
    if tenant == nil {
        return fmt.Errorf("no tenant in context")
    }
    fullPattern := fmt.Sprintf("tenant:%s:%s", tenant.TenantID, pattern)
    // 注意：生产环境 SCAN + DEL 更稳健
    return redisClient.Eval(ctx, redisDelByPattern, []string{fullPattern}).Err()
}

package database_test

import (
    "context"
    "testing"
)

func TestTenantIsolation(t *testing.T) {
    db := setupTestDB()
    RegisterTenantHooks(db)

    ctxA := context.WithValue(context.Background(), tenantKey,
        &TenantContext{TenantID: "tenant_a", AppID: "app_1"})
    ctxB := context.WithValue(context.Background(), tenantKey,
        &TenantContext{TenantID: "tenant_b", AppID: "app_1"})

    // tenant_a 创建内容
    contentA := Content{Title: "A 的文章"}
    err := db.WithContext(ctxA).Create(&contentA).Error
    if err != nil {
        t.Fatal(err)
    }

    // tenant_b 查询时应该看不到 tenant_a 的数据
    var contents []Content
    err = db.WithContext(ctxB).Scopes(ScopeTenant(ctxB)).Find(&contents).Error
    if err != nil {
        t.Fatal(err)
    }
    if len(contents) != 0 {
        t.Fatalf("tenant_b 不应看到 tenant_a 的数据，实际返回 %d 条", len(contents))
    }
}