发帖功能与缓存

// domain/article.go
package domain

const (
    ArticleStatusUnknown    uint8 = 0  // 未知，零值无意义
    ArticleStatusUnpublished uint8 = 1 // 未发表
    ArticleStatusPublished   uint8 = 2 // 已发表
    ArticleStatusPrivate     uint8 = 3 // 仅自己可见
)

// web/article.go
type Article struct {
    Id      int64  `json:"id"`
    Title   string `json:"title"`
    Content string `json:"content"`
}

type ArticleHandler struct {
    svc service.ArticleService
}

func (h *ArticleHandler) RegisterRoutes(server *gin.Engine) {
    g := server.Group("/articles")
    g.POST("/edit", h.Edit)       // 新建或修改
    g.POST("/publish", h.Publish) // 发表
}

// web/article_test.go
func TestArticleHandler_Edit(t *testing.T) {
    // 步骤 1：定义用例表（mock/reqBody/want...）
    testCases := []struct {
        name     string
        mock     func(ctrl *gomock.Controller) service.ArticleService
        reqBody  string
        wantCode int
        wantRes  web.Result[int64]
    }{
        // 用例稍后填
    }

    // 步骤 2：遍历用例
    for _, tc := range testCases {
        t.Run(tc.name, func(t *testing.T) {
            ctrl := gomock.NewController(t)
            defer ctrl.Finish()

            svc := tc.mock(ctrl)
            h := web.NewArticleHandler(svc)
            server := gin.Default()
            h.RegisterRoutes(server)

            req := httptest.NewRequest(http.MethodPost, "/articles/edit",
                strings.NewReader(tc.reqBody))
            req.Header.Set("Content-Type", "application/json")
            recorder := httptest.NewRecorder()

            server.ServeHTTP(recorder, req)

            assert.Equal(t, tc.wantCode, recorder.Code)
            var res web.Result[int64]
            err := json.Unmarshal(recorder.Body.Bytes(), &res)
            require.NoError(t, err)
            assert.Equal(t, tc.wantRes, res)
        })
    }
}

{
    name: "新建帖子成功",
    mock: func(ctrl *gomock.Controller) service.ArticleService {
        svc := svcmocks.NewMockArticleService(ctrl)
        // 期望 Save 被调用，返回 id=1
        svc.EXPECT().Save(gomock.Any(), domain.Article{
            Title:   "我的标题",
            Content: "我的内容",
        }).Return(int64(1), nil)
        return svc
    },
    reqBody:  `{"title":"我的标题","content":"我的内容"}`,
    wantCode: 200,
    wantRes: web.Result[int64]{Data: 1},
},

// web/article.go
func (h *ArticleHandler) Edit(ctx *gin.Context) {
    // 步骤 1：绑定请求体
    var req Article
    if err := ctx.Bind(&req); err != nil {
        return
    }
    // 步骤 2：从登录态拿创作者 ID
    uid, _ := ctx.Get("claims")
    claims := uid.(*jwt.Claims)

    // 步骤 3：调用 Service 保存
    id, err := h.svc.Save(ctx, domain.Article{
        Id:       req.Id,
        Title:    req.Title,
        Content:  req.Content,
        AuthorId: claims.Uid,
    })
    if err != nil {
        ctx.JSON(http.StatusOK, web.Result{Code: 5, Msg: "系统错误"})
        return
    }
    ctx.JSON(http.StatusOK, web.Result{Data: id})
}

{
    name: "修改帖子成功",
    before: func(t *testing.T) {
        // 在数据库中插入一条已有数据
        db.Exec("INSERT INTO articles (id, title, content, author_id) VALUES (?, ?, ?, ?)",
            1, "旧标题", "旧内容", 123)
    },
    after: func(t *testing.T) {
        // 验证字段都被修改了
        // 验证不该修改的字段（如 author_id）没变
        var a Article
        db.First(&a, 1)
        assert.Equal(t, "新标题", a.Title)
        assert.Equal(t, int64(123), a.AuthorId)  // 作者不该变
    },
    reqBody:  `{"id":1,"title":"新标题","content":"新内容"}`,
    wantCode: 200,
},

// dao/article.go
func (d *ArticleDAO) UpdateById(ctx context.Context, art Article) error {
    // 步骤 1：带 author_id 条件，只改"自己的"帖子
    res := d.db.WithContext(ctx).Model(&Article{}).
        Where("id = ? AND author_id = ?", art.Id, art.AuthorId).  // 关键！
        Updates(map[string]any{
            "title":   art.Title,
            "content": art.Content,
            "utime":   time.Now().UnixMilli(),
        })
    if res.Error != nil {
        return res.Error
    }
    // 步骤 2：没命中行 = ID 不存在 或 不是作者
    if res.RowsAffected == 0 {
        return errors.New("更新失败")
    }
    return nil
}

func (h *ArticleHandler) Publish(ctx *gin.Context) {
    // 步骤 1：绑定请求体
    var req Article
    if err := ctx.Bind(&req); err != nil {
        return
    }
    // 步骤 2：从登录态拿创作者 ID
    uid, _ := ctx.Get("claims")
    claims := uid.(*jwt.Claims)

    // 步骤 3：调用 Service 发表
    id, err := h.svc.Publish(ctx, domain.Article{
        Id:       req.Id,
        Title:    req.Title,
        Content:  req.Content,
        AuthorId: claims.Uid,
    })
    if err != nil {
        ctx.JSON(http.StatusOK, web.Result{Code: 5, Msg: "系统错误"})
        return
    }
    ctx.JSON(http.StatusOK, web.Result{Data: id})
}

{
    name: "新建发表成功",
    mock: func(ctrl *gomock.Controller) service.ArticleService {
        svc := svcmocks.NewMockArticleService(ctrl)
        svc.EXPECT().Publish(gomock.Any(), domain.Article{
            Title:   "标题",
            Content: "内容",
        }).Return(int64(1), nil)
        return svc
    },
    reqBody:  `{"title":"标题","content":"内容"}`,
    wantCode: 200,
    wantRes:  web.Result[int64]{Data: 1},
},

type articleService struct {
    authorRepo repository.ArticleAuthorRepository  // 操作制作库
    readerRepo repository.ArticleReaderRepository  // 操作线上库
}

func (s *articleService) Publish(ctx context.Context, art domain.Article) (int64, error) {
    // 步骤 1：保存到制作库
    art.Status = domain.ArticleStatusPublished
    id, err := s.authorRepo.Save(ctx, art)
    if err != nil {
        return 0, err
    }
    art.Id = id
    // 步骤 2：同步到线上库
    err = s.readerRepo.Save(ctx, art)
    if err != nil {
        // 部分失败：制作库已写，线上库失败
        // 创作者会看到发表失败，可以重试
        // 读者要么看不到，要么看到上一次发表的版本
        return 0, err
    }
    return id, nil
}

type articleRepository struct {
    dao dao.ArticleDAO
}

func (r *articleRepository) Sync(ctx context.Context, art domain.Article) error {
    return r.dao.Sync(ctx, art)
}

// dao 层用 GORM 闭包事务
func (d *ArticleDAO) Sync(ctx context.Context, art Article) error {
    return d.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
        // 步骤 1：制作库更新状态
        if err := tx.Model(&Article{}).
            Where("id = ?", art.Id).
            Updates(map[string]any{"status": art.Status}).Error; err != nil {
            return err
        }
        // 步骤 2：线上库 Upsert
        return tx.Clauses(clause.OnConflict{
            Columns:   []clause.Column{{Name: "id"}},
            DoUpdates: clause.Assignments(map[string]any{...}),
        }).Create(&PublishedArticle{...}).Error
    })
}

func (d *ArticleDAO) Sync(ctx context.Context, art Article) error {
    return d.db.Transaction(func(tx *gorm.DB) error {
        // 事务里同时操作两张表
        if err := tx.Model(&Article{}).Where("id = ?", art.Id).
            Updates(...).Error; err != nil {
            return err
        }
        return tx.Clauses(clause.OnConflict{...}).
            Create(&PublishedArticle{...}).Error
    })
}

// GORM Upsert
db.Clauses(clause.OnConflict{
    Columns:   []clause.Column{{Name: "id"}},         // 冲突判定列
    DoUpdates: clause.Assignments(map[string]any{...}), // 冲突时更新
}).Create(&art)

func (h *ArticleHandler) Withdraw(ctx *gin.Context) {
    // 接收 id，校验登录态
    // 调用 svc.Withdraw
}

// dao 通过事务同时更新两张表的状态
func (d *ArticleDAO) SyncStatus(ctx context.Context, id, authorId int64, status uint8) error {
    // 步骤 1：制作库 + 线上库同时更新状态（都带 author_id 条件）
    return d.db.Transaction(func(tx *gorm.DB) error {
        if err := tx.Model(&Article{}).
            Where("id = ? AND author_id = ?", id, authorId).
            Updates(map[string]any{"status": status}).Error; err != nil {
            return err
        }
        return tx.Model(&PublishedArticle{}).
            Where("id = ?", id).
            Updates(map[string]any{"status": status}).Error
    })
}

// 初始化客户端
client, _ := mongo.Connect(context.TODO(),
    options.Client().ApplyURI("mongodb://localhost:27017"))
db := client.Database("webook")
col := db.Collection("articles")

// 插入
res, _ := col.InsertOne(ctx, Article{Title: "x", Content: "y"})
id := res.InsertedID  // 是字符串，不是数字！

// 查找（用结构体构造查询条件）
var art Article
err := col.FindOne(ctx, Article{Id: 1}).Decode(&art)
if errors.Is(err, mongo.ErrNoDocuments) {
    // 没找到
}

// 更新
col.UpdateOne(ctx, bson.M{"_id": 1}, bson.M{"$set": bson.M{"title": "new"}})

// 删除
col.DeleteOne(ctx, bson.M{"_id": 1})

// OR
col.Find(ctx, bson.D{{Key: "$or", Value: bson.A{
    bson.D{{Key: "x", Value: 1}},
    bson.D{{Key: "y", Value: 2}},
}})

// IN
col.Find(ctx, bson.D{{Key: "x", Value: bson.D{{Key: "$in", Value: bson.A{1,2,3}}}}})

// 用 bwmarrin/snowflake 库
import "github.com/bwmarrin/snowflake"

node, _ := snowflake.NewNode(1)  // worker ID = 1
id := node.Generate().Int64()    // 生成 int64 ID

type ArticleMongoDAO struct {
    col  *mongo.Collection
    node *snowflake.Node
}

func (d *ArticleMongoDAO) Insert(ctx context.Context, art Article) (int64, error) {
    // 步骤 1：雪花算法生成 ID
    art.Id = d.node.Generate().Int64()
    art.Ctime = time.Now().UnixMilli()
    art.Utime = time.Now().UnixMilli()
    // 步骤 2：插入
    _, err := d.col.InsertOne(ctx, art)
    if err != nil {
        return 0, err
    }
    return art.Id, nil
}

func (d *ArticleMongoDAO) Update(ctx context.Context, art Article) error {
    // 步骤 1：显式指定要更新的字段，避免零值覆盖
    _, err := d.col.UpdateOne(ctx, bson.M{"_id": art.Id, "author_id": art.AuthorId},
        bson.M{"$set": bson.M{
            "title":   art.Title,
            "content": art.Content,
            "utime":   time.Now().UnixMilli(),
        }})
    return err
}

func (d *ArticleMongoDAO) Sync(ctx context.Context, art Article) error {
    // 没有 MongoDB 事务（本场景不需要）
    // Upsert 语义：$set 用于更新，$setOnInsert 用于插入时引入额外字段
    filter := bson.M{"_id": art.Id}
    update := bson.M{
        "$set": bson.M{
            "title":   art.Title,
            "content": art.Content,
            "status":  art.Status,
            "utime":   time.Now().UnixMilli(),
        },
        "$setOnInsert": bson.M{
            "ctime": time.Now().UnixMilli(),
        },
    }
    // 步骤 1：Upsert（存在则更新，不存在则插入）
    _, err := d.col.UpdateOne(ctx, filter, update, options.Update().SetUpsert(true))
    return err
}

//go get github.com/aws/aws-sdk-go-v2/config
//go get github.com/aws/aws-sdk-go-v2/service/s3

cfg, _ := config.LoadDefaultConfig(ctx,
    config.WithRegion("us-east-1"),
    config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(
        "accessKey", "secretKey", "")),
)
client := s3.NewFromConfig(cfg, func(o *s3.Options) {
    o.BaseEndpoint = aws.String("https://cos.ap-shanghai.myqcloud.com")
})

// 上传文件
_, err := client.PutObject(ctx, &s3.PutObjectInput{
    Bucket:      aws.String("webook"),
    Key:         aws.String(fmt.Sprintf("article/%d.html", id)),
    Body:        strings.NewReader(content),
    ContentType: aws.String("text/html;charset=utf-8"),  // 注意 charset 防乱码
})

// dao.articleOSSDAO.go
type ArticleDAOS3 struct {
    db *gorm.DB
    s3 *s3.Client
}

func (d *ArticleDAOS3) Sync(ctx context.Context, art Article) error {
    // 步骤 1：制作库（不含 Content，Content 在 OSS）
    return d.db.Transaction(func(tx *gorm.DB) error {
        if err := tx.Model(&Article{}).Where("id = ?", art.Id).
            Updates(map[string]any{"title": art.Title, "status": art.Status}).Error; err != nil {
            return err
        }
        // 步骤 2：线上库（不含 Content）
        if err := tx.Clauses(clause.OnConflict{...}).
            Create(&PublishedArticle{...}).Error; err != nil {
            return err
        }
        // 步骤 3：Content 上传到 OSS
        _, err := d.s3.PutObject(ctx, &s3.PutObjectInput{
            Bucket: aws.String("webook"),
            Key:    aws.String(fmt.Sprintf("article/%d.html", art.Id)),
            Body:   strings.NewReader(art.Content),
        })
        return err
    })
}

type ListReq struct {
    Offset int `form:"offset"`
    Limit  int `form:"limit"`
}

func (h *ArticleHandler) List(ctx *gin.Context) {
    // 步骤 1：绑定分页参数
    var req ListReq
    if err := ctx.Bind(&req); err != nil {
        return
    }
    // 步骤 2：限制最大每页数量，防一次性拉爆
    if req.Limit > 100 {
        req.Limit = 100
    }
    uid := ctx.MustGet("claims").(*jwt.Claims).Uid

    // 步骤 3：查列表
    arts, err := h.svc.List(ctx, uid, req.Offset, req.Limit)
    if err != nil {
        ctx.JSON(http.StatusOK, web.Result{Code: 5, Msg: "系统错误"})
        return
    }
    ctx.JSON(http.StatusOK, web.Result{Data: arts})
}

func (r *CachedArticleRepository) List(ctx context.Context, authorId int64,
    offset, limit int) ([]domain.Article, error) {
    // 步骤 1：只有偏移量是 0 且每页是 100 时才走缓存
    if offset == 0 && limit == 100 {
        arts, err := r.cache.GetFirstPage(ctx, authorId)
        if err == nil {
            return arts, nil
        }
        // 降级：缓存出错也查 DB
    }
    // 步骤 2：查 DB
    arts, err := r.dao.List(ctx, authorId, offset, limit)
    if err != nil {
        return nil, err
    }
    // 步骤 3：列表页只需要摘要，不缓存 Content
    res := slice.Map[entity.Article, domain.Article](arts, func(art entity.Article) domain.Article {
        return art.ToDomain()
    })
    // 步骤 4：只缓存第一页
    if offset == 0 && limit == 100 {
        _ = r.cache.SetFirstPage(ctx, authorId, res)
    }
    return res, nil
}

func (r *CachedArticleRepository) Save(ctx context.Context, art domain.Article) (int64, error) {
    // 步骤 1：写制作库
    id, err := r.authorDAO.Save(ctx, art)
    if err != nil {
        return 0, err
    }
    // 步骤 2：清除第一页缓存（因为列表内容变了）
    _ = r.cache.DelFirstPage(ctx, art.AuthorId)
    return id, nil
}

func (r *CachedArticleRepository) List(ctx context.Context, authorId int64,
    offset, limit int) ([]domain.Article, error) {
    // 步骤 1：查 DB
    arts, err := r.dao.List(ctx, authorId, offset, limit)
    if err != nil {
        return nil, err
    }
    // 步骤 2：业务预加载——把第一条数据放进缓存，过期时间很短
    // 让调用者决定是否异步，而不是偷偷异步
    if len(arts) > 0 {
        _ = r.cache.Set(ctx, arts[0])  // 短 TTL，如 1 分钟
    }
    return arts, nil
}

func (r *CachedArticleReaderRepository) Save(ctx context.Context, art domain.Article) error {
    // 步骤 1：写线上库
    err := r.dao.Upsert(ctx, art)
    if err != nil {
        return err
    }
    // 步骤 2：提前设置缓存（发布即预热）
    // 失败不用关心，可能是超时或偶发性能抖动
    _ = r.cache.Set(ctx, art)
    return nil
}

// repository/article_reader.go
type CachedArticleReaderRepository struct {
    dao     dao.ArticleReaderDAO
    cache   cache.ArticleCache
    userRepo repository.UserRepository  // 用于组装 Author
}

func (r *CachedArticleReaderRepository) Get(ctx context.Context, id int64) (domain.Article, error) {
    // 步骤 1：先查缓存
    art, err := r.cache.Get(ctx, id)
    if err == nil {
        // 缓存命中：组装作者信息（也走缓存）
        u, _ := r.userRepo.FindById(ctx, art.AuthorId)
        art.Author = domain.Author{Id: u.Id, Nickname: u.Nickname}
        return art, nil
    }
    // 步骤 2：查 DB
    art, err = r.dao.Get(ctx, id)
    if err != nil {
        return domain.Article{}, err
    }
    // 步骤 3：回写缓存 + 组装 Author
    _ = r.cache.Set(ctx, art)
    u, _ := r.userRepo.FindById(ctx, art.AuthorId)
    art.Author = domain.Author{Id: u.Id, Nickname: u.Nickname}
    return art, nil
}