会员管理代码

baqing-shop/src/main/java/com/ruoyi/web/modules/openstats/service/impl/MallStatsOpenServiceImpl.java

@@ -10,6 +10,7 @@ import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -42,6 +43,8 @@ public class MallStatsOpenServiceImpl implements IMallStatsOpenService
 {
     private static final ZoneId ZONE_SHANGHAI = ZoneId.of("Asia/Shanghai");
 
+    private final ConcurrentHashMap<Integer, Object> yearlyRefreshLocks = new ConcurrentHashMap<>();
+
     @Autowired
     private MallStatsOpenMapper statsMapper;
 
@@ -55,110 +58,161 @@ public class MallStatsOpenServiceImpl implements IMallStatsOpenService
     public CategorySalesVO getCategorySales(String statYear)
     {
         int year = resolveStatYear(statYear);
-        String cacheKey = StatsCacheKeys.categorySales(year);
-        CategorySalesVO cached = redisCache.getCacheObject(cacheKey);
-        if (cached != null)
-        {
-            return cached;
-        }
-        List<CategoryQtyRow> rows = safeList(statsMapper.selectCategoryQtyByFinishYear(year));
-        CategorySalesVO vo = buildCategorySales(year, rows);
-        redisCache.setCacheObject(cacheKey, vo, OpenStatsConstants.CACHE_TTL_YEARLY_HOUR, TimeUnit.HOURS);
-        return vo;
+        ensureYearlyStatsCached(year);
+        return redisCache.getCacheObject(StatsCacheKeys.categorySales(year));
     }
 
     @Override
     public HotCategoryRankVO getHotCategoryRank(String statYear)
     {
         int year = resolveStatYear(statYear);
-        String cacheKey = StatsCacheKeys.hotCategory(year);
-        HotCategoryRankVO cached = redisCache.getCacheObject(cacheKey);
-        if (cached != null)
-        {
-            return cached;
-        }
-        List<CategoryQtyRow> rows = safeList(statsMapper.selectCategoryQtyByFinishYear(year));
-        HotCategoryRankVO vo = buildHotCategoryRank(year, rows);
-        redisCache.setCacheObject(cacheKey, vo, OpenStatsConstants.CACHE_TTL_YEARLY_HOUR, TimeUnit.HOURS);
-        return vo;
+        ensureYearlyStatsCached(year);
+        return redisCache.getCacheObject(StatsCacheKeys.hotCategory(year));
     }
 
     @Override
     public OrderTrendVO getOrderTrend(String statYear)
     {
         int year = resolveStatYear(statYear);
-        String cacheKey = StatsCacheKeys.orderTrend(year);
-        OrderTrendVO cached = redisCache.getCacheObject(cacheKey);
-        if (cached != null)
-        {
-            return cached;
-        }
-        List<MonthCountRow> rows = safeList(statsMapper.selectOrderCountByYear(year));
-        OrderTrendVO vo = buildOrderTrend(year, rows);
-        redisCache.setCacheObject(cacheKey, vo, OpenStatsConstants.CACHE_TTL_YEARLY_HOUR, TimeUnit.HOURS);
-        return vo;
+        ensureYearlyStatsCached(year);
+        return redisCache.getCacheObject(StatsCacheKeys.orderTrend(year));
     }
 
     @Override
     public ShopEntryVO getShopEntry(String statYear)
     {
         int year = resolveStatYear(statYear);
-        String cacheKey = StatsCacheKeys.shopEntry(year);
-        ShopEntryVO cached = redisCache.getCacheObject(cacheKey);
-        if (cached != null)
-        {
-            return cached;
-        }
-        List<MonthCountRow> rows = safeList(statsMapper.selectShopCountByYear(year));
-        ShopEntryVO vo = buildShopEntry(year, rows);
-        redisCache.setCacheObject(cacheKey, vo, OpenStatsConstants.CACHE_TTL_YEARLY_HOUR, TimeUnit.HOURS);
-        return vo;
+        ensureYearlyStatsCached(year);
+        return redisCache.getCacheObject(StatsCacheKeys.shopEntry(year));
     }
 
     @Override
     public RegionRankVO getRegionRank(String statYear)
     {
         int year = resolveStatYear(statYear);
-        String cacheKey = StatsCacheKeys.regionRank(year);
-        RegionRankVO cached = redisCache.getCacheObject(cacheKey);
-        if (cached != null)
-        {
-            return cached;
-        }
-        List<RegionAmountRow> rows = safeList(statsMapper.selectRegionAmountByYear(year));
-        RegionRankVO vo = buildRegionRank(year, rows);
-        redisCache.setCacheObject(cacheKey, vo, OpenStatsConstants.CACHE_TTL_YEARLY_HOUR, TimeUnit.HOURS);
-        return vo;
+        ensureYearlyStatsCached(year);
+        return redisCache.getCacheObject(StatsCacheKeys.regionRank(year));
     }
 
     @Override
     public ReviewWordCloudVO getReviewWordCloud()
     {
-        String cacheKey = StatsCacheKeys.wordCloud();
-        ReviewWordCloudVO cached = redisCache.getCacheObject(cacheKey);
-        if (cached != null)
-        {
-            return cached;
-        }
-        List<String> contents = safeList(statsMapper.selectReviewContentsForWordCloud());
-        ReviewWordCloudVO vo = wordCloudSupport.buildTopWords(contents);
-        redisCache.setCacheObject(cacheKey, vo, OpenStatsConstants.CACHE_TTL_WORDCLOUD_HOUR, TimeUnit.HOURS);
-        return vo;
+        ensureWordCloudCached();
+        return redisCache.getCacheObject(StatsCacheKeys.wordCloud());
     }
 
     @Override
     public StatsOverviewVO getOverview(String statYear)
     {
+        int year = resolveStatYear(statYear);
+        ensureOverviewStatsCached(year);
         StatsOverviewVO overview = new StatsOverviewVO();
-        overview.setCategorySales(getCategorySales(statYear));
-        overview.setHotCategoryRank(getHotCategoryRank(statYear));
-        overview.setOrderTrend(getOrderTrend(statYear));
-        overview.setShopEntry(getShopEntry(statYear));
-        overview.setRegionRank(getRegionRank(statYear));
-        overview.setReviewWordCloud(getReviewWordCloud());
+        overview.setCategorySales(redisCache.getCacheObject(StatsCacheKeys.categorySales(year)));
+        overview.setHotCategoryRank(redisCache.getCacheObject(StatsCacheKeys.hotCategory(year)));
+        overview.setOrderTrend(redisCache.getCacheObject(StatsCacheKeys.orderTrend(year)));
+        overview.setShopEntry(redisCache.getCacheObject(StatsCacheKeys.shopEntry(year)));
+        overview.setRegionRank(redisCache.getCacheObject(StatsCacheKeys.regionRank(year)));
+        overview.setReviewWordCloud(redisCache.getCacheObject(StatsCacheKeys.wordCloud()));
         return overview;
     }
 
+    private void ensureOverviewStatsCached(int year)
+    {
+        if (isYearlyStatsCached(year) && isWordCloudCached())
+        {
+            return;
+        }
+        Object lock = yearlyRefreshLocks.computeIfAbsent(year, key -> new Object());
+        synchronized (lock)
+        {
+            if (!isYearlyStatsCached(year))
+            {
+                refreshYearlyStatsCache(year);
+            }
+            if (!isWordCloudCached())
+            {
+                refreshWordCloudCache();
+            }
+        }
+    }
+
+    private void ensureYearlyStatsCached(int year)
+    {
+        if (isYearlyStatsCached(year))
+        {
+            return;
+        }
+        Object lock = yearlyRefreshLocks.computeIfAbsent(year, key -> new Object());
+        synchronized (lock)
+        {
+            if (!isYearlyStatsCached(year))
+            {
+                refreshYearlyStatsCache(year);
+            }
+        }
+    }
+
+    private void ensureWordCloudCached()
+    {
+        if (isWordCloudCached())
+        {
+            return;
+        }
+        synchronized (MallStatsOpenServiceImpl.class)
+        {
+            if (!isWordCloudCached())
+            {
+                refreshWordCloudCache();
+            }
+        }
+    }
+
+    private boolean isYearlyStatsCached(int year)
+    {
+        for (String cacheKey : StatsCacheKeys.yearlyStatKeys(year))
+        {
+            if (redisCache.getCacheObject(cacheKey) == null)
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean isWordCloudCached()
+    {
+        return redisCache.getCacheObject(StatsCacheKeys.wordCloud()) != null;
+    }
+
+    private void refreshYearlyStatsCache(int year)
+    {
+        List<CategoryQtyRow> categoryRows = safeList(statsMapper.selectCategoryQtyByFinishYear(year));
+        CategorySalesVO categorySales = buildCategorySales(year, categoryRows);
+        HotCategoryRankVO hotCategory = buildHotCategoryRank(year, new ArrayList<>(categoryRows));
+        OrderTrendVO orderTrend = buildOrderTrend(year, safeList(statsMapper.selectOrderCountByYear(year)));
+        ShopEntryVO shopEntry = buildShopEntry(year, safeList(statsMapper.selectShopCountByYear(year)));
+        RegionRankVO regionRank = buildRegionRank(year, safeList(statsMapper.selectRegionAmountByYear(year)));
+
+        cacheYearlyStat(StatsCacheKeys.categorySales(year), categorySales);
+        cacheYearlyStat(StatsCacheKeys.hotCategory(year), hotCategory);
+        cacheYearlyStat(StatsCacheKeys.orderTrend(year), orderTrend);
+        cacheYearlyStat(StatsCacheKeys.shopEntry(year), shopEntry);
+        cacheYearlyStat(StatsCacheKeys.regionRank(year), regionRank);
+    }
+
+    private void refreshWordCloudCache()
+    {
+        List<String> contents = safeList(statsMapper.selectReviewContentsForWordCloud());
+        ReviewWordCloudVO vo = wordCloudSupport.buildTopWords(contents);
+        redisCache.setCacheObject(StatsCacheKeys.wordCloud(), vo,
+                OpenStatsConstants.CACHE_TTL_WORDCLOUD_HOUR, TimeUnit.HOURS);
+    }
+
+    private void cacheYearlyStat(String cacheKey, Object value)
+    {
+        redisCache.setCacheObject(cacheKey, value, OpenStatsConstants.CACHE_TTL_YEARLY_HOUR, TimeUnit.HOURS);
+    }
+
     private CategorySalesVO buildCategorySales(int statYear, List<CategoryQtyRow> rows)
     {
         CategorySalesVO vo = new CategorySalesVO();

baqing-shop/src/main/java/com/ruoyi/web/modules/openstats/support/StatsCacheKeys.java

@@ -40,4 +40,15 @@ public final class StatsCacheKeys
     {
         return PREFIX + "wordcloud";
     }
+
+    public static String[] yearlyStatKeys(int statYear)
+    {
+        return new String[] {
+            categorySales(statYear),
+            hotCategory(statYear),
+            orderTrend(statYear),
+            shopEntry(statYear),
+            regionRank(statYear)
+        };
+    }
 }

baqing-shop/src/test/java/com/ruoyi/web/modules/openstats/service/MallStatsOpenServiceImplTest.java

@@ -8,12 +8,15 @@ import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 import java.math.BigDecimal;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.concurrent.TimeUnit;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -21,6 +24,9 @@ import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+import org.mockito.stubbing.Answer;
 import com.ruoyi.common.core.redis.RedisCache;
 import com.ruoyi.web.modules.openstats.constant.OpenStatsConstants;
 import com.ruoyi.web.modules.openstats.dto.CategoryQtyRow;
@@ -40,6 +46,7 @@ import com.ruoyi.web.modules.openstats.vo.StatsOverviewVO;
 import com.ruoyi.web.modules.openstats.vo.WordCloudItemVO;
 
 @ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
 class MallStatsOpenServiceImplTest
 {
     private static final int STAT_YEAR = 2026;
@@ -56,10 +63,20 @@ class MallStatsOpenServiceImplTest
     @InjectMocks
     private MallStatsOpenServiceImpl service;
 
+    private final Map<String, Object> cacheStore = new HashMap<>();
+
     @BeforeEach
-    void stubCacheMiss()
+    void setUpCache()
     {
-        when(redisCache.getCacheObject(anyString())).thenReturn(null);
+        cacheStore.clear();
+        when(redisCache.getCacheObject(anyString())).thenAnswer(
+                invocation -> cacheStore.get(invocation.getArgument(0)));
+        Answer<Object> saveCache = invocation -> {
+            cacheStore.put(invocation.getArgument(0), invocation.getArgument(1));
+            return null;
+        };
+        doAnswer(saveCache).when(redisCache).setCacheObject(anyString(), any(), anyInt(), any(TimeUnit.class));
+        stubYearlyMapperDefaults();
     }
 
     @Test
@@ -77,8 +94,8 @@ class MallStatsOpenServiceImplTest
         assertEquals(3, vo.getItems().size());
         double ratioSum = vo.getItems().stream().mapToDouble(i -> i.getRatio()).sum();
         assertEquals(100.0, ratioSum, 0.05);
-        verify(redisCache).setCacheObject(eq(StatsCacheKeys.categorySales(STAT_YEAR)), eq(vo),
-                eq(OpenStatsConstants.CACHE_TTL_YEARLY_HOUR), eq(TimeUnit.HOURS));
+        assertNotNull(cacheStore.get(StatsCacheKeys.orderTrend(STAT_YEAR)));
+        assertNotNull(cacheStore.get(StatsCacheKeys.hotCategory(STAT_YEAR)));
     }
 
     @Test
@@ -99,6 +116,22 @@ class MallStatsOpenServiceImplTest
         assertEquals(1, vo.getItems().get(0).getRank());
         assertEquals("A", vo.getItems().get(0).getCategoryName());
         assertTrue(vo.getItems().stream().noneMatch(i -> "F".equals(i.getCategoryName())));
+        assertNotNull(cacheStore.get(StatsCacheKeys.categorySales(STAT_YEAR)));
+    }
+
+    @Test
+    void yearlyStatsCache_refreshesAllMetricsTogether()
+    {
+        service.getOrderTrend("2026");
+
+        for (String cacheKey : StatsCacheKeys.yearlyStatKeys(STAT_YEAR))
+        {
+            assertNotNull(cacheStore.get(cacheKey), cacheKey);
+        }
+        verify(statsMapper, times(1)).selectCategoryQtyByFinishYear(STAT_YEAR);
+        verify(statsMapper, times(1)).selectOrderCountByYear(STAT_YEAR);
+        verify(statsMapper, times(1)).selectShopCountByYear(STAT_YEAR);
+        verify(statsMapper, times(1)).selectRegionAmountByYear(STAT_YEAR);
     }
 
     @Test
@@ -150,7 +183,6 @@ class MallStatsOpenServiceImplTest
         item.setWord("质量好");
         item.setCount(10L);
         cached.getItems().add(item);
-        when(redisCache.getCacheObject(StatsCacheKeys.wordCloud())).thenReturn(null, cached);
         when(statsMapper.selectReviewContentsForWordCloud()).thenReturn(Collections.singletonList("质量很好"));
         when(wordCloudSupport.buildTopWords(any())).thenReturn(cached);
 
@@ -165,11 +197,6 @@ class MallStatsOpenServiceImplTest
     @Test
     void overview_containsAllSections()
     {
-        when(statsMapper.selectCategoryQtyByFinishYear(anyInt())).thenReturn(Collections.emptyList());
-        when(statsMapper.selectOrderCountByYear(anyInt())).thenReturn(Collections.emptyList());
-        when(statsMapper.selectShopCountByYear(anyInt())).thenReturn(Collections.emptyList());
-        when(statsMapper.selectRegionAmountByYear(anyInt())).thenReturn(Collections.emptyList());
-        when(statsMapper.selectReviewContentsForWordCloud()).thenReturn(Collections.emptyList());
         when(wordCloudSupport.buildTopWords(any())).thenReturn(new ReviewWordCloudVO());
 
         StatsOverviewVO overview = service.getOverview("2026");
@@ -181,6 +208,20 @@ class MallStatsOpenServiceImplTest
         assertNotNull(overview.getRegionRank());
         assertNotNull(overview.getReviewWordCloud());
         verify(statsMapper, atLeastOnce()).selectCategoryQtyByFinishYear(STAT_YEAR);
+        verify(statsMapper, times(1)).selectReviewContentsForWordCloud();
+        for (String cacheKey : StatsCacheKeys.yearlyStatKeys(STAT_YEAR))
+        {
+            assertNotNull(cacheStore.get(cacheKey));
+        }
+        assertNotNull(cacheStore.get(StatsCacheKeys.wordCloud()));
+    }
+
+    private void stubYearlyMapperDefaults()
+    {
+        when(statsMapper.selectCategoryQtyByFinishYear(anyInt())).thenReturn(Collections.emptyList());
+        when(statsMapper.selectOrderCountByYear(anyInt())).thenReturn(Collections.emptyList());
+        when(statsMapper.selectShopCountByYear(anyInt())).thenReturn(Collections.emptyList());
+        when(statsMapper.selectRegionAmountByYear(anyInt())).thenReturn(Collections.emptyList());
     }
 
     private CategoryQtyRow row(Long id, String name, Long qty)

doc/平台后台/外部接口/商城数据统计技术方案.md

@@ -356,8 +356,10 @@ Header: X-Open-Token: {token}
 | 规则 |
 |------|
 | **Cache-Aside**：先读 Redis，miss 再查 DB 并写入 |
+| **年度指标捆绑刷新**：同一 `statYear` 下 **5 项年度指标**（品类销售、热销、订单趋势、入驻、区域）**任一缓存 miss 或不全** 时，**一次性重建并写入全部 5 个 key**，避免各接口数据时间点不一致 |
+| **`overview`**：在年度捆绑就绪且词云缓存存在时组装；**任一缺失** 时 **同步刷新年度捆绑 + 词云** 后再返回 |
 | 订单 **确认收货/自动确认** 后 **不主动删缓存**；靠 TTL **准实时**（对齐功能需求） |
-| **`overview`** 内部并行调 6 段逻辑，**共用** 各 key |
+| **`overview` / 单接口** 均 **复用** 上述子 key，不再单独刷新部分指标 |
 
 ### 5.3 性能约束
 
@@ -420,7 +422,8 @@ Header: X-Open-Token: {token}
 | 版本 | 说明 |
 |------|------|
 | **v1.0** | 首版：RuoYi3.9.2 + MySQL5.7；复用业务表聚合；六项 Open API + overview；Redis 缓存 |
+| **v1.3** | 年度 5 项指标 **捆绑刷新**；`overview` miss 时 **同步更新** 年度指标 + 词云，避免部分缓存过期 |
 | **v1.2** | §5.1/§5.2 改为 **统计年**（`YEAR(finish_time)`）；接口参数统一 `statYear`；缓存 key/TTL 对齐年度指标 |
 | **v1.1** | Token 改为 **AES-128-CBC 加密 UUID** 校验；**移除** `biz_open_api_token` 库表方案 |
 
-*文档版本：v1.2 · 关联《商城数据统计功能需求.md》v1.0.4 · 统计索引：`sql/biz_order.sql` → `idx_stats_finish`*
+*文档版本：v1.3 · 关联《商城数据统计功能需求.md》v1.0.4 · 统计索引：`sql/biz_order.sql` → `idx_stats_finish`*