第16章 · 评论与用户关系服务（正式版）

id  | content       | parent_id
----|---------------|----------
1   | 一级评论A      | NULL
2   | 一级评论B      | NULL
3   | 回复A的评论    | 1
4   | 回复3的评论    | 3

id  | content       | path
----|---------------|-------
1   | 一级评论A      | 1
3   | 回复A的评论    | 1/3
4   | 回复3的评论    | 1/3/4

TreePaths
ancestor | descendant
---------|-----------
1        | 1
1        | 3
1        | 4
3        | 3
3        | 4
4        | 4

// Comment 评论表对应模型
// 关键字段：UID(评论者)、Biz/BizID(被评论的资源)、PID(父评论)、RootID(根评论)
type Comment struct {
    ID      int64          `gorm:"primaryKey;autoIncrement;comment:评论ID"`
    UID     int64          `gorm:"index;comment:评论者ID"`
    Biz     string         `gorm:"type:varchar(128);not null;comment:业务标识"`
    BizID   int64          `gorm:"not null;comment:业务ID"`
    Content string         `gorm:"type:text;comment:评论内容"`
    PID     int64          `gorm:"index;comment:父评论ID，根评论为0"`
    RootID  int64          `gorm:"index;comment:根评论ID，方便加载整棵子树"`
    Ctime   int64          `gorm:"index;comment:创建时间"`
    Utime   int64          `gorm:"comment:更新时间"`
}

// 索引设计要点：
// 1. (biz, biz_id) 联合索引 —— 加载资源的评论列表
// 2. pid 单列索引 —— 加载某条评论的子评论
// 3. root_id 单列索引 —— 加载某条评论下的全部回复（楼中楼展开）
// 4. uid 单列索引（可选）—— 用户查询自己发表过的评论
// 5. ctime 索引 —— 按时间排序

// CreateComment 创建评论
// 如果传入 PID > 0，则代表回复某条评论；
// 如果是回复，需要同步设置 RootID（沿用父评论的 RootID，若父评论本身就是根，则 RootID = PID）
func (s *CommentService) CreateComment(ctx context.Context, c domain.Comment) (int64, error) {
    // 步骤 1：校验父评论存在性（如果传了 PID），并继承 RootID
    if c.PID > 0 {
        parent, err := s.repo.FindById(ctx, c.PID)
        if err != nil {
            return 0, err
        }
        // 沿用父评论的 RootID；若父评论本身是根，则 RootID 就是父评论 ID
        if parent.RootID > 0 {
            c.RootID = parent.RootID
        } else {
            c.RootID = parent.ID
        }
    }
    // 步骤 2：落库
    return s.repo.Create(ctx, c)
}

// CreateCommentAsync 异步写评论的简化示例
// 生产者：将评论序列化后发送到 Kafka
func (s *CommentService) CreateCommentAsync(ctx context.Context, c domain.Comment) error {
    // 步骤 1：序列化评论
    msg, err := json.Marshal(c)
    if err != nil {
        return err
    }
    // 步骤 2：用 biz_id 作 key，保证同一资源下的评论顺序写入同一分区
    return s.producer.SendMessage(ctx, "comment_write", strconv.FormatInt(c.BizID, 10), msg)
}

// 消费者：从 Kafka 拉取评论并落库
func (s *CommentConsumer) Consume(ctx context.Context, msg kafka.Message) error {
    // 步骤 1：反序列化
    var c domain.Comment
    if err := json.Unmarshal(msg.Value, &c); err != nil {
        return err
    }
    // 步骤 2：落库（复用同步写逻辑）
    _, err := s.svc.CreateComment(ctx, c)
    return err
}

删除节点 4 的步骤：
1. DELETE FROM comments WHERE id = 4;
2. 查找 parent_id = 4 的节点（5、6），删除；
3. 查找 parent_id IN (5,6) 的节点（7），删除；
4. 递归直到没有子节点。

type Comment struct {
    ID           int64     `gorm:"primaryKey;autoIncrement"`
    Content      string    `gorm:"type:text"`
    // 通过 ForeignKey 指定 PID 关联到自身 ID，并设置级联删除策略
    ParentComment *Comment `gorm:"ForeignKey:PID;AssociationForeignKey:ID;constraint:OnDelete:CASCADE"`
    PID           int64    `gorm:"index"`
}

// FindByBiz 按资源加载第一页评论
// 关键：使用 minID + limit 的游标分页，而非传统 offset + limit
func (r *CommentRepository) FindByBiz(ctx context.Context, biz string, bizID, minID, limit int64) ([]domain.Comment, error) {
    // 步骤 1：构造基础查询
    var res []domain.Comment
    db := r.db.WithContext(ctx).
        Where("biz = ? AND biz_id = ?", biz, bizID)
    // 步骤 2：minID > 0 时只查比 minID 更早（ID 更小）的评论
    if minID > 0 {
        db = db.Where("id < ?", minID)
    }
    // 步骤 3：按 ID 倒序取前 limit 条
    err := db.Order("id DESC").
        Limit(int(limit)).
        Find(&res).Error
    return res, err
}

// FindTopReplies 批量查询多条一级评论的 Top N 回复
// 在 repository 层完成聚合，避免 N+1 查询问题
func (r *CommentRepository) FindTopReplies(ctx context.Context, rootIDs []int64, limit int64) (map[int64][]domain.Comment, error) {
    var comments []domain.Comment
    // 步骤 1：用窗口函数为每个 root_id 取最新 limit 条
    err := r.db.WithContext(ctx).
        Raw(`
            SELECT * FROM (
                SELECT *, ROW_NUMBER() OVER (PARTITION BY root_id ORDER BY id DESC) AS rn
                FROM comments
                WHERE root_id IN (?)
            ) t WHERE rn <= ?
        `, rootIDs, limit).
        Scan(&comments).Error
    if err != nil {
        return nil, err
    }
    // 步骤 2：按 root_id 分组返回，避免 N+1
    res := make(map[int64][]domain.Comment, len(rootIDs))
    for _, c := range comments {
        res[c.RootID] = append(res[c.RootID], c)
    }
    return res, nil
}

// FindMoreReplies 点击「查看更多回复」时按 root_id 翻页
func (r *CommentRepository) FindMoreReplies(ctx context.Context, rootID, minID, limit int64) ([]domain.Comment, error) {
    // 步骤 1：按 root_id 查
    var res []domain.Comment
    db := r.db.WithContext(ctx).Where("root_id = ?", rootID)
    // 步骤 2：minID 游标分页
    if minID > 0 {
        db = db.Where("id < ?", minID)
    }
    // 步骤 3：倒序取前 limit
    err := db.Order("id DESC").Limit(int(limit)).Find(&res).Error
    return res, err
}

// FollowRelation 用户关系表
// 约定：A 关注 B，则 follower=A，followee=B
type FollowRelation struct {
    ID         int64  `gorm:"primaryKey;autoIncrement"`
    Follower   int64  `gorm:"index:idx_follower_followee,unique,priority:1;comment:关注者"`
    Followee   int64  `gorm:"index:idx_follower_followee,unique,priority:2;index:idx_followee;comment:被关注者"`
    Status     uint8  `gorm:"comment:状态 1=已关注 0=已取消"`
    Ctime      int64
    Utime      int64
}

// 关键索引设计：
// 1. 唯一索引 (follower, followee) —— 用于"查询某人关注了谁"场景，WHERE follower = ? 命中索引
// 2. 单独在 followee 上创建普通索引 —— 用于"查询某人的粉丝列表"场景
//    因为唯一索引列顺序是 (follower, followee)，WHERE followee = ? 无法命中索引

// Follow 关注或取消关注
// status=1 表示关注，status=0 表示取消关注
func (r *FollowRepository) Follow(ctx context.Context, follower, followee int64, status uint8) error {
    // 步骤 1：开启事务（关系表与计数表必须一致）
    now := time.Now().UnixMilli()
    return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
        // 步骤 2：INSERT ... ON DUPLICATE KEY UPDATE 实现 Upsert
        err := tx.Clauses(clause.OnConflict{
            Columns: []clause.Column{{Name: "follower"}, {Name: "followee"}},
            DoUpdates: clause.Assignments(map[string]interface{}{
                "status": status,
                "utime":  now,
            }),
        }).Create(&FollowRelation{
            Follower: follower, Followee: followee,
            Status: status, Ctime: now, Utime: now,
        }).Error
        if err != nil {
            return err
        }
        // 步骤 3：同步更新计数表（详见下方两个方案），保证关系表与计数表一致
        return nil
    })
}

type FollowStatics struct {
    UID         int64 `gorm:"primaryKey"`
    FollowCount int64 `gorm:"comment:关注了多少人"`
    FanCount    int64 `gorm:"comment:有多少粉丝"`
}

// Cache 实现四个接口：FollowCount / FanCount / IncrFollow / IncrFan
// 关键：使用 TxPipeline（Redis 事务）保证 A 关注 B 时同时更新 A 的关注数和 B 的粉丝数
func (c *FollowCache) IncrFollowAndFan(ctx context.Context, follower, followee int64) error {
    // 步骤 1：开启 Redis 事务管道
    pipe := c.client.TxPipeline()
    // 步骤 2：两条 INCRBY 原子执行
    pipe.IncrBy(ctx, followKey(follower), 1)
    pipe.IncrBy(ctx, fanKey(followee), 1)
    // 步骤 3：提交
    _, err := pipe.Exec(ctx)
    return err
}

反例（不推荐）：
| follower | followee | is_follow | is_block | is_mute |

原因：
1. 关注的量级远大于拉黑、屏蔽（关注：100/人，拉黑：可能 0-5/人）
2. 拆开后单表数据量小，扫描快，索引维护成本低
3. 不同业务的查询模式不同，拆表后可以独立优化

// 思路 ④ 的骨架：定时任务异步刷新计数缓存
func (s *FollowService) refreshFollowCount(ctx context.Context, uid int64) error {
    // 步骤 1：COUNT 数据库，WHERE follower = ? 命索引（别忘 3.8 节的最左前缀）
    cnt, err := s.repo.CountFollowing(ctx, uid)
    if err != nil {
        return err
    }
    // 步骤 2：SET 直接覆盖写回 Redis —— 以 DB 的真实值为准，顺便纠偏 INCRBY 的累计误差
    return s.cache.SetFollowCount(ctx, uid, cnt)
}

// 一次 UpdateOne 同时做三件事：扣库存 + 追加买家 + 更新时间
// 单文档原子性由 MongoDB 自己保证
_, err := r.coll.UpdateOne(ctx,
    bson.M{"_id": itemID, "stock": bson.M{"$gt": 0}}, // 条件里带上 stock>0，防止超扣
    bson.M{
        "$inc":  bson.M{"stock": -1},                  // 原子自减
        "$push": bson.M{"buyers": uid},                // 原子追加到数组
        "$set":  bson.M{"utime": time.Now().UnixMilli()},
    },
)

// TransferPoints 用多文档事务实现积分转账：从 from 扣 points，给 to 加 points
// 写法基于官方 mongo-driver v1（go.mongodb.org/mongo-driver）
func (r *AccountRepo) TransferPoints(ctx context.Context, from, to, points int64) error {
    // 步骤 1：创建 session —— MongoDB 的事务必须挂在 session 上
    sess, err := r.client.StartSession()
    if err != nil {
        return err
    }
    // 步骤 2：defer 结束 session，释放底层连接资源
    defer sess.EndSession(ctx)

    // 步骤 3：WithTransaction 执行事务回调
    // 回调返回 nil → 自动 Commit；返回 error → 自动 Abort
    _, err = sess.WithTransaction(ctx, func(sc mongo.SessionContext) (interface{}, error) {
        // ⚠️ 事务内的所有操作必须用 sc（session 上下文），
        //    误用外层 ctx 的话操作会跑在事务外面，事务形同虚设！
        // 步骤 4：扣减 from 的积分；filter 带余额条件，防止超扣
        res, err := r.coll.UpdateOne(sc,
            bson.M{"_id": from, "points": bson.M{"$gte": points}},
            bson.M{"$inc": bson.M{"points": -points}},
        )
        if err != nil {
            return nil, err // 出错 → 整个事务回滚
        }
        if res.ModifiedCount == 0 {
            return nil, ErrInsufficientPoints // 余额不足（没匹配到）也回滚
        }
        // 步骤 5：给 to 加积分
        if _, err := r.coll.UpdateOne(sc,
            bson.M{"_id": to},
            bson.M{"$inc": bson.M{"points": points}},
        ); err != nil {
            return nil, err
        }
        return nil, nil // 全部成功 → 自动 Commit
    })
    return err
}

// pkg/sensitive/trie.go —— AC 自动机骨架（简化示意）
type node struct {
    children map[rune]*node
    fail     *node // 失配指针：AC 自动机的灵魂
    isEnd    bool  // 是否命中一个完整敏感词
}

func (root *node) insert(word string) { /* 沿 children 建 Trie，末节点标 isEnd */ }

// BFS 建 fail 指针：子节点的 fail = 父节点 fail 的同名子节点（没有则沿 fail 链回溯到根）
// 匹配：文本逐字走 Trie，走不通就沿 fail 链回跳，途经 isEnd 节点即命中

-- scripts/comment.sql
CREATE DATABASE IF NOT EXISTS comment_db;
USE comment_db;

CREATE TABLE comments (
    id          BIGINT   NOT NULL COMMENT '评论ID（雪花ID，应用侧生成）',
    target_type TINYINT  NOT NULL DEFAULT 1 COMMENT '1=帖子 2=预留',
    target_id   BIGINT   NOT NULL COMMENT '被评论的资源ID',
    user_id     BIGINT   NOT NULL COMMENT '评论者',
    content     TEXT     NOT NULL COMMENT '评论内容',
    parent_id   BIGINT   NOT NULL DEFAULT 0 COMMENT '父评论ID，0=一级评论',
    root_id     BIGINT   NOT NULL DEFAULT 0 COMMENT '根评论ID：一级评论=自己；回复=所在树的根',
    like_count  INT      NOT NULL DEFAULT 0 COMMENT '点赞数冗余（第07章互动服务维护）',
    reply_count INT      NOT NULL DEFAULT 0 COMMENT '回复数冗余',
    status      TINYINT  NOT NULL DEFAULT 1 COMMENT '1=正常 2=已删除 3=已屏蔽',
    created_at  DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    updated_at  DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    PRIMARY KEY (id),
    KEY idx_target (target_type, target_id, created_at), -- 查某资源的一级评论
    KEY idx_root (root_id)                               -- 查某棵评论树的全部回复
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

-- scripts/relation.sql
CREATE DATABASE IF NOT EXISTS relation_db;
USE relation_db;

CREATE TABLE follows (
    id           BIGINT  NOT NULL COMMENT '雪花ID',
    follower_id  BIGINT  NOT NULL COMMENT '关注者',
    followee_id  BIGINT  NOT NULL COMMENT '被关注者',
    status       TINYINT NOT NULL DEFAULT 1 COMMENT '1=正常 2=已取消',
    created_at   DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
    updated_at   DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    PRIMARY KEY (id),
    UNIQUE KEY uk_follower_followee (follower_id, followee_id), -- 防重复关注，toggle 的判定依据
    KEY idx_followee (followee_id, created_at)                  -- 粉丝列表专用（为什么必须单建见 3.8 节）
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

CREATE TABLE user_stats (
    user_id         BIGINT NOT NULL COMMENT '用户ID',
    following_count BIGINT NOT NULL DEFAULT 0 COMMENT '关注数',
    follower_count  BIGINT NOT NULL DEFAULT 0 COMMENT '粉丝数',
    updated_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    PRIMARY KEY (user_id)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

mysql -h127.0.0.1 -uroot -p < scripts/comment.sql
mysql -h127.0.0.1 -uroot -p < scripts/relation.sql
mysql -h127.0.0.1 -uroot -p -e "SHOW DATABASES LIKE '%_db';"
# 预期输出：结果集里出现 comment_db 与 relation_db 两行

// internal/comment/repository/model.go
package repository

import "time"

// Comment 评论表模型（字段与第 1 步 DDL 一一对应）
type Comment struct {
    ID         int64     `gorm:"primaryKey;autoIncrement:false"` // 雪花ID，插入前生成
    TargetType int8      // 1=帖子
    TargetID   int64     // 被评论的资源ID
    UserID     int64     // 评论者
    Content    string    `gorm:"type:text"`
    ParentID   int64     // 父评论ID，0=一级评论
    RootID     int64     // 根评论ID：一级评论=自己；回复=所在树的根
    LikeCount  int32     // 点赞数冗余
    ReplyCount int32     // 回复数冗余
    Status     int8      // 1=正常 2=已删除 3=已屏蔽
    CreatedAt  time.Time
    UpdatedAt  time.Time
}

func (Comment) TableName() string { return "comments" }

// internal/comment/repository/comment.go —— 发表评论：root_id 继承 + 回复数冗余
package repository

import (
    "context"
    "errors"
    "fmt"

    "github.com/bwmarrin/snowflake"
    "gorm.io/gorm"
)

var (
    ErrParentNotFound  = errors.New("父评论不存在或已删除")
    ErrCommentNotFound = errors.New("评论不存在")
)

type CommentRepository struct {
    db   *gorm.DB
    node *snowflake.Node // 第06章引入的雪花ID生成器，构造函数注入
}

func NewCommentRepository(db *gorm.DB, node *snowflake.Node) *CommentRepository {
    return &CommentRepository{db: db, node: node}
}

// Create 发表评论：parentID>0 是回复，在同一事务里继承 root_id 并给根评论回复数 +1
func (r *CommentRepository) Create(ctx context.Context, c *Comment) (int64, error) {
    c.ID = r.node.Generate().Int64() // 雪花ID由应用侧生成，不依赖 DB 自增
    err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
        if c.ParentID == 0 {
            c.RootID = c.ID // 一级评论：root_id = 自己
            return tx.Create(c).Error
        }
        // 回复：查父评论（已删除的不许回复），root_id 沿用父评论的 root_id
        var parent Comment
        if err := tx.Where("id = ? AND status = 1", c.ParentID).
            First(&parent).Error; err != nil {
            return fmt.Errorf("查父评论: %w", ErrParentNotFound)
        }
        c.RootID = parent.RootID
        if err := tx.Model(&Comment{}).Where("id = ?", c.RootID).
            UpdateColumn("reply_count", gorm.Expr("reply_count + 1")).Error; err != nil {
            return err
        }
        return tx.Create(c).Error
    })
    if err != nil {
        return 0, err
    }
    // TODO：发 Kafka 事件更新帖子评论数冗余、给被回复者发通知（复用第07章 producer，本章从简）
    return c.ID, nil
}

// internal/comment/repository/comment.go 追加（同文件、同 package）
// Delete 软删除：只能删自己的评论；删一级评论时级联软删整棵树
func (r *CommentRepository) Delete(ctx context.Context, id, uid int64) error {
    return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
        var c Comment
        // 只查"未删除"的评论：防止重复删除导致 reply_count 被重复扣减
        if err := tx.Where("id = ? AND user_id = ? AND status = 1", id, uid).First(&c).Error; err != nil {
            return fmt.Errorf("查评论: %w", ErrCommentNotFound)
        }
        if err := tx.Model(&Comment{}).Where("id = ?", c.ID).
            Update("status", 2).Error; err != nil { // 2=已删除
            return err
        }
        if c.ParentID > 0 {
            // 删的是回复：根评论的回复数 -1
            return tx.Model(&Comment{}).Where("id = ?", c.RootID).
                UpdateColumn("reply_count", gorm.Expr("reply_count - 1")).Error
        }
        // 删的是一级评论：名下所有回复一并软删（应用层级联，不用外键）
        return tx.Model(&Comment{}).Where("root_id = ? AND status = 1", c.ID).
            Update("status", 2).Error
    })
}

// internal/comment/repository/comment.go 追加
// FindByTarget 一级评论分页列表 + 每棵树最新 3 条回复（批量查，避免 N+1）
func (r *CommentRepository) FindByTarget(ctx context.Context, targetType int8, targetID int64, page, pageSize int) ([]Comment, map[int64][]Comment, error) {
    var roots []Comment
    err := r.db.WithContext(ctx).
        Where("target_type = ? AND target_id = ? AND parent_id = 0 AND status = 1", targetType, targetID).
        Order("id DESC").                              // 新评论在前
        Limit(pageSize).Offset((page - 1) * pageSize). // 本章按 page 分页；换 minID 游标见正文 3.6 节
        Find(&roots).Error
    if err != nil || len(roots) == 0 {
        return roots, nil, err
    }
    rootIDs := make([]int64, 0, len(roots))
    for _, rc := range roots {
        rootIDs = append(rootIDs, rc.ID)
    }
    // 窗口函数批量取每棵树最新 3 条——与正文 3.6 节 FindTopReplies 同一招
    var replies []Comment
    err = r.db.WithContext(ctx).Raw(`
        SELECT * FROM (
            SELECT *, ROW_NUMBER() OVER (PARTITION BY root_id ORDER BY id DESC) AS rn
            FROM comments
            WHERE root_id IN ? AND status = 1
        ) t WHERE t.rn <= 3
    `, rootIDs).Scan(&replies).Error
    if err != nil {
        return nil, nil, err
    }
    grouped := make(map[int64][]Comment, len(roots))
    for _, rc := range roots {
        grouped[rc.ID] = []Comment{} // 先占位：没有回复的评论序列化成 [] 而不是 null
    }
    for _, rep := range replies {
        grouped[rep.RootID] = append(grouped[rep.RootID], rep)
    }
    return roots, grouped, nil
}

// FindReplies "查看更多回复"：某棵树下的全部回复，按 id 正序翻页
func (r *CommentRepository) FindReplies(ctx context.Context, rootID int64, page, pageSize int) ([]Comment, error) {
    var res []Comment
    return res, r.db.WithContext(ctx).
        Where("root_id = ? AND status = 1", rootID).
        Order("id ASC").
        Limit(pageSize).Offset((page - 1) * pageSize).
        Find(&res).Error
}

# configs/config.yaml 追加（viper 统一读取；redis/etcd 段沿用第06/12章）
comment:
  http: 8200      # HTTP 端口（本章验证用）
  grpc: 9200      # gRPC 端口：服务间调用用，挂法见第12章第 5 步
  worker_id: 21   # 雪花节点号，每个服务错开（第06章的坑）
relation:
  http: 8300
  grpc: 9300
  worker_id: 31
mysql:
  comment_dsn: "root:root@tcp(localhost:3306)/comment_db?parseTime=true&loc=Local"
  relation_dsn: "root:root@tcp(localhost:3306)/relation_db?parseTime=true&loc=Local"

// internal/comment/handler.go
package handler

import (
    "errors"
    "net/http"
    "strconv"

    "github.com/gin-gonic/gin"
    "github.com/yourname/content-community/internal/comment/repository"
)

type CommentHandler struct {
    repo *repository.CommentRepository
}

func NewCommentHandler(repo *repository.CommentRepository) *CommentHandler {
    return &CommentHandler{repo: repo}
}

func (h *CommentHandler) RegisterRoutes(server *gin.Engine) {
    g := server.Group("/api/comments")
    g.POST("", h.Create)             // 发表评论 / 回复
    g.DELETE("/:id", h.Delete)       // 删除（软删）
    g.GET("", h.List)                // 一级评论列表（附前 3 条回复）
    g.GET("/:id/replies", h.Replies) // 查看更多回复
}

// 统一响应格式（全局约定）；relation 侧的 handler 包里放同样的两个函数
func ok(c *gin.Context, data any) {
    c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "success", "data": data})
}

func fail(c *gin.Context, code int, msg string) {
    c.JSON(http.StatusOK, gin.H{"code": code, "msg": msg})
}

func (h *CommentHandler) Create(c *gin.Context) {
    var req struct {
        TargetType int8   `json:"target_type" binding:"required"` // 1=帖子
        TargetID   int64  `json:"target_id" binding:"required"`
        Content    string `json:"content" binding:"required"`
        ParentID   int64  `json:"parent_id"` // 可选：>0 表示这是回复
    }
    if err := c.ShouldBindJSON(&req); err != nil {
        fail(c, 400, "参数错误")
        return
    }
    uid := c.GetInt64("user_id") // JWT 中间件写入（第03章）；本地调试可先临时写死
    id, err := h.repo.Create(c, &repository.Comment{
        TargetType: req.TargetType, TargetID: req.TargetID,
        UserID: uid, Content: req.Content, ParentID: req.ParentID,
    })
    if err != nil {
        if errors.Is(err, repository.ErrParentNotFound) {
            fail(c, 400, "父评论不存在或已删除")
            return
        }
        fail(c, 500, "系统错误") // 原始错误按全局约定 %w 包装后 zap 打 error，不外泄给前端
        return
    }
    ok(c, gin.H{"id": id})
}

// internal/comment/handler.go 追加
func (h *CommentHandler) List(c *gin.Context) {
    targetType, _ := strconv.Atoi(c.DefaultQuery("target_type", "1"))
    targetID, _ := strconv.ParseInt(c.Query("target_id"), 10, 64)
    page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
    pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "20"))
    roots, replies, err := h.repo.FindByTarget(c, int8(targetType), targetID, page, pageSize)
    if err != nil {
        fail(c, 500, "系统错误")
        return
    }
    type commentVO struct { // 组装"一级评论 + 前 3 条回复"的返回结构
        repository.Comment
        Replies []repository.Comment `json:"replies"`
    }
    list := make([]commentVO, 0, len(roots))
    for _, rc := range roots {
        list = append(list, commentVO{Comment: rc, Replies: replies[rc.ID]})
    }
    ok(c, gin.H{"comments": list})
}

// Delete / Replies 两个 handler 是"取参 → 调 repo → ok()"的同款，不再重复贴

// cmd/comment/main.go —— 组装顺序与第12章 cmd/user 完全同构
package main

import (
    "fmt"
    "net/http"
    "os"
    "os/signal"
    "syscall"

    "github.com/bwmarrin/snowflake"
    "github.com/gin-gonic/gin"
    "github.com/spf13/viper"
    "go.uber.org/zap"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"

    "github.com/yourname/content-community/internal/comment/handler"
    "github.com/yourname/content-community/internal/comment/ioc"
    "github.com/yourname/content-community/internal/comment/repository"
    "github.com/yourname/content-community/pkg/registry"
)

func main() {
    // 1. 配置 + 日志（全局约定：viper 读 configs/，zap 结构化日志）
    viper.SetConfigFile("configs/config.yaml")
    if err := viper.ReadInConfig(); err != nil {
        panic(err)
    }
    logger, _ := zap.NewProduction()
    zap.ReplaceGlobals(logger)

    // 2. 依赖：comment_db 的 GORM 连接 + 雪花节点
    db, err := gorm.Open(mysql.Open(viper.GetString("mysql.comment_dsn")), &gorm.Config{})
    if err != nil {
        panic(err)
    }
    node, _ := snowflake.NewNode(viper.GetInt("comment.worker_id"))

// cmd/comment/main.go 续（同一个文件，接着上面的花括号）
    // 3. HTTP 路由（ioc.InitEtcdClient 与第12章 internal/user/ioc/etcd.go 一模一样，直接复制）
    server := gin.Default()
    handler.NewCommentHandler(repository.NewCommentRepository(db, node)).RegisterRoutes(server)

    // 4. 注册 ETCD：先起监听再注册（顺序的理由见第12章）；gRPC 9200 挂法同第12章第 5 步
    port := viper.GetInt("comment.http")
    reg := registry.NewRegistry(ioc.InitEtcdClient(logger), logger)
    ip := registry.GetOutboundIP()
    if err := reg.Register(&registry.ServiceInstance{
        ServiceName: "comment-service",
        InstanceID:  fmt.Sprintf("comment-service-%s:%d", ip, port),
        Address:     ip, Port: port, Protocol: "http", Weight: 100,
    }); err != nil {
        panic(err) // fail-fast：注册不上就退出，别让客户端拿到死地址（第12章）
    }

    // 5. 优雅停机：先注销（客户端立刻感知，不等 TTL）再关 HTTP
    go func() {
        quit := make(chan os.Signal, 1)
        signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
        <-quit
        _ = reg.Deregister()
        _ = server.Shutdown(nil)
    }()
    if err := http.ListenAndServe(fmt.Sprintf(":%d", port), server); err != nil {
        panic(err)
    }
}

go run ./cmd/comment
# 另开终端。以下 curl 假设 JWT 中间件已按第03章解析出 uid；
# 本地联调最省事的做法：临时给中间件加一个 ?debug_uid=1 后门，验完删掉
curl -s -X POST localhost:8200/api/comments -H 'Content-Type: application/json' \
  -d '{"target_type":1,"target_id":42,"content":"写得好！"}'
# 预期输出：{"code":0,"msg":"success","data":{"id":736819...}}（雪花ID）
curl -s -X POST localhost:8200/api/comments -H 'Content-Type: application/json' \
  -d '{"target_type":1,"target_id":42,"content":"同感，尤其是树形那段","parent_id":736819...}'
# 预期输出：{"code":0,...,"data":{"id":736820...}}
curl -s "localhost:8200/api/comments?target_type=1&target_id=42&page=1&page_size=20"
# 预期输出：data.comments[0] 是一级评论，replies 数组里带着刚才那条回复，reply_count=1
docker exec content-etcd etcdctl get /services/comment-service/ --prefix
# 预期输出：本实例的注册 JSON（IP/端口换成你的）；Ctrl+C 后再查，key 立刻消失

// internal/relation/repository/model.go
package repository

import "time"

const (
    StatusActive   int8 = 1 // 已关注
    StatusCanceled int8 = 2 // 已取消
)

// Follow 关注关系表：约定 A 关注 B → follower=A、followee=B（与正文 3.8 节一致）
type Follow struct {
    ID         int64     `gorm:"primaryKey;autoIncrement:false"`
    FollowerID int64     // 关注者
    FolloweeID int64     // 被关注者
    Status     int8      // 1=正常 2=已取消
    CreatedAt  time.Time
    UpdatedAt  time.Time
}

func (Follow) TableName() string { return "follows" }

// UserStat 冗余计数表
type UserStat struct {
    UserID         int64 `gorm:"primaryKey"`
    FollowingCount int64 // 关注数
    FollowerCount  int64 // 粉丝数
    UpdatedAt      time.Time
}

func (UserStat) TableName() string { return "user_stats" }

// internal/relation/repository/follow.go
package repository

import (
    "context"
    "fmt"
    "time"

    "github.com/bwmarrin/snowflake"
    "gorm.io/gorm"
    "gorm.io/gorm/clause"
)

type FollowRepository struct {
    db   *gorm.DB
    node *snowflake.Node
}

func NewFollowRepository(db *gorm.DB, node *snowflake.Node) *FollowRepository {
    return &FollowRepository{db: db, node: node}
}

// FindOne 查一对用户的关系记录（gorm.ErrRecordNotFound = 从未关注过）
func (r *FollowRepository) FindOne(ctx context.Context, follower, followee int64) (Follow, error) {
    var f Follow
    err := r.db.WithContext(ctx).
        Where("follower_id = ? AND followee_id = ?", follower, followee).First(&f).Error
    return f, err
}

// internal/relation/repository/follow.go 续
// UpdateStatus 写关系 + 双方计数，一个事务搞定（upsert 语义与第07章点赞同款）
func (r *FollowRepository) UpdateStatus(ctx context.Context, follower, followee int64, status int8) error {
    now := time.Now()
    return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
        // 1) 关系表 upsert：唯一索引冲突时只改 status——天然幂等，并发重复点也不怕
        if err := tx.Clauses(clause.OnConflict{
            Columns:   []clause.Column{{Name: "follower_id"}, {Name: "followee_id"}},
            DoUpdates: clause.Assignments(map[string]any{"status": status, "updated_at": now}),
        }).Create(&Follow{
            ID: r.node.Generate().Int64(), FollowerID: follower, FolloweeID: followee,
            Status: status, CreatedAt: now, UpdatedAt: now,
        }).Error; err != nil {
            return err
        }
        // 2) 双方计数同增同减：关注 +1、取消 -1
        delta := int64(1)
        if status == StatusCanceled {
            delta = -1
        }
        if err := upsertStat(tx, follower, "following_count", delta, now); err != nil {
            return err
        }
        return upsertStat(tx, followee, "follower_count", delta, now)
    })
}

// upsertStat 计数行不存在则插入（首次关注），存在则增减。
// col 只会是上面写死的两个列名、不接收外部输入，无注入风险
func upsertStat(tx *gorm.DB, uid int64, col string, delta int64, now time.Time) error {
    initVal := delta
    if initVal < 0 {
        initVal = 0 // 取消时行必然已存在、走不到插入分支，这里只是保险
    }
    return tx.Exec(fmt.Sprintf(`
        INSERT INTO user_stats (user_id, %s, updated_at) VALUES (?, ?, ?)
        ON DUPLICATE KEY UPDATE %s = %s + ?, updated_at = VALUES(updated_at)
    `, col, col, col), uid, initVal, now, delta).Error
}

// internal/relation/service/follow.go
package service

import (
    "context"
    "errors"

    "gorm.io/gorm"
    "go.uber.org/zap"

    "github.com/yourname/content-community/internal/relation/cache"
    "github.com/yourname/content-community/internal/relation/repository"
)

var ErrFollowSelf = errors.New("不能关注自己")

type RelationService struct {
    repo   *repository.FollowRepository
    cache  *cache.FollowCache
    logger *zap.Logger
}

func NewRelationService(repo *repository.FollowRepository, c *cache.FollowCache,
    logger *zap.Logger) *RelationService {
    return &RelationService{repo: repo, cache: c, logger: logger}
}

// ToggleFollow 关注/取消关注二合一：已关注则取消，未关注则添加；返回最终状态
func (s *RelationService) ToggleFollow(ctx context.Context, follower, followee int64) (bool, error) {
    if follower == followee {
        return false, ErrFollowSelf
    }
    rel, err := s.repo.FindOne(ctx, follower, followee)
    if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
        return false, err
    }
    following := rel.Status == repository.StatusActive
    target := repository.StatusActive
    if following {
        target = repository.StatusCanceled
    }
    if err := s.repo.UpdateStatus(ctx, follower, followee, target); err != nil {
        return false, err
    }
    followedNow := target == repository.StatusActive
    // 3) Redis 同步：计数 Hash HINCRBY + 关注 Set SADD/SREM（Set 是第 7 步共同关注的原料）。
    // 缓存失败只打日志、不回滚 DB——计数漂移可由 3.10 节的"定时全量对表"纠偏
    if err := s.cache.SyncOnToggle(ctx, follower, followee, followedNow); err != nil {
        s.logger.Error("同步关注缓存失败", zap.Error(err))
    }
    // TODO：发 Kafka follow-events（通知被关注者 + Feed 收件箱预热，第19章接消费端），本章从简
    s.logger.Info("关注关系变更",
        zap.Int64("follower", follower), zap.Int64("followee", followee),
        zap.Bool("followed", followedNow))
    return followedNow, nil
}

// internal/relation/repository/follow.go 追加（同文件、同 package）

// ListFollowing 关注列表：WHERE follower_id 命中唯一索引的最左前缀
func (r *FollowRepository) ListFollowing(ctx context.Context, uid int64, page, pageSize int) ([]Follow, error) {
    var res []Follow
    return res, r.db.WithContext(ctx).
        Where("follower_id = ? AND status = ?", uid, StatusActive).
        Order("id DESC"). // 雪花ID趋势递增，倒序=最近关注在前
        Limit(pageSize).Offset((page - 1) * pageSize).
        Find(&res).Error
}

// ListFollowers 粉丝列表：WHERE followee_id 走 idx_followee——
// 没有这个索引就是全表扫描，最左前缀的坑见正文 3.8 节
func (r *FollowRepository) ListFollowers(ctx context.Context, uid int64, page, pageSize int) ([]Follow, error) {
    var res []Follow
    return res, r.db.WithContext(ctx).
        Where("followee_id = ? AND status = ?", uid, StatusActive).
        Order("id DESC").
        Limit(pageSize).Offset((page - 1) * pageSize).
        Find(&res).Error
}

// internal/relation/repository/follow.go 追加

// Status 关系状态：我→TA 与 TA→我 各查一次存在性
func (r *FollowRepository) Status(ctx context.Context, uid, peer int64) (following, followed bool, err error) {
    exists := func(follower, followee int64) (bool, error) {
        var n int64
        e := r.db.WithContext(ctx).Model(&Follow{}).
            Where("follower_id = ? AND followee_id = ? AND status = ?",
                follower, followee, StatusActive).
            Count(&n).Error // 唯一索引保证最多一行，COUNT 足够
        return n > 0, e
    }
    if following, err = exists(uid, peer); err != nil {
        return
    }
    followed, err = exists(peer, uid)
    return
}

// ListFolloweeIDs 全量关注ID（共同关注回源 + Set 预热用，不分页）
func (r *FollowRepository) ListFolloweeIDs(ctx context.Context, uid int64) ([]int64, error) {
    var ids []int64
    err := r.db.WithContext(ctx).Model(&Follow{}).
        Where("follower_id = ? AND status = ?", uid, StatusActive).
        Order("id DESC").
        Limit(10000). // 上限保护：关注列表本身就该有产品上限（如微博 2000）
        Pluck("followee_id", &ids).Error
    return ids, err
}

// internal/relation/service/follow.go 追加：透传层
func (s *RelationService) ListFollowing(ctx context.Context, uid int64, page, pageSize int) ([]repository.Follow, error) {
    return s.repo.ListFollowing(ctx, uid, page, pageSize)
}

func (s *RelationService) ListFollowers(ctx context.Context, uid int64, page, pageSize int) ([]repository.Follow, error) {
    return s.repo.ListFollowers(ctx, uid, page, pageSize)
}

func (s *RelationService) Status(ctx context.Context, uid, peer int64) (following, followed bool, err error) {
    return s.repo.Status(ctx, uid, peer)
}

// internal/relation/handler.go —— ok / fail 两个函数与 comment 侧一模一样，各服务包里放一份
package handler

import (
    "strconv"

    "github.com/gin-gonic/gin"
    "github.com/yourname/content-community/internal/relation/service"
)

type RelationHandler struct {
    svc *service.RelationService
}

func NewRelationHandler(svc *service.RelationService) *RelationHandler {
    return &RelationHandler{svc: svc}
}

func (h *RelationHandler) RegisterRoutes(server *gin.Engine) {
    g := server.Group("/api/relations")
    g.POST("/follow", h.Follow)      // 关注 / 取消关注（toggle）
    g.GET("/following", h.Following) // 关注列表
    g.GET("/followers", h.Followers) // 粉丝列表
    g.GET("/status", h.Status)       // 关系状态（是否关注 / 被关注 / 互关）
    g.GET("/common", h.Common)       // 共同关注（第 7 步实现）
}

func (h *RelationHandler) Follow(c *gin.Context) {
    var req struct {
        FolloweeID int64 `json:"followee_id" binding:"required"`
    }
    if err := c.ShouldBindJSON(&req); err != nil {
        fail(c, 400, "参数错误")
        return
    }
    followed, err := h.svc.ToggleFollow(c, c.GetInt64("user_id"), req.FolloweeID)
    if err != nil {
        fail(c, 500, "系统错误")
        return
    }
    ok(c, gin.H{"followed": followed})
}

// internal/relation/handler.go 追加
func (h *RelationHandler) Following(c *gin.Context) {
    uid, page, pageSize := parsePage(c)
    follows, err := h.svc.ListFollowing(c, uid, page, pageSize)
    if err != nil {
        fail(c, 500, "系统错误")
        return
    }
    ok(c, gin.H{"follows": follows})
}

func (h *RelationHandler) Followers(c *gin.Context) {
    uid, page, pageSize := parsePage(c)
    follows, err := h.svc.ListFollowers(c, uid, page, pageSize)
    if err != nil {
        fail(c, 500, "系统错误")
        return
    }
    ok(c, gin.H{"follows": follows})
}

func (h *RelationHandler) Status(c *gin.Context) {
    peerID, _ := strconv.ParseInt(c.Query("user_id"), 10, 64)
    following, followed, err := h.svc.Status(c, c.GetInt64("user_id"), peerID)
    if err != nil {
        fail(c, 500, "系统错误")
        return
    }
    ok(c, gin.H{"following": following, "followed": followed,
        "mutual": following && followed}) // 互关 = 我关注TA 且 TA关注我
}

// parsePage 列表接口三件套：user_id + page + page_size（默认 1 / 20）
func parsePage(c *gin.Context) (uid int64, page, pageSize int) {
    uid, _ = strconv.ParseInt(c.Query("user_id"), 10, 64)
    page, _ = strconv.Atoi(c.DefaultQuery("page", "1"))
    pageSize, _ = strconv.Atoi(c.DefaultQuery("page_size", "20"))
    return
}

go run ./cmd/relation
# uid 的取法同第 4 步（JWT 或调试后门）。先关注 100，再原样发一次验证 toggle：
curl -s -X POST localhost:8300/api/relations/follow -H 'Content-Type: application/json' \
  -d '{"followee_id":100}'
# 预期输出：{"code":0,"msg":"success","data":{"followed":true}}；再发一次预期 followed:false
curl -s "localhost:8300/api/relations/status?user_id=100"
# 预期输出：..."data":{"following":true,"followed":false,"mutual":false}}

// internal/relation/cache/follow.go —— 计数 Hash + 关注 Set（共同关注的原料）
package cache

import (
    "context"
    "strconv"
    "time"

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

type FollowCache struct {
    client redis.Cmdable
}

func NewFollowCache(client redis.Cmdable) *FollowCache {
    return &FollowCache{client: client}
}

func setKey(uid int64) string { return "relation:follow_set:" + strconv.FormatInt(uid, 10) }

// SyncOnToggle toggle 后同步 Redis：计数 Hash HINCRBY（3.9 节的计数方案）
// + 关注 Set SADD/SREM。成对更新用 TxPipeline，理由见 3.9 节的对比表
func (c *FollowCache) SyncOnToggle(ctx context.Context, follower, followee int64, followed bool) error {
    delta := int64(1)
    if !followed {
        delta = -1
    }
    pipe := c.client.TxPipeline()
    pipe.HIncrBy(ctx, "relation:count:"+strconv.FormatInt(follower, 10), "following", delta)
    pipe.HIncrBy(ctx, "relation:count:"+strconv.FormatInt(followee, 10), "follower", delta)
    if followed {
        pipe.SAdd(ctx, setKey(follower), followee)
    } else {
        pipe.SRem(ctx, setKey(follower), followee)
    }
    _, err := pipe.Exec(ctx)
    return err
}

// internal/relation/cache/follow.go 续

// SInter 共同关注：两个 Set 都存在才敢信结果；否则第二个返回值 false，让 Service 回源 DB
func (c *FollowCache) SInter(ctx context.Context, uid, peer int64) ([]int64, bool, error) {
    n, err := c.client.Exists(ctx, setKey(uid), setKey(peer)).Uint64()
    if err != nil || n != 2 {
        return nil, false, err // 任一集合没预热过，SINTER 的空结果不可信
    }
    members, err := c.client.SInter(ctx, setKey(uid), setKey(peer)).Result()
    if err != nil {
        return nil, false, err
    }
    res := make([]int64, 0, len(members))
    for _, m := range members {
        id, _ := strconv.ParseInt(m, 10, 64)
        res = append(res, id)
    }
    return res, true, nil
}

// Warmup 回源后预热：全量关注列表灌回 Set，TTL 一小时（冷用户自然淘汰）
func (c *FollowCache) Warmup(ctx context.Context, uid int64, followeeIDs []int64) error {
    if len(followeeIDs) == 0 {
        return nil
    }
    members := make([]any, 0, len(followeeIDs))
    for _, id := range followeeIDs {
        members = append(members, id) // SAdd 是可变参数，切片要展开传
    }
    if err := c.client.SAdd(ctx, setKey(uid), members...).Err(); err != nil {
        return err
    }
    return c.client.Expire(ctx, setKey(uid), time.Hour).Err()
}

// internal/relation/service/follow.go 追加：共同关注——SINTER 命中直接用，未预热回源求交集并回写
func (s *RelationService) CommonFollow(ctx context.Context, uid, peer int64) ([]int64, error) {
    ids, hit, err := s.cache.SInter(ctx, uid, peer)
    if err != nil {
        s.logger.Error("读共同关注缓存失败，降级 DB", zap.Error(err))
    }
    if hit {
        return ids, nil
    }
    // 回源：查两边全量关注列表，内存求交集（基础实现）
    mine, err := s.repo.ListFolloweeIDs(ctx, uid)
    if err != nil {
        return nil, err
    }
    theirs, err := s.repo.ListFolloweeIDs(ctx, peer)
    if err != nil {
        return nil, err
    }
    set := make(map[int64]struct{}, len(theirs))
    for _, id := range theirs {
        set[id] = struct{}{}
    }
    common := make([]int64, 0, len(mine))
    for _, id := range mine {
        if _, ok := set[id]; ok {
            common = append(common, id)
        }
    }
    // 回写预热两个 Set：下一次 SINTER 直接命中
    if err := s.cache.Warmup(ctx, uid, mine); err != nil {
        s.logger.Error("预热关注Set失败", zap.Error(err))
    }
    if err := s.cache.Warmup(ctx, peer, theirs); err != nil {
        s.logger.Error("预热关注Set失败", zap.Error(err))
    }
    return common, nil
}

// internal/relation/handler.go 追加
func (h *RelationHandler) Common(c *gin.Context) {
    peerID, _ := strconv.ParseInt(c.Query("user_id"), 10, 64)
    ids, err := h.svc.CommonFollow(c, c.GetInt64("user_id"), peerID)
    if err != nil {
        fail(c, 500, "系统错误")
        return
    }
    ok(c, gin.H{"common_follows": ids})
}

# 让 1、2 两个用户都关注 100 和 200（uid 取法同第 4 步）
for uid in 1 2; do for peer in 100 200; do
  curl -s -X POST localhost:8300/api/relations/follow -H 'Content-Type: application/json' \
    -d "{\"followee_id\":$peer}" > /dev/null
done; done
curl -s "localhost:8300/api/relations/common?user_id=2"
# 预期输出：..."data":{"common_follows":[200,100]}}（按关注时间倒序）
redis-cli SINTER relation:follow_set:1 relation:follow_set:2
# 预期输出两行：200 / 100——接口与 Redis 侧一致，说明 SINTER 优化已生效

content-community/
├── configs/
│   └── config.yaml            # 修改：追加 comment/relation 的端口、worker_id 与两个 DSN
├── scripts/
│   ├── comment.sql            # 新增：comment_db / comments 表
│   └── relation.sql           # 新增：relation_db / follows / user_stats 表
├── cmd/
│   ├── comment/main.go        # 新增：评论服务入口（HTTP 8200，注册 ETCD）
│   └── relation/main.go       # 新增：关系服务入口（HTTP 8300，注册 ETCD）
└── internal/
    ├── comment/
    │   ├── handler.go         # 新增：四个评论接口（含统一响应 ok/fail）
    │   ├── ioc/etcd.go        # 新增：复制第12章 user 侧同名文件改包名
    │   └── repository/
    │       ├── model.go       # 新增：Comment 模型
    │       └── comment.go     # 新增：发表/软删/树形查询（root_id 继承核心）
    └── relation/
        ├── handler.go         # 新增：follow/following/followers/status/common
        ├── ioc/etcd.go        # 新增：同上
        ├── cache/follow.go    # 新增：计数 Hash + 关注 Set（SINTER）
        ├── service/follow.go  # 新增：ToggleFollow / CommonFollow
        └── repository/
            ├── model.go       # 新增：Follow / UserStat 模型
            └── follow.go      # 新增：toggle 事务 + 列表 + 关系状态