商品中心—7.自研缓存框架的技术文档

大纲
1.商品C端系统监听商品变更及刷新缓存
2.自研缓存框架的数据表缓存组件
3.自研缓存框架的通用缓存读写组件与DB操作组件
 
1.商品C端系统监听商品变更及刷新缓存
FlushRedisCache的flushRedisStringData()方法刷新缓存的逻辑是：首先从DB查询最新的数据 -> 然后删除旧缓存 -> 最后更新缓存。

1. @Configuration
2. public class ConsumerBeanConfig {
3.     //配置内容对象
4.     @Autowired
5.     private RocketMQProperties rocketMQProperties;
6.    
7.     //监听商品修改的MQ消息
8.     @Bean("productUpdateTopic")
9.     public DefaultMQPushConsumer productUpdateTopic(ProductUpdateListener productUpdateListener) throws MQClientException {
10.         DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(RocketMqConstant.PRODUCT_UPDATE_CONSUMER_GROUP);
11.         consumer.setNamesrvAddr(rocketMQProperties.getNameServer());
12.         consumer.subscribe(RocketMqConstant.PRODUCT_UPDATE_TOPIC, "*");
13.         consumer.registerMessageListener(productUpdateListener);
14.         consumer.start();
15.         return consumer;
16.     }
17. }
19. //商品变更时的缓存处理
20. @Component
21. public class ProductUpdateListener implements MessageListenerConcurrently {
22.     @DubboReference(version = "1.0.0")
23.     private TableDataUpdateApi tableDataUpdateApi;
24.    
25.     @Override
26.     public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
27.         try {
28.             for (MessageExt messageExt : list) {
29.                 //消息处理这里，涉及到sku的缓存更新以及对应的整个商品明细的缓存更新
30.                 String msg = new String(messageExt.getBody());
31.                 log.info("执行商品缓存数据更新逻辑，消息内容：{}", msg);
32.   
33.                 TableDataChangeDTO tableDataChangeMessage = JsonUtil.json2Object(msg, TableDataChangeDTO.class);
34.                 //更新sku对应的商品缓存信息
35.                 tableDataUpdateApi.tableDataChange(tableDataChangeMessage);
36.                 //发送回调消息通知
37.                 tableDataUpdateApi.sendCallbackMessage(tableDataChangeMessage);
38.             }
39.         } catch (Exception e) {
40.             log.error("consume error, 商品缓存更新失败", e);
41.             //本次消费失败，下次重新消费
42.             return ConsumeConcurrentlyStatus.RECONSUME_LATER;
43.         }
44.         return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
45.     }
46. }
48. //商品信息变更服务
49. @DubboService(version = "1.0.0", interfaceClass = TableDataUpdateApi.class, retries = 0)
50. public class TableDataUpdateApiImpl implements TableDataUpdateApi {
51.     @Resource
52.     private FlushRedisCache flushRedisCache;
53.    
54.     private ExecutorService executorService = Executors.newFixedThreadPool(10);
55.    
56.     //商品表数据变更逆向更新缓存
57.     @Override
58.     public JsonResult tableDataChange(TableDataChangeDTO tableDataChangeDTO) {
59.         executorService.execute(() -> {
60.             try {
61.                 //刷新缓存数据
62.                 flushRedisCache.flushRedisStringData(false, tableDataChangeDTO.getTableName(), Sets.newHashSet(tableDataChangeDTO.getKeyId()));
63.             } catch (Exception e) {
64.                 log.error("刷新string类型缓存异常，入参为tableDataChangeDTO={}", tableDataChangeDTO, e);
65.             }
66.             try {
67.                 flushRedisCache.flushRedisSetData(false, tableDataChangeDTO.getTableName(), Sets.newHashSet(tableDataChangeDTO.getKeyId()));
68.             } catch (Exception e) {
69.                 log.error("刷新set类型缓存异常，入参为tableDataChangeDTO={}", tableDataChangeDTO, e);
70.             }
71.             try {
72.                 flushRedisCache.flushRedisSortedSetData(false, tableDataChangeDTO.getTableName(), Sets.newHashSet(tableDataChangeDTO.getKeyId()));
73.             } catch (Exception e) {
74.                 log.error("刷新sortedset类型缓存异常，入参为tableDataChangeDTO={}", tableDataChangeDTO, e);
75.             }
76.         });
77.         return JsonResult.buildSuccess();
78.     }
79.     ...
80. }
82. //数据变更—刷新缓存
83. @Component
84. public class FlushRedisCache {
85.     //继承了AbstractRedisStringCache的缓存实例会被注入到abstractRedisStringCacheMap这个map中
86.     //例如CategoryBaseCache、FrontCategoryCache、ItemCollectCache、ProductDetailCache、SkuCollectCache等
87.     @Autowired
88.     private Map<String, AbstractRedisStringCache> abstractRedisStringCacheMap;
89.    
90.     //更新string类型缓存
91.     //@param flushAll  是否全量刷新
92.     //@param tableName 表名
93.     //@param idSet     主键ID集合
94.     public void flushRedisStringData(boolean flushAll, String tableName, Set<Long> idSet) {
95.         for (Map.Entry<String, AbstractRedisStringCache> entry : abstractRedisStringCacheMap.entrySet()) {
96.             AbstractRedisStringCache stringCache = entry.getValue();
97.             if (flushAll) {
98.                 stringCache.flushRedisStringDataByTableUpdateData();
99.                 continue;
100.             }
101.             //继承AbstractRedisStringCache的每个缓存实例都指定来表名，如下用于匹配出对应的缓存实例
102.             if (stringCache.getTableName().contains(tableName)) {
103.                 stringCache.flushRedisStringDataByTableAndIdSet(tableName, idSet);
104.             }
105.         }
106.     }
107.     ...
108. }
110. //Redis(string)缓存抽象类
111. public abstract class AbstractRedisStringCache<DO, BO> {
112.     @Resource
113.     private RedisReadWriteManager redisReadWriteManager;
114.     ...
115.    
116.     //刷新缓存—根据主表ID集合（关联表变更需要查询主表）
117.     public void flushRedisStringDataByTableAndIdSet(String tableName, Set<Long> idSet) {
118.         Optional<Set<Long>> idSetOpt = getStringDatabase().getTableIdSetByRelationTableIdSet(tableName, idSet);
119.         if (!idSetOpt.isPresent()) {
120.             return;
121.         }
122.         flushRedisStringDataByIdSet(idSetOpt.get());
123.     }
124.    
125.     //刷新缓存—根据主键ID集合
126.     //@param idSet 数据表主键ID
127.     private void flushRedisStringDataByIdSet(Set<Long> idSet) {
128.         //根据id集合从数据库中查询出数据
129.         Optional<RedisStringCache<DO>> stringSourceOpt = getStringDatabase().listTableDataByIdSet(idSet, queryType());
130.         if (!stringSourceOpt.isPresent()) {
131.             return;
132.         }
133.         RedisStringCache<DO> redisStringCache = stringSourceOpt.get();
134.         if (!CollectionUtils.isEmpty(redisStringCache.getDeleteSet())) {
135.             //通过缓存读写组件删除缓存
136.             redisReadWriteManager.delete(redisStringCache.getDeleteSet().stream().map(this::getRedisKey).collect(toSet()).toArray(new String[]{}));
137.         }
138.         if (CollectionUtils.isEmpty(redisStringCache.getAddList())) {
139.             return;
140.         }
141.         List<BO> boList = convertDO2BO(redisStringCache.getAddList());
142.         Map<String, BO> redisMap = convertBO2Map(boList);
143.         //通过缓存读写组件写入缓存
144.         redisReadWriteManager.batchWriteRedisString(redisMap);
145.     }
146.     ...
147. }
149. //缓存读写管理
150. @Service
151. public class RedisReadWriteManager {
152.     @Resource
153.     private RedisCache redisCache;
154.     ...
155.    
156.     //删除指定的key
157.     public void delete(String... keys) {
158.         Arrays.asList(keys).stream().forEach(key -> redisCache.delete(key));
159.     }
160.    
161.     //批量添加string缓存
162.     public <T> void batchWriteRedisString(Map<String, T> redisMap) {
163.         List<Map.Entry<String, T>> list = Lists.newArrayList(redisMap.entrySet());
164.         try {
165.             for (List<Map.Entry<String, T>> entries : Lists.partition(list, PAGE_SIZE_100)) {
166.                 for (Map.Entry<String, T> entry : entries) {
167.                     redisCache.setex(true, entry.getKey(), JSON.toJSONString(entry.getValue()), RedisKeyUtils.redisKeyRandomTime(INT_EXPIRED_SEVEN_DAYS));
168.                 }
169.                 try {
170.                     Thread.sleep(SLEEP_100);
171.                 } catch (InterruptedException e) {
172.                     e.printStackTrace();
173.                 }
174.             }
175.         } catch (Exception e) {
176.             log.error("批量添加string缓存异常 redisMap={}", redisMap, e);
177.         }
178.     }
179.     ...
180. }

复制代码

 
2.自研缓存框架的数据表缓存组件
(1)自研缓存框架的目录结构
(2)通过注解实现继承同一个抽象类的数据表缓存组件实例自动注入Map
 
(1)自研缓存框架的目录结构

(2)通过注解实现继承同一个抽象类的数据表缓存组件实例自动注入Map
继承AbstractRedisStringCache的数据表缓存组件实例会被注入到Map中，之后通过Map便可以根据表名来获取对应的数据表缓存组件实例了。数据表缓存组件实例中会封装一些获取DB数据表数据、获取缓存key等方法，而其继承的抽象类会提供一些根据DB获取缓存、刷新缓存等模版方法。

1. @Component
2. public class FlushRedisCache {
3.     //继承了AbstractRedisStringCache的缓存实例会被注入到abstractRedisStringCacheMap这个map中
4.     //例如CategoryBaseCache、FrontCategoryCache、ItemCollectCache、ProductDetailCache、SkuCollectCache等
5.     @Autowired
6.     private Map<String, AbstractRedisStringCache> abstractRedisStringCacheMap;
8.     //继承了AbstractRedisSortedSetCache的缓存实例会被注入到abstractRedisSortedSetCacheMap这个map中
9.     //例如SkuSellerCache
10.     @Autowired
11.     private Map<String, AbstractRedisSortedSetCache> abstractRedisSortedSetCacheMap;
12.     ...
13. }
15. @Service("productDetailCache")
16. public class ProductDetailCache extends AbstractRedisStringCache<ProductDetailDO, ProductDetailBO> {
17.     //DB操作组件
18.     @Resource
19.     private ProductDetailStringDatabase productDetailStringDatabase;
20.    
21.     @Resource
22.     private ProductDetailConverter productDetailConverter;
23.    
24.     @Override
25.     protected RedisStringDatabase<ProductDetailDO> getStringDatabase() {
26.         return productDetailStringDatabase;
27.     }
28.    
29.     @Override
30.     protected String getPendingRedisKey() {
31.         return AbstractRedisKeyConstants.PRODUCT_SKU_INFO_STRING;
32.     }
33.    
34.     @Override
35.     protected List<ProductDetailBO> convertDO2BO(Collection<ProductDetailDO> doList) {
36.         return productDetailConverter.converterDetailList(doList);
37.     }
38.    
39.     @Override
40.     protected Map<String, Object> getTableFieldsMap(String key) {
41.         Map<String, Object> dbInputMap = Maps.newHashMap();
42.         dbInputMap.put(SkuCollectStringDatabase.SKU_ID, key);
43.         return dbInputMap;
44.     }
45.    
46.     @Override
47.     protected Class<ProductDetailBO> getBOClass() {
48.         return ProductDetailBO.class;
49.     }
50.     ...
51. }
53. //Redis(string)缓存抽象类
54. //@param <DO> 数据对象
55. //@param <BO> 缓存对象
56. public abstract class AbstractRedisStringCache<DO, BO> {
57.     @Resource
58.     private RedisReadWriteManager redisReadWriteManager;
59.    
60.     //获取redis key
61.     //@param key 需要替换的关键字
62.     protected String getRedisKey(String key) {
63.         return String.format(getPendingRedisKey(), key);
64.     }
65.    
66.     //单个获取数据库表名
67.     public String getTableName() {
68.         return getStringDatabase().getTableName();
69.     }
70.    
71.     //获取DB读取对象
72.     protected abstract RedisStringDatabase<DO> getStringDatabase();
73.    
74.     //获取待处理的Redis key
75.     protected abstract String getPendingRedisKey();
76.    
77.     //DO转BO
78.     protected abstract List<BO> convertDO2BO(Collection<DO> doList);
79.    
80.     //关联表字段值
81.     protected abstract Map<String, Object> getTableFieldsMap(String key);
82.    
83.     //获取BO对象的class
84.     protected abstract Class<BO> getBOClass();
85.     ...
86.    
87.     //模版方法：根据关键字批量获取数据
88.     //@param useLocalCache 是否使用本地缓存
89.     //@param keyList       入参关键字
90.     public Optional<List<BO>> listRedisStringData(Boolean useLocalCache, List<String> keyList) {
91.         if (CollectionUtils.isEmpty(keyList)) {
92.             return Optional.empty();
93.         }
94.         Optional<List<BO>> boListOpt = redisReadWriteManager.listRedisStringDataByCache(useLocalCache, keyList,
95.             getBloomKey(), getStringDatabase()::getTableSingleFiled, getStringDatabase().getBloomField(),
96.             getBOClass(), this::getRedisKey, (key) -> {
97.                 Map<String, Object> tableFieldsMap = getTableFieldsMap(key);
98.                 Optional<DO> doOpt;
99.                 try {
100.                     doOpt = getStringDatabase().getTableData(tableFieldsMap, queryType());
101.                 } catch (Exception e) {
102.                     log.error("根据关键字批量获取数据异常 key={},paramMap={}", key, tableFieldsMap, e);
103.                     return Optional.empty();
104.                 }
105.                 if (!doOpt.isPresent()) {
106.                     return Optional.empty();
107.                 }
108.                 List<BO> boList = convertDO2BO(Arrays.asList(doOpt.get()));
109.                 if (CollectionUtils.isEmpty(boList)) {
110.                     return Optional.empty();
111.                 }
112.                 return Optional.of(boList.get(0));
113.             }
114.         );
115.         return boListOpt;
116.     }
117.    
118.     //模版方法：根据多关键字批量获取集合数据
119.     //@param keyList    入参关键字
120.     //@param requestMap key 数据库表字段，value 字段值，该map中的字段不要与getTableFieldsMap(key)获取的字段重复
121.     public Optional<List<BO>> listRedisStringData(List<String> keyList, Map<String, Object> requestMap) {
122.         if (CollectionUtils.isEmpty(keyList)) {
123.             return Optional.empty();
124.         }
125.         Optional<List<BO>> boListOpt = redisReadWriteManager.listRedisStringDataByBatchCache(keyList, getBOClass(), this::getRedisKey, (key) -> {
126.             Map<String, Object> tableFieldsMap = getTableFieldsMap(key);
127.             if (MapUtils.isNotEmpty(requestMap)) {
128.                 tableFieldsMap.putAll(requestMap);
129.             }
130.             Optional<List<DO>> doOpt;
131.             try {
132.                 doOpt = getStringDatabase().listTableData(tableFieldsMap, queryType());
133.             } catch (Exception e) {
134.                 log.error("根据关键字批量获取数据异常 key={},paramMap={}", key, tableFieldsMap, e);
135.                 return Optional.empty();
136.             }
137.             if (!doOpt.isPresent()) {
138.                 return Optional.empty();
139.             }
140.             List<BO> boList = convertDO2BO(doOpt.get());
141.             if (CollectionUtils.isEmpty(boList)) {
142.                 return Optional.empty();
143.             }
144.             return Optional.of(boList);
145.         });
146.         return boListOpt;
147.     }
148.    
149.     //模版方法：刷新缓存—根据主表ID集合（关联表变更需要查询主表）
150.     //@param tableName 关联表名
151.     //@param idSet     关联表主键集合
152.     public void flushRedisStringDataByTableAndIdSet(String tableName, Set<Long> idSet) {
153.         Optional<Set<Long>> idSetOpt = getStringDatabase().getTableIdSetByRelationTableIdSet(tableName, idSet);
154.         if (!idSetOpt.isPresent()) {
155.             return;
156.         }
157.         flushRedisStringDataByIdSet(idSetOpt.get());
158.     }
159.    
160.     //模版方法：刷新缓存—根据表变更数据ID集合
161.     public void flushRedisStringDataByTableUpdateData() {
162.         Optional<Set<Long>> updateIdSetOpt = getStringDatabase().getTableUpdateIdSet();
163.         if (!updateIdSetOpt.isPresent()) {
164.             return;
165.         }
166.         flushRedisStringDataByIdSet(updateIdSetOpt.get());
167.     }
168.    
169.     //模版方法：刷新缓存—根据主键ID集合
170.     //@param idSet 数据表主键ID
171.     private void flushRedisStringDataByIdSet(Set<Long> idSet) {
172.         //根据id集合从数据库中查询出数据
173.         Optional<RedisStringCache<DO>> stringSourceOpt = getStringDatabase().listTableDataByIdSet(idSet, queryType());
174.         if (!stringSourceOpt.isPresent()) {
175.             return;
176.         }
177.         RedisStringCache<DO> redisStringCache = stringSourceOpt.get();
178.         if (!CollectionUtils.isEmpty(redisStringCache.getDeleteSet())) {
179.             //通过缓存读写组件删除缓存
180.             redisReadWriteManager.delete(redisStringCache.getDeleteSet().stream().map(this::getRedisKey).collect(toSet()).toArray(new String[]{}));
181.         }
182.         if (CollectionUtils.isEmpty(redisStringCache.getAddList())) {
183.             return;
184.         }
185.         List<BO> boList = convertDO2BO(redisStringCache.getAddList());
186.         Map<String, BO> redisMap = convertBO2Map(boList);
187.         //通过缓存读写组件写入缓存
188.         redisReadWriteManager.batchWriteRedisString(redisMap);
189.     }
190.     ...
191. }

复制代码

 
3.自研缓存框架的通用缓存读写组件与DB操作组件
(1)通用缓存读写组件
(2)数据表的DB操作组件
 
每个数据表缓存组件都会有至少两个必备组件：一个通用缓存读写组件 + 一个数据表的DB操作组件。
 
(1)通用缓存读写组件
通用缓存读写组件也包含两个必备组件：一个操作缓存的RedisCache组件 + 一个操作分布式锁的RedisLock组件。通用缓存读写组件封装了大量基础的缓存读写操作，这些基础的缓存读写操作会结合DB读库 + 缓存问题等解决方案来进行实现。

1. //缓存读写管理
2. @Service
3. public class RedisReadWriteManager {
4.     @Resource
5.     private RedisCache redisCache;
6.    
7.     @Resource
8.     private RedisLock redisLock;
9.     ...
10.    
11.     //删除指定的key
12.     public void delete(String... keys) {
13.         Arrays.asList(keys).stream().forEach(key -> redisCache.delete(key));
14.     }
15.    
16.     //批量添加string缓存
17.     public <T> void batchWriteRedisString(Map<String, T> redisMap) {
18.         List<Map.Entry<String, T>> list = Lists.newArrayList(redisMap.entrySet());
19.         try {
20.             for (List<Map.Entry<String, T>> entries : Lists.partition(list, PAGE_SIZE_100)) {
21.                 for (Map.Entry<String, T> entry : entries) {
22.                     redisCache.setex(true, entry.getKey(), JSON.toJSONString(entry.getValue()), RedisKeyUtils.redisKeyRandomTime(INT_EXPIRED_SEVEN_DAYS));
23.                 }
24.                 try {
25.                     Thread.sleep(SLEEP_100);
26.                 } catch (InterruptedException e) {
27.                     e.printStackTrace();
28.                 }
29.             }
30.         } catch (Exception e) {
31.             log.error("批量添加string缓存异常 redisMap={}", redisMap, e);
32.         }
33.     }
34.    
35.     //批量获取多缓存数据
36.     public <T> Optional<List<T>> listRedisStringDataByBatchCache(List<String> keyList, Class<T> clazz, Function<String, String> getRedisKeyFunction, Function<String, Optional<List<T>>> getDbFuction) {
37.         try {
38.             List<T> list = Lists.newArrayList();
39.             List<String> pendingKeyList = keyList.stream().distinct().collect(toList());
40.             List<String> redisKeyList = pendingKeyList.stream().map(getRedisKeyFunction).distinct().collect(toList());
41.             List<String> cacheList = redisCache.mget(redisKeyList);
42.             for (int i = 0; i < cacheList.size(); i++) {
43.                 String cache = cacheList.get(i);
44.                 //过滤无效缓存
45.                 if (EMPTY_OBJECT_STRING.equals(cache)) {
46.                     continue;
47.                 }
48.                 if (StringUtils.isNotBlank(cache)) {
49.                     List<T> tList = JSON.parseArray(cache, clazz);
50.                     list.addAll(tList);
51.                     continue;
52.                 }
53.                 //缓存没有则读库
54.                 Optional<List<T>> optional = listRedisStringDataByDb(pendingKeyList.get(i), getRedisKeyFunction, getDbFuction);
55.                 if (optional.isPresent()) {
56.                     list.addAll(optional.get());
57.                 }
58.             }
59.             return CollectionUtils.isEmpty(list) ? Optional.empty() : Optional.of(list);
60.         } catch (Exception e) {
61.             log.error("批量获取缓存数据异常 keyList={},clazz={}", keyList, clazz, e);
62.             throw e;
63.         }
64.     }
65.    
66.     //读取数据库表多数据赋值到Redis
67.     public <T> Optional<List<T>> listRedisStringDataByDb(String key, Function<String, String> getRedisKeyFunction, Function<String, Optional<List<T>>> getDbFuction) {
68.         if (StringUtils.isEmpty(key) || Objects.isNull(getDbFuction)) {
69.             return Optional.empty();
70.         }
71.         try {
72.             if (!redisLock.lock(key)) {
73.                 return Optional.empty();
74.             }
75.             String redisKey = getRedisKeyFunction.apply(key);
76.             Optional<List<T>> optional = getDbFuction.apply(key);
77.             if (!optional.isPresent()) {
78.                 //把空对象暂存到redis
79.                 redisCache.setex(true, redisKey, EMPTY_OBJECT_STRING, RedisKeyUtils.redisKeyRandomTime(INT_EXPIRED_ONE_DAY, TimeUnit.HOURS, NUMBER_24));
80.                 log.warn("发生缓存穿透 redisKey={}", redisKey);
81.                 return optional;
82.             }
83.             //把表数据对象存到redis
84.             redisCache.setex(true, redisKey, JSON.toJSONString(optional.get()), RedisKeyUtils.redisKeyRandomTime(INT_EXPIRED_SEVEN_DAYS));
85.             log.info("表数据对象存到Redis redisKey={}, data={}", redisKey, optional.get());
86.             return optional;
87.         } finally {
88.             redisLock.unlock(key);
89.         }
90.     }
91.     ...
92. }

复制代码

(2)数据表的DB操作组件
该组件主要提供对数据表数据的查询方法。

1. @Service("productDetailStringDatabase")
2. public class ProductDetailStringDatabase extends AbstractRedisStringDatabase<ProductDetailDO> {
3.     public static final String SKU_ID = "skuId";
4.     private static final String TABLE_NAME = "sku_info";
5.    
6.     @Resource
7.     private ProductRepository productRepository;
8.    
9.     @Override
10.     public String getTableName() {
11.         return TABLE_NAME;
12.     }
13.    
14.     @Override
15.     public Set<String> getTableNameSet() {
16.         return Sets.newHashSet(getTableName());
17.     }
18.    
19.     @Override
20.     public Optional<ProductDetailDO> getTableData(Map<String, Object> tableFieldsMap, String queryType) {
21.         if (tableFieldsMap.containsKey(SKU_ID)) {
22.             String skuId = (String) tableFieldsMap.get(SKU_ID);
23.             ProductDetailDO productDetailDO = productRepository.queryProductDetail(skuId);
24.             if (!Objects.isNull(productDetailDO) && DelFlagEnum.EFFECTIVE.getCode().equals(productDetailDO.getDelFlag())) {
25.                 return Optional.of(productDetailDO);
26.             }
27.             return Optional.empty();
28.         }
29.         return Optional.empty();
30.     }
31.    
32.     @Override
33.     public Optional<List<ProductDetailDO>> listTableData(Map<String, Object> tableFieldsMap, String queryType) {
34.         return Optional.empty();
35.     }
36.    
37.     @Override
38.     public Optional<RedisStringCache<ProductDetailDO>> listTableDataByIdSet(Set<Long> idSet, String queryType) {
39.         RedisStringCache redisStringCache = new RedisStringCache();
40.         List<ProductDetailDO> addList = new ArrayList<>();
41.         for (Long skuId : idSet) {
42.             ProductDetailDO productDetailDO = productRepository.queryProductDetail(String.valueOf(skuId));
43.             if (!Objects.isNull(productDetailDO)) {
44.                 addList.add(productDetailDO);
45.             }
46.         }
47.         redisStringCache.setAddList(addList);
48.         return Optional.of(redisStringCache);
49.     }
50.    
51.     @Override
52.     public Optional<RedisStringCache<ProductDetailDO>> listTableDataByIdSet(List<Long> idSet, String queryType) {
53.         Long skuId = idSet.get(0);
54.         ProductDetailDO productDetailDO = productRepository.queryProductDetail(String.valueOf(skuId));
55.         RedisStringCache redisStringCache = new RedisStringCache();
56.         redisStringCache.setAddList(Arrays.asList(productDetailDO));
57.         return Optional.of(redisStringCache);
58.     }
59. }

复制代码

 

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！