docs(constitution): 新增数据库设计原则(v2.4.0)

在项目宪章中新增第九条原则"数据库设计原则",明确禁止使用数据库外键约束和ORM关联标签。

主要变更:
- 新增原则IX:数据库设计原则(Database Design Principles)
- 强制要求:数据库表不得使用外键约束
- 强制要求:GORM模型不得使用ORM关联标签(foreignKey、hasMany等)
- 强制要求:表关系必须通过ID字段手动维护
- 强制要求:关联数据查询必须显式编写,避免ORM魔法
- 强制要求:时间字段由GORM处理,不使用数据库触发器

设计理念:
- 提升业务逻辑灵活性(无数据库约束限制)
- 优化高并发性能(无外键检查开销)
- 增强代码可读性(显式查询,无隐式预加载)
- 简化数据库架构和迁移流程
- 支持分布式和微服务场景

版本升级:2.3.0 → 2.4.0(MINOR)
This commit is contained in:
2025-11-13 13:40:19 +08:00
parent ea0c6a8b16
commit 984ccccc63
63 changed files with 12099 additions and 83 deletions

155
internal/task/email.go Normal file
View File

@@ -0,0 +1,155 @@
package task
import (
"context"
"fmt"
"strings"
"time"
"github.com/bytedance/sonic"
"github.com/hibiken/asynq"
"github.com/redis/go-redis/v9"
"go.uber.org/zap"
"github.com/break/junhong_cmp_fiber/pkg/constants"
)
// EmailPayload 邮件任务载荷
type EmailPayload struct {
RequestID string `json:"request_id"`
To string `json:"to"`
Subject string `json:"subject"`
Body string `json:"body"`
CC []string `json:"cc,omitempty"`
Attachments []string `json:"attachments,omitempty"`
}
// EmailHandler 邮件任务处理器
type EmailHandler struct {
redis *redis.Client
logger *zap.Logger
}
// NewEmailHandler 创建邮件任务处理器
func NewEmailHandler(redis *redis.Client, logger *zap.Logger) *EmailHandler {
return &EmailHandler{
redis: redis,
logger: logger,
}
}
// HandleEmailSend 处理邮件发送任务
func (h *EmailHandler) HandleEmailSend(ctx context.Context, task *asynq.Task) error {
// 解析任务载荷
var payload EmailPayload
if err := sonic.Unmarshal(task.Payload(), &payload); err != nil {
h.logger.Error("解析邮件任务载荷失败",
zap.Error(err),
zap.String("task_id", task.ResultWriter().TaskID()),
)
return asynq.SkipRetry // JSON 解析失败不重试
}
// 验证载荷
if err := h.validatePayload(&payload); err != nil {
h.logger.Error("邮件任务载荷验证失败",
zap.Error(err),
zap.String("request_id", payload.RequestID),
)
return asynq.SkipRetry // 参数错误不重试
}
// 幂等性检查:使用 Redis 锁
lockKey := constants.RedisTaskLockKey(payload.RequestID)
locked, err := h.acquireLock(ctx, lockKey)
if err != nil {
h.logger.Error("获取任务锁失败",
zap.Error(err),
zap.String("request_id", payload.RequestID),
)
return err // 锁获取失败,可以重试
}
if !locked {
h.logger.Info("任务已执行,跳过(幂等性)",
zap.String("request_id", payload.RequestID),
zap.String("to", payload.To),
)
return nil // 已执行,跳过
}
// 记录任务开始执行
h.logger.Info("开始处理邮件发送任务",
zap.String("request_id", payload.RequestID),
zap.String("to", payload.To),
zap.String("subject", payload.Subject),
zap.Int("cc_count", len(payload.CC)),
zap.Int("attachments_count", len(payload.Attachments)),
)
// 执行邮件发送(模拟)
if err := h.sendEmail(ctx, &payload); err != nil {
h.logger.Error("邮件发送失败",
zap.Error(err),
zap.String("request_id", payload.RequestID),
zap.String("to", payload.To),
)
return err // 发送失败,可以重试
}
// 记录任务完成
h.logger.Info("邮件发送成功",
zap.String("request_id", payload.RequestID),
zap.String("to", payload.To),
)
return nil
}
// validatePayload 验证邮件载荷
func (h *EmailHandler) validatePayload(payload *EmailPayload) error {
if payload.RequestID == "" {
return fmt.Errorf("request_id 不能为空")
}
if payload.To == "" {
return fmt.Errorf("收件人不能为空")
}
if !strings.Contains(payload.To, "@") {
return fmt.Errorf("邮箱格式无效")
}
if payload.Subject == "" {
return fmt.Errorf("邮件主题不能为空")
}
if payload.Body == "" {
return fmt.Errorf("邮件正文不能为空")
}
return nil
}
// acquireLock 获取 Redis 锁(幂等性)
func (h *EmailHandler) acquireLock(ctx context.Context, key string) (bool, error) {
// 使用 SetNX 实现分布式锁
// 过期时间 24 小时,防止锁永久存在
result, err := h.redis.SetNX(ctx, key, "1", 24*time.Hour).Result()
if err != nil {
return false, fmt.Errorf("设置 Redis 锁失败: %w", err)
}
return result, nil
}
// sendEmail 发送邮件(实际实现需要集成 SMTP 或邮件服务)
func (h *EmailHandler) sendEmail(ctx context.Context, payload *EmailPayload) error {
// TODO: 实际实现中需要集成邮件发送服务
// 例如:使用 SMTP、SendGrid、AWS SES 等
// 模拟发送延迟
time.Sleep(100 * time.Millisecond)
// 这里仅作演示,实际应用中需要调用真实的邮件发送 API
h.logger.Debug("模拟邮件发送",
zap.String("to", payload.To),
zap.String("subject", payload.Subject),
zap.Int("body_length", len(payload.Body)),
)
return nil
}

170
internal/task/sim.go Normal file
View File

@@ -0,0 +1,170 @@
package task
import (
"context"
"fmt"
"time"
"github.com/bytedance/sonic"
"github.com/hibiken/asynq"
"github.com/redis/go-redis/v9"
"go.uber.org/zap"
"gorm.io/gorm"
"github.com/break/junhong_cmp_fiber/pkg/constants"
)
// SIMStatusSyncPayload SIM 卡状态同步任务载荷
type SIMStatusSyncPayload struct {
RequestID string `json:"request_id"`
ICCIDs []string `json:"iccids"` // ICCID 列表
ForceSync bool `json:"force_sync"` // 强制同步(忽略缓存)
}
// SIMHandler SIM 卡状态同步任务处理器
type SIMHandler struct {
db *gorm.DB
redis *redis.Client
logger *zap.Logger
}
// NewSIMHandler 创建 SIM 卡状态同步任务处理器
func NewSIMHandler(db *gorm.DB, redis *redis.Client, logger *zap.Logger) *SIMHandler {
return &SIMHandler{
db: db,
redis: redis,
logger: logger,
}
}
// HandleSIMStatusSync 处理 SIM 卡状态同步任务
func (h *SIMHandler) HandleSIMStatusSync(ctx context.Context, task *asynq.Task) error {
// 解析任务载荷
var payload SIMStatusSyncPayload
if err := sonic.Unmarshal(task.Payload(), &payload); err != nil {
h.logger.Error("解析 SIM 状态同步任务载荷失败",
zap.Error(err),
zap.String("task_id", task.ResultWriter().TaskID()),
)
return asynq.SkipRetry
}
// 验证载荷
if err := h.validatePayload(&payload); err != nil {
h.logger.Error("SIM 状态同步任务载荷验证失败",
zap.Error(err),
zap.String("request_id", payload.RequestID),
)
return asynq.SkipRetry
}
// 幂等性检查
lockKey := constants.RedisTaskLockKey(payload.RequestID)
locked, err := h.acquireLock(ctx, lockKey)
if err != nil {
h.logger.Error("获取任务锁失败",
zap.Error(err),
zap.String("request_id", payload.RequestID),
)
return err
}
if !locked {
h.logger.Info("任务已执行,跳过(幂等性)",
zap.String("request_id", payload.RequestID),
zap.Int("iccid_count", len(payload.ICCIDs)),
)
return nil
}
// 记录任务开始
h.logger.Info("开始处理 SIM 卡状态同步任务",
zap.String("request_id", payload.RequestID),
zap.Int("iccid_count", len(payload.ICCIDs)),
zap.Bool("force_sync", payload.ForceSync),
)
// 执行状态同步
if err := h.syncSIMStatus(ctx, &payload); err != nil {
h.logger.Error("SIM 卡状态同步失败",
zap.Error(err),
zap.String("request_id", payload.RequestID),
)
return err
}
// 记录任务完成
h.logger.Info("SIM 卡状态同步成功",
zap.String("request_id", payload.RequestID),
zap.Int("iccid_count", len(payload.ICCIDs)),
)
return nil
}
// validatePayload 验证 SIM 状态同步载荷
func (h *SIMHandler) validatePayload(payload *SIMStatusSyncPayload) error {
if payload.RequestID == "" {
return fmt.Errorf("request_id 不能为空")
}
if len(payload.ICCIDs) == 0 {
return fmt.Errorf("iccids 不能为空")
}
if len(payload.ICCIDs) > 1000 {
return fmt.Errorf("单次同步 ICCID 数量不能超过 1000")
}
return nil
}
// acquireLock 获取 Redis 锁
func (h *SIMHandler) acquireLock(ctx context.Context, key string) (bool, error) {
result, err := h.redis.SetNX(ctx, key, "1", 24*time.Hour).Result()
if err != nil {
return false, fmt.Errorf("设置 Redis 锁失败: %w", err)
}
return result, nil
}
// syncSIMStatus 执行 SIM 卡状态同步
func (h *SIMHandler) syncSIMStatus(ctx context.Context, payload *SIMStatusSyncPayload) error {
// TODO: 实际实现中需要调用运营商 API 获取 SIM 卡状态
// 批量处理 ICCID
batchSize := 100
for i := 0; i < len(payload.ICCIDs); i += batchSize {
// 检查上下文是否已取消
select {
case <-ctx.Done():
return ctx.Err()
default:
}
end := i + batchSize
if end > len(payload.ICCIDs) {
end = len(payload.ICCIDs)
}
batch := payload.ICCIDs[i:end]
h.logger.Debug("同步 SIM 卡状态批次",
zap.Int("batch_start", i),
zap.Int("batch_end", end),
zap.Int("batch_size", len(batch)),
)
// 模拟调用外部 API
time.Sleep(200 * time.Millisecond)
// TODO: 实际实现中需要:
// 1. 调用运营商 API 获取状态
// 2. 使用事务批量更新数据库
// 3. 更新 Redis 缓存
// 4. 记录同步日志
}
h.logger.Info("SIM 卡状态批量同步完成",
zap.Int("total_iccids", len(payload.ICCIDs)),
zap.Int("batch_size", batchSize),
)
return nil
}

166
internal/task/sync.go Normal file
View File

@@ -0,0 +1,166 @@
package task
import (
"context"
"fmt"
"time"
"github.com/bytedance/sonic"
"github.com/hibiken/asynq"
"go.uber.org/zap"
"gorm.io/gorm"
)
// DataSyncPayload 数据同步任务载荷
type DataSyncPayload struct {
RequestID string `json:"request_id"`
SyncType string `json:"sync_type"` // sim_status, flow_usage, real_name
StartDate string `json:"start_date"` // YYYY-MM-DD
EndDate string `json:"end_date"` // YYYY-MM-DD
BatchSize int `json:"batch_size"` // 批量大小
}
// SyncHandler 数据同步任务处理器
type SyncHandler struct {
db *gorm.DB
logger *zap.Logger
}
// NewSyncHandler 创建数据同步任务处理器
func NewSyncHandler(db *gorm.DB, logger *zap.Logger) *SyncHandler {
return &SyncHandler{
db: db,
logger: logger,
}
}
// HandleDataSync 处理数据同步任务
func (h *SyncHandler) HandleDataSync(ctx context.Context, task *asynq.Task) error {
// 解析任务载荷
var payload DataSyncPayload
if err := sonic.Unmarshal(task.Payload(), &payload); err != nil {
h.logger.Error("解析数据同步任务载荷失败",
zap.Error(err),
zap.String("task_id", task.ResultWriter().TaskID()),
)
return asynq.SkipRetry
}
// 验证载荷
if err := h.validatePayload(&payload); err != nil {
h.logger.Error("数据同步任务载荷验证失败",
zap.Error(err),
zap.String("request_id", payload.RequestID),
)
return asynq.SkipRetry
}
// 设置默认批量大小
if payload.BatchSize <= 0 {
payload.BatchSize = 100
}
// 记录任务开始
h.logger.Info("开始处理数据同步任务",
zap.String("request_id", payload.RequestID),
zap.String("sync_type", payload.SyncType),
zap.String("start_date", payload.StartDate),
zap.String("end_date", payload.EndDate),
zap.Int("batch_size", payload.BatchSize),
)
// 执行数据同步
if err := h.syncData(ctx, &payload); err != nil {
h.logger.Error("数据同步失败",
zap.Error(err),
zap.String("request_id", payload.RequestID),
zap.String("sync_type", payload.SyncType),
)
return err // 同步失败,可以重试
}
// 记录任务完成
h.logger.Info("数据同步成功",
zap.String("request_id", payload.RequestID),
zap.String("sync_type", payload.SyncType),
)
return nil
}
// validatePayload 验证数据同步载荷
func (h *SyncHandler) validatePayload(payload *DataSyncPayload) error {
if payload.RequestID == "" {
return fmt.Errorf("request_id 不能为空")
}
if payload.SyncType == "" {
return fmt.Errorf("sync_type 不能为空")
}
validTypes := []string{"sim_status", "flow_usage", "real_name"}
valid := false
for _, t := range validTypes {
if payload.SyncType == t {
valid = true
break
}
}
if !valid {
return fmt.Errorf("sync_type 无效,必须为 sim_status, flow_usage, real_name 之一")
}
if payload.StartDate == "" {
return fmt.Errorf("start_date 不能为空")
}
if payload.EndDate == "" {
return fmt.Errorf("end_date 不能为空")
}
return nil
}
// syncData 执行数据同步
func (h *SyncHandler) syncData(ctx context.Context, payload *DataSyncPayload) error {
// TODO: 实际实现中需要调用外部 API 或数据源进行同步
// 模拟批量同步
totalRecords := 500 // 假设有 500 条记录需要同步
batches := (totalRecords + payload.BatchSize - 1) / payload.BatchSize
for i := 0; i < batches; i++ {
// 检查上下文是否已取消
select {
case <-ctx.Done():
return ctx.Err()
default:
}
// 模拟批量处理
offset := i * payload.BatchSize
limit := payload.BatchSize
if offset+limit > totalRecords {
limit = totalRecords - offset
}
h.logger.Debug("同步批次",
zap.String("sync_type", payload.SyncType),
zap.Int("batch", i+1),
zap.Int("total_batches", batches),
zap.Int("offset", offset),
zap.Int("limit", limit),
)
// 模拟处理延迟
time.Sleep(200 * time.Millisecond)
// TODO: 实际实现中需要:
// 1. 从外部 API 获取数据
// 2. 使用事务批量更新数据库
// 3. 记录同步状态
}
h.logger.Info("批量同步完成",
zap.String("sync_type", payload.SyncType),
zap.Int("total_records", totalRecords),
zap.Int("batches", batches),
)
return nil
}