异步保存内容分数

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/mapper/longArticle/RankContentScoreMapper.java

@@ -0,0 +1,24 @@
+package com.tzld.longarticle.recommend.server.mapper.longArticle;
+
+import com.tzld.longarticle.recommend.server.model.entity.longArticle.RankContentScore;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+
+/**
+ * 排序内容分数记录表Mapper
+ */
+public interface RankContentScoreMapper {
+
+    /**
+     * 批量插入排序内容分数
+     */
+    void batchInsert(@Param("list") List<RankContentScore> list);
+
+    /**
+     * 根据planId和ghId删除历史记录
+     */
+    void deleteByPlanIdAndGhId(@Param("planId") String planId, @Param("ghId") String ghId);
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/model/entity/longArticle/RankContentScore.java

@@ -0,0 +1,66 @@
+package com.tzld.longarticle.recommend.server.model.entity.longArticle;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.*;
+
+/**
+ * 排序内容分数记录表
+ * 存储rankStrategy计算后的content分数
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+@Table(name = "rank_content_score")
+public class RankContentScore {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "plan_id")
+    private String planId;
+
+    @Column(name = "gh_id")
+    private String ghId;
+
+    @Column(name = "account_name")
+    private String accountName;
+
+    @Column(name = "content_id")
+    private String contentId;
+
+    @Column(name = "crawler_channel_content_id")
+    private String crawlerChannelContentId;
+
+    @Column(name = "source_type")
+    private Integer sourceType;
+
+    @Column(name = "source_id")
+    private String sourceId;
+
+    @Column(name = "title")
+    private String title;
+
+    @Column(name = "content_pool_type")
+    private String contentPoolType;
+
+    @Column(name = "strategy")
+    private String strategy;
+
+    @Column(name = "score")
+    private Double score;
+
+    @Column(name = "score_map")
+    private String scoreMap;
+
+    @Column(name = "category")
+    private String category;
+
+    @Column(name = "create_timestamp")
+    private Long createTimestamp;
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/longArticle/RankContentScoreRepository.java

@@ -0,0 +1,45 @@
+package com.tzld.longarticle.recommend.server.repository.longArticle;
+
+import com.tzld.longarticle.recommend.server.model.entity.longArticle.RankContentScore;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * 排序内容分数记录表Repository
+ */
+@Repository
+public interface RankContentScoreRepository extends JpaRepository<RankContentScore, Long> {
+
+    /**
+     * 根据planId和ghId删除历史记录
+     */
+    @Modifying
+    @Query("DELETE FROM RankContentScore r WHERE r.planId = :planId AND r.ghId = :ghId")
+    void deleteByPlanIdAndGhId(@Param("planId") String planId, @Param("ghId") String ghId);
+
+    /**
+     * 根据planId查询记录
+     */
+    List<RankContentScore> findByPlanId(String planId);
+
+    /**
+     * 根据ghId查询记录
+     */
+    List<RankContentScore> findByGhId(String ghId);
+
+    /**
+     * 根据planId和ghId查询记录
+     */
+    List<RankContentScore> findByPlanIdAndGhId(String planId, String ghId);
+
+    /**
+     * 根据strategy查询记录
+     */
+    List<RankContentScore> findByStrategy(String strategy);
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/RankContentScoreService.java

@@ -0,0 +1,162 @@
+package com.tzld.longarticle.recommend.server.service.recommend;
+
+import com.alibaba.fastjson.JSONObject;
+import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import com.tzld.longarticle.recommend.server.common.CommonThreadPoolExecutor;
+import com.tzld.longarticle.recommend.server.common.enums.recommend.ContentPoolEnum;
+import com.tzld.longarticle.recommend.server.mapper.longArticle.RankContentScoreMapper;
+import com.tzld.longarticle.recommend.server.model.dto.Content;
+import com.tzld.longarticle.recommend.server.model.entity.longArticle.RankContentScore;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.MapUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 排序内容分数记录服务
+ * 异步保存rankStrategy计算后的content分数
+ */
+@Service
+@Slf4j
+public class RankContentScoreService {
+
+    @Autowired
+    private RankContentScoreMapper rankContentScoreMapper;
+
+    /**
+     * 批量插入批次大小
+     */
+    private static final int BATCH_SIZE = 500;
+
+    /**
+     * 异步执行线程池
+     */
+    private final ExecutorService pool = new CommonThreadPoolExecutor(
+            4,
+            8,
+            0L, TimeUnit.SECONDS,
+            new LinkedBlockingQueue<>(1000),
+            new ThreadFactoryBuilder().setNameFormat("RankContentScore-%d").build(),
+            new ThreadPoolExecutor.AbortPolicy());
+
+    /**
+     * 异步保存排序内容分数
+     * 每个计划账号只存在一批次，先删除历史再插入新的
+     * 只保留头次内容，冷启池内容不需要保存
+     *
+     * @param planId      计划ID
+     * @param ghId        公众号ID
+     * @param accountName 账号名称
+     * @param strategy    排序策略
+     * @param contents    内容列表
+     */
+    public void asyncSaveRankContentScore(String planId, String ghId, String accountName, String strategy, List<Content> contents) {
+        if (CollectionUtils.isEmpty(contents)) {
+            return;
+        }
+        pool.submit(() -> {
+            try {
+                saveRankContentScore(planId, ghId, accountName, strategy, contents);
+            } catch (Exception e) {
+                log.error("asyncSaveRankContentScore error, planId:{}, ghId:{}, strategy:{}", planId, ghId, strategy, e);
+            }
+        });
+    }
+
+    /**
+     * 保存排序内容分数
+     * 先删除历史记录，再插入新记录
+     * 只保留头次内容（autoArticlePoolLevel1和autoArticlePoolLevel2），冷启池内容不保存
+     *
+     * @param planId      计划ID
+     * @param ghId        公众号ID
+     * @param accountName 账号名称
+     * @param strategy    排序策略
+     * @param contents    内容列表
+     */
+    public void saveRankContentScore(String planId, String ghId, String accountName, String strategy, List<Content> contents) {
+        if (CollectionUtils.isEmpty(contents)) {
+            return;
+        }
+
+        // 过滤出头次内容（非冷启池内容）
+        List<Content> filteredContents = filterHeadContents(contents);
+        if (CollectionUtils.isEmpty(filteredContents)) {
+            log.info("saveRankContentScore no head contents to save, planId:{}, ghId:{}, strategy:{}", planId, ghId, strategy);
+            return;
+        }
+
+        long start = System.currentTimeMillis();
+
+        // 先删除该planId和ghId的历史记录
+        rankContentScoreMapper.deleteByPlanIdAndGhId(planId, ghId);
+
+        // 构建保存列表
+        List<RankContentScore> saveList = new ArrayList<>();
+        long createTimestamp = System.currentTimeMillis();
+
+        for (Content content : filteredContents) {
+            RankContentScore score = new RankContentScore();
+            score.setPlanId(planId);
+            score.setGhId(ghId);
+            score.setAccountName(accountName);
+            score.setContentId(content.getId());
+            score.setCrawlerChannelContentId(content.getCrawlerChannelContentId());
+            score.setSourceType(content.getSourceType());
+            score.setSourceId(content.getSourceId());
+            score.setTitle(content.getTitle());
+            score.setContentPoolType(content.getContentPoolType());
+            score.setStrategy(strategy);
+            score.setScore(content.getScore());
+            if (MapUtils.isNotEmpty(content.getScoreMap())) {
+                score.setScoreMap(JSONObject.toJSONString(content.getScoreMap()));
+            }
+            if (CollectionUtils.isNotEmpty(content.getCategory())) {
+                score.setCategory(JSONObject.toJSONString(content.getCategory()));
+            }
+            score.setCreateTimestamp(createTimestamp);
+            saveList.add(score);
+        }
+
+        // 分批批量保存
+        List<List<RankContentScore>> partitions = Lists.partition(saveList, BATCH_SIZE);
+        for (List<RankContentScore> partition : partitions) {
+            rankContentScoreMapper.batchInsert(partition);
+        }
+
+        log.info("saveRankContentScore success, planId:{}, ghId:{}, strategy:{}, count:{}, batchCount:{}, cost:{}ms",
+                planId, ghId, strategy, saveList.size(), partitions.size(), System.currentTimeMillis() - start);
+    }
+
+    /**
+     * 过滤出头次内容（非冷启池内容）
+     * 冷启池：autoArticlePoolLevel4
+     *
+     * @param contents 内容列表
+     * @return 过滤后的头次内容列表
+     */
+    private List<Content> filterHeadContents(List<Content> contents) {
+        List<Content> result = new ArrayList<>();
+        String coldStartPool = ContentPoolEnum.autoArticlePoolLevel4.getContentPool();
+
+        for (Content content : contents) {
+            // 跳过冷启池内容
+            if (coldStartPool.equals(content.getContentPoolType())) {
+                continue;
+            }
+            result.add(content);
+        }
+
+        return result;
+    }
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/RankStrategy.java

@@ -6,10 +6,13 @@ import com.tzld.longarticle.recommend.server.common.enums.recommend.FeishuRobotI
 import com.tzld.longarticle.recommend.server.common.enums.recommend.ScoreStrategyEnum;
 import com.tzld.longarticle.recommend.server.model.dto.Content;
 import com.tzld.longarticle.recommend.server.model.entity.crawler.Article;
+import com.tzld.longarticle.recommend.server.service.ServiceBeanFactory;
+import com.tzld.longarticle.recommend.server.service.recommend.RankContentScoreService;
 import com.tzld.longarticle.recommend.server.service.recommend.score.ScoreParam;
 import com.tzld.longarticle.recommend.server.util.TitleSimilarCheckUtil;
 import com.tzld.longarticle.recommend.server.util.feishu.FeishuMessageSender;
 import org.apache.commons.collections4.CollectionUtils;
+import org.springframework.util.StringUtils;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -112,4 +115,33 @@ public interface RankStrategy {
                         + "策略: " + param.getStrategy());
     }
 
+    /**
+     * 异步保存排序内容分数
+     * 在排序后、选择前调用，保存所有内容的分数
+     *
+     * @param param 排序参数
+     * @param items 排序后的所有内容项
+     */
+    static void asyncSaveRankContentScore(RankParam param, List<RankItem> items) {
+        if (CollectionUtils.isEmpty(items) || !StringUtils.hasText(param.getPlanId())) {
+            return;
+        }
+        // 获取所有Content
+        List<Content> contents = new ArrayList<>();
+        for (RankItem item : items) {
+            contents.add(item.getContent());
+        }
+        // 异步保存
+        RankContentScoreService service = ServiceBeanFactory.getBean(RankContentScoreService.class);
+        if (service != null) {
+            service.asyncSaveRankContentScore(
+                    param.getPlanId(),
+                    param.getGhId(),
+                    param.getAccountName(),
+                    param.getStrategy(),
+                    contents
+            );
+        }
+    }
+
 }

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/DefaultRankStrategy.java

@@ -86,6 +86,9 @@ public class DefaultRankStrategy implements RankStrategy {
         log.info("Sort result {}", JSONUtils.toJson(sortedItems));
         List<Content> contents = CommonCollectionUtils.toList(sortedItems, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, sortedItems);
+
         // 3 相似去重
         log.info("Deduplication {}", JSONUtils.toJson(contents));
         String[] publishPool = Arrays.copyOf(contentPools, contentPools.length);

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/FwhColdStartRankStrategy.java

@@ -63,6 +63,9 @@ public class FwhColdStartRankStrategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 选文章
         List<Content> result = new ArrayList<>();
         int size = param.getSize();

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/HisJumpRankStrategy.java

@@ -79,6 +79,9 @@ public class HisJumpRankStrategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/InfiniteRankStrategy.java

@@ -66,6 +66,9 @@ public class InfiniteRankStrategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/LateRankStrategy.java

@@ -66,6 +66,9 @@ public class LateRankStrategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RandomRankStrategy.java

@@ -32,6 +32,10 @@ public class RandomRankStrategy implements RankStrategy {
         });
 
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
+
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV10Strategy.java

@@ -91,6 +91,9 @@ public class RankV10Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV11Strategy.java

@@ -110,6 +110,9 @@ public class RankV11Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV12Strategy.java

@@ -110,6 +110,9 @@ public class RankV12Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV13Strategy.java

@@ -111,6 +111,9 @@ public class RankV13Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV14Strategy.java

@@ -111,6 +111,9 @@ public class RankV14Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV15Strategy.java

@@ -120,6 +120,9 @@ public class RankV15Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV16Strategy.java

@@ -105,6 +105,9 @@ public class RankV16Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV17Strategy.java

@@ -105,6 +105,9 @@ public class RankV17Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV18Strategy.java

@@ -110,6 +110,9 @@ public class RankV18Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV19Strategy.java

@@ -116,6 +116,9 @@ public class RankV19Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV20Strategy.java

@@ -145,6 +145,9 @@ public class RankV20Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV21Strategy.java

@@ -138,6 +138,9 @@ public class RankV21Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV2Strategy.java

@@ -54,6 +54,9 @@ public class RankV2Strategy implements RankStrategy {
                     o1.getScore(ScoreStrategyEnum.VIEW_COUNT.value()),
                     o2.getScore(ScoreStrategyEnum.VIEW_COUNT.value()));
         });
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 2 选文章
         List<Content> result = new ArrayList<>();
         if (CollectionUtils.isNotEmpty(items)) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV3Strategy.java

@@ -82,6 +82,9 @@ public class RankV3Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV4Strategy.java

@@ -81,6 +81,9 @@ public class RankV4Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV5Strategy.java

@@ -99,6 +99,9 @@ public class RankV5Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV7Strategy.java

@@ -83,6 +83,9 @@ public class RankV7Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV8Strategy.java

@@ -94,6 +94,9 @@ public class RankV8Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/RankV9Strategy.java

@@ -83,6 +83,9 @@ public class RankV9Strategy implements RankStrategy {
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 
+        // 异步保存排序内容分数（保存所有排序后的内容）
+        RankStrategy.asyncSaveRankContentScore(param, items);
+
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
         for (Content c : contents) {

long-article-recommend-service/src/main/resources/mapper/longArticle/RankContentScoreMapper.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.tzld.longarticle.recommend.server.mapper.longArticle.RankContentScoreMapper">
+
+    <!-- 批量插入排序内容分数 -->
+    <insert id="batchInsert">
+        INSERT INTO rank_content_score
+        (plan_id, gh_id, account_name, content_id, crawler_channel_content_id, source_type, source_id,
+         title, content_pool_type, strategy, score, score_map, category, create_timestamp)
+        VALUES
+        <foreach collection="list" item="item" separator=",">
+            (#{item.planId}, #{item.ghId}, #{item.accountName}, #{item.contentId}, #{item.crawlerChannelContentId},
+             #{item.sourceType}, #{item.sourceId}, #{item.title}, #{item.contentPoolType}, #{item.strategy},
+             #{item.score}, #{item.scoreMap}, #{item.category}, #{item.createTimestamp})
+        </foreach>
+    </insert>
+
+    <!-- 根据planId和ghId删除历史记录 -->
+    <delete id="deleteByPlanIdAndGhId">
+        DELETE FROM rank_content_score WHERE plan_id = #{planId} AND gh_id = #{ghId}
+    </delete>
+
+</mapper>