strategyAwards = strategyAwardDao.queryStrategyAwardListByStrategyId(strategyId);
+ strategyAwardEntities = new ArrayList<>(strategyAwards.size());
+ for (StrategyAward strategyAward : strategyAwards) {
+ StrategyAwardEntity strategyAwardEntity = StrategyAwardEntity.builder()
+ .strategyId(strategyAward.getStrategyId())
+ .awardId(strategyAward.getAwardId())
+ .awardTitle(strategyAward.getAwardTitle())
+ .awardSubtitle(strategyAward.getAwardSubtitle())
+ .awardCount(strategyAward.getAwardCount())
+ .awardCountSurplus(strategyAward.getAwardCountSurplus())
+ .awardRate(strategyAward.getAwardRate())
+ .sort(strategyAward.getSort())
+ .ruleModels(strategyAward.getRuleModels())
+ .build();
+ strategyAwardEntities.add(strategyAwardEntity);
+ }
+ redisService.setValue(cacheKey, strategyAwardEntities);
+ return strategyAwardEntities;
+ }
+
+
+
+ /**
+ * 在 Redisson 中，当你调用 getMap 方法时，如果指定的 key 不存在，Redisson 并不会立即在 Redis 数据库中创建这个 key。相反，它会返回一个 RMap 对象的实例，这个实例是一个本地的 Java 对象，它代表了 Redis 中的一个哈希（hash）。
+ *
+ * 当你开始使用这个 RMap 实例进行操作，比如添加键值对，那么 Redisson 会在 Redis 数据库中创建相应的 key，并将数据存储在这个 key 对应的哈希中。如果你只是获取了 RMap 实例而没有进行任何操作，那么在 Redis 数据库中是不会有任何变化的。
+ *
+ * 简单来说，getMap 方法返回的 RMap 对象是懒加载的，只有在你实际进行操作时，Redis 数据库中的数据结构才会被创建或修改。
+ */
+ @Override
+ public void storeStrategyAwardSearchRateTable(Long strategyId, int size, Map shuffleStrategyAwardSearchRateTable) {
+ // 1. 存储抽奖策略范围值，如10000，用于生成1000以内的随机数
+ redisService.setValue(Constants.RedisKey.STRATEGY_RATE_RANGE_KEY + strategyId, size);
+ // 2. 存储概率查找表
+ Map cacheRateTable = redisService.getMap(Constants.RedisKey.STRATEGY_RATE_TABLE_KEY + strategyId);
+ cacheRateTable.putAll(shuffleStrategyAwardSearchRateTable);
+
+ }
+
+ @Override
+ public int getRateRange(Long strategyId) {
+ return redisService.getValue(Constants.RedisKey.STRATEGY_RATE_RANGE_KEY + strategyId);
+ }
+
+ @Override
+ public Integer getStrategyAwardAssemble(Long strategyId, Integer rateKey) {
+ return redisService.getFromMap(Constants.RedisKey.STRATEGY_RATE_TABLE_KEY + strategyId,rateKey);
+ }
+
+
+//
+// @Override
+// public Map getMap(String key) {
+// return redisService.getMap(Constants.RedisKey.STRATEGY_RATE_TABLE_KEY + key);
+// }
+//
+// @Override
+// public Integer getStrategyAwardAssemble(String key, Integer rateKey) {
+// return redisService.getFromMap(Constants.RedisKey.STRATEGY_RATE_TABLE_KEY + key, rateKey);
+// }
+//
+// @Override
+// public int getRateRange(Long strategyId) {
+// return getRateRange(String.valueOf(strategyId));
+// }
+//
+// @Override
+// public int getRateRange(String key) {
+// String cacheKey = Constants.RedisKey.STRATEGY_RATE_RANGE_KEY + key;
+// if (!redisService.isExists(cacheKey)) {
+// throw new AppException(UN_ASSEMBLED_STRATEGY_ARMORY.getCode(), cacheKey + Constants.COLON + UN_ASSEMBLED_STRATEGY_ARMORY.getInfo());
+// }
+// return redisService.getValue(cacheKey);
+// }
+//
+// @Override
+// public StrategyEntity queryStrategyEntityByStrategyId(Long strategyId) {
+// // 优先从缓存获取
+// String cacheKey = Constants.RedisKey.STRATEGY_KEY + strategyId;
+// StrategyEntity strategyEntity = redisService.getValue(cacheKey);
+// if (null != strategyEntity) return strategyEntity;
+// Strategy strategy = strategyDao.queryStrategyByStrategyId(strategyId);
+// if (null == strategy) return StrategyEntity.builder().build();
+// strategyEntity = StrategyEntity.builder()
+// .strategyId(strategy.getStrategyId())
+// .strategyDesc(strategy.getStrategyDesc())
+// .ruleModels(strategy.getRuleModels())
+// .build();
+// redisService.setValue(cacheKey, strategyEntity);
+// return strategyEntity;
+// }
+//
+// @Override
+// public StrategyRuleEntity queryStrategyRule(Long strategyId, String ruleModel) {
+// StrategyRule strategyRuleReq = new StrategyRule();
+// strategyRuleReq.setStrategyId(strategyId);
+// strategyRuleReq.setRuleModel(ruleModel);
+// StrategyRule strategyRuleRes = strategyRuleDao.queryStrategyRule(strategyRuleReq);
+// if (null == strategyRuleRes) return null;
+// return StrategyRuleEntity.builder()
+// .strategyId(strategyRuleRes.getStrategyId())
+// .awardId(strategyRuleRes.getAwardId())
+// .ruleType(strategyRuleRes.getRuleType())
+// .ruleModel(strategyRuleRes.getRuleModel())
+// .ruleValue(strategyRuleRes.getRuleValue())
+// .ruleDesc(strategyRuleRes.getRuleDesc())
+// .build();
+// }
+//
+// @Override
+// public String queryStrategyRuleValue(Long strategyId, String ruleModel) {
+// return queryStrategyRuleValue(strategyId, null, ruleModel);
+// }
+//
+// @Override
+// public String queryStrategyRuleValue(Long strategyId, Integer awardId, String ruleModel) {
+// StrategyRule strategyRule = new StrategyRule();
+// strategyRule.setStrategyId(strategyId);
+// strategyRule.setAwardId(awardId);
+// strategyRule.setRuleModel(ruleModel);
+// return strategyRuleDao.queryStrategyRuleValue(strategyRule);
+// }
+//
+// @Override
+// public StrategyAwardRuleModelVO queryStrategyAwardRuleModelVO(Long strategyId, Integer awardId) {
+// StrategyAward strategyAward = new StrategyAward();
+// strategyAward.setStrategyId(strategyId);
+// strategyAward.setAwardId(awardId);
+// String ruleModels = strategyAwardDao.queryStrategyAwardRuleModels(strategyAward);
+// if (null == ruleModels) return null;
+// return StrategyAwardRuleModelVO.builder().ruleModels(ruleModels).build();
+// }
+//
+// @Override
+// public RuleTreeVO queryRuleTreeVOByTreeId(String treeId) {
+// // 优先从缓存获取
+// String cacheKey = Constants.RedisKey.RULE_TREE_VO_KEY + treeId;
+// RuleTreeVO ruleTreeVOCache = redisService.getValue(cacheKey);
+// if (null != ruleTreeVOCache) return ruleTreeVOCache;
+//
+// // 从数据库获取
+// RuleTree ruleTree = ruleTreeDao.queryRuleTreeByTreeId(treeId);
+// List ruleTreeNodes = ruleTreeNodeDao.queryRuleTreeNodeListByTreeId(treeId);
+// List ruleTreeNodeLines = ruleTreeNodeLineDao.queryRuleTreeNodeLineListByTreeId(treeId);
+//
+// // 1. tree node line 转换Map结构
+// Map> ruleTreeNodeLineMap = new HashMap<>();
+// for (RuleTreeNodeLine ruleTreeNodeLine : ruleTreeNodeLines) {
+// RuleTreeNodeLineVO ruleTreeNodeLineVO = RuleTreeNodeLineVO.builder()
+// .treeId(ruleTreeNodeLine.getTreeId())
+// .ruleNodeFrom(ruleTreeNodeLine.getRuleNodeFrom())
+// .ruleNodeTo(ruleTreeNodeLine.getRuleNodeTo())
+// .ruleLimitType(RuleLimitTypeVO.valueOf(ruleTreeNodeLine.getRuleLimitType()))
+// .ruleLimitValue(RuleLogicCheckTypeVO.valueOf(ruleTreeNodeLine.getRuleLimitValue()))
+// .build();
+//
+// ruleTreeNodeLineMap
+// .computeIfAbsent(ruleTreeNodeLine.getRuleNodeFrom(), k -> new ArrayList<>())
+// .add(ruleTreeNodeLineVO);
+// }
+//
+// // 2. tree node 转换为Map结构
+// Map treeNodeMap = new HashMap<>();
+// for (RuleTreeNode ruleTreeNode : ruleTreeNodes) {
+// RuleTreeNodeVO ruleTreeNodeVO = RuleTreeNodeVO.builder()
+// .treeId(ruleTreeNode.getTreeId())
+// .ruleKey(ruleTreeNode.getRuleKey())
+// .ruleDesc(ruleTreeNode.getRuleDesc())
+// .ruleValue(ruleTreeNode.getRuleValue())
+// .treeNodeLineVOList(ruleTreeNodeLineMap.get(ruleTreeNode.getRuleKey()))
+// .build();
+// treeNodeMap.put(ruleTreeNode.getRuleKey(), ruleTreeNodeVO);
+// }
+//
+// // 3. 构建 Rule Tree
+// RuleTreeVO ruleTreeVODB = RuleTreeVO.builder()
+// .treeId(ruleTree.getTreeId())
+// .treeName(ruleTree.getTreeName())
+// .treeDesc(ruleTree.getTreeDesc())
+// .treeRootRuleNode(ruleTree.getTreeRootRuleKey())
+// .treeNodeMap(treeNodeMap)
+// .build();
+//
+// redisService.setValue(cacheKey, ruleTreeVODB);
+// return ruleTreeVODB;
+// }
+//
+// @Override
+// public void cacheStrategyAwardCount(String cacheKey, Integer awardCount) {
+// if (redisService.isExists(cacheKey)) return;
+// redisService.setAtomicLong(cacheKey, awardCount);
+// }
+//
+// @Override
+// public Boolean subtractionAwardStock(String cacheKey) {
+// return subtractionAwardStock(cacheKey, null);
+// }
+//
+// /**
+// * 扣减库存并加锁操作，decr和0对比，如果是incr操作就和总量对比，和总量对比可以动态添加库存
+// *
+// * @param cacheKey 缓存Key
+// * @param endDateTime 活动结束时间
+// */
+// @Override
+// public Boolean subtractionAwardStock(String cacheKey, Date endDateTime) {
+// long surplus = redisService.decr(cacheKey);
+// if (surplus < 0) {
+// // 库存小于0，恢复为0个
+// redisService.setAtomicLong(cacheKey, 0);
+// return false;
+// }
+// // 1. 按照cacheKey decr 后的值，如 99、98、97 和 key 组成为库存锁的key进行使用。
+// // 2. 加锁为了兜底，如果后续有恢复库存，手动处理等，也不会超卖。因为所有的可用库存key，都被加锁了。
+// String lockKey = cacheKey + Constants.UNDERLINE + surplus;
+// Boolean lock = false;
+// if (null != endDateTime) {
+// long expireMillis = endDateTime.getTime() - System.currentTimeMillis() + TimeUnit.DAYS.toMillis(1);
+// lock = redisService.setNx(lockKey, expireMillis, TimeUnit.MILLISECONDS);
+// } else {
+// lock = redisService.setNx(lockKey);
+// }
+// if (!lock) {
+// log.info("策略奖品库存加锁失败 {}", lockKey);
+// }
+// return lock;
+// }
+//
+// @Override
+// public void awardStockConsumeSendQueue(StrategyAwardStockKeyVO strategyAwardStockKeyVO) {
+// String cacheKey = Constants.RedisKey.STRATEGY_AWARD_COUNT_QUERY_KEY + Constants.UNDERLINE + strategyAwardStockKeyVO.getStrategyId() + Constants.UNDERLINE + strategyAwardStockKeyVO.getAwardId();
+// RBlockingQueue blockingQueue = redisService.getBlockingQueue(cacheKey);
+// RDelayedQueue delayedQueue = redisService.getDelayedQueue(blockingQueue);
+// delayedQueue.offer(strategyAwardStockKeyVO, 3, TimeUnit.SECONDS);
+// }
+//
+// @Override
+// public StrategyAwardStockKeyVO takeQueueValue() throws InterruptedException {
+// String cacheKey = Constants.RedisKey.STRATEGY_AWARD_COUNT_QUERY_KEY;
+// RBlockingQueue destinationQueue = redisService.getBlockingQueue(cacheKey);
+// return destinationQueue.poll();
+// }
+//
+// @Override
+// public StrategyAwardStockKeyVO takeQueueValue(Long strategyId, Integer awardId) throws InterruptedException {
+// String cacheKey = Constants.RedisKey.STRATEGY_AWARD_COUNT_QUERY_KEY + Constants.UNDERLINE + strategyId + Constants.UNDERLINE + awardId;
+// RBlockingQueue destinationQueue = redisService.getBlockingQueue(cacheKey);
+// return destinationQueue.poll();
+// }
+//
+// @Override
+// public void updateStrategyAwardStock(Long strategyId, Integer awardId) {
+// StrategyAward strategyAward = new StrategyAward();
+// strategyAward.setStrategyId(strategyId);
+// strategyAward.setAwardId(awardId);
+// strategyAwardDao.updateStrategyAwardStock(strategyAward);
+// }
+//
+// @Override
+// public StrategyAwardEntity queryStrategyAwardEntity(Long strategyId, Integer awardId) {
+// // 优先从缓存获取
+// String cacheKey = Constants.RedisKey.STRATEGY_AWARD_KEY + strategyId + Constants.UNDERLINE + awardId;
+// StrategyAwardEntity strategyAwardEntity = redisService.getValue(cacheKey);
+// if (null != strategyAwardEntity) return strategyAwardEntity;
+// // 查询数据
+// StrategyAward strategyAwardReq = new StrategyAward();
+// strategyAwardReq.setStrategyId(strategyId);
+// strategyAwardReq.setAwardId(awardId);
+// StrategyAward strategyAwardRes = strategyAwardDao.queryStrategyAward(strategyAwardReq);
+// // 转换数据
+// strategyAwardEntity = StrategyAwardEntity.builder()
+// .strategyId(strategyAwardRes.getStrategyId())
+// .awardId(strategyAwardRes.getAwardId())
+// .awardTitle(strategyAwardRes.getAwardTitle())
+// .awardSubtitle(strategyAwardRes.getAwardSubtitle())
+// .awardCount(strategyAwardRes.getAwardCount())
+// .awardCountSurplus(strategyAwardRes.getAwardCountSurplus())
+// .awardRate(strategyAwardRes.getAwardRate())
+// .sort(strategyAwardRes.getSort())
+// .build();
+// // 缓存结果
+// redisService.setValue(cacheKey, strategyAwardEntity);
+// // 返回数据
+// return strategyAwardEntity;
+// }
+//
+// @Override
+// public Long queryStrategyIdByActivityId(Long activityId) {
+// return raffleActivityDao.queryStrategyIdByActivityId(activityId);
+// }
+//
+// @Override
+// public Integer queryTodayUserRaffleCount(String userId, Long strategyId) {
+// // 活动ID
+// Long activityId = raffleActivityDao.queryActivityIdByStrategyId(strategyId);
+// // 封装参数
+// RaffleActivityAccountDay raffleActivityAccountDayReq = new RaffleActivityAccountDay();
+// raffleActivityAccountDayReq.setUserId(userId);
+// raffleActivityAccountDayReq.setActivityId(activityId);
+// raffleActivityAccountDayReq.setDay(RaffleActivityAccountDay.currentDay());
+// RaffleActivityAccountDay raffleActivityAccountDay = raffleActivityAccountDayDao.queryActivityAccountDayByUserId(raffleActivityAccountDayReq);
+// if (null == raffleActivityAccountDay) return 0;
+// // 总次数 - 剩余的，等于今日参与的
+// return raffleActivityAccountDay.getDayCount() - raffleActivityAccountDay.getDayCountSurplus();
+// }
+//
+// @Override
+// public Map queryAwardRuleLockCount(String[] treeIds) {
+// if (null == treeIds || treeIds.length == 0) return new HashMap<>();
+// List ruleTreeNodes = ruleTreeNodeDao.queryRuleLocks(treeIds);
+// Map resultMap = new HashMap<>();
+// for (RuleTreeNode node : ruleTreeNodes) {
+// String treeId = node.getTreeId();
+// Integer ruleValue = Integer.valueOf(node.getRuleValue());
+// resultMap.put(treeId, ruleValue);
+// }
+// return resultMap;
+// }
+//
+// @Override
+// public Integer queryActivityAccountTotalUseCount(String userId, Long strategyId) {
+// Long activityId = raffleActivityDao.queryActivityIdByStrategyId(strategyId);
+// RaffleActivityAccount raffleActivityAccount = raffleActivityAccountDao.queryActivityAccountByUserId(RaffleActivityAccount.builder()
+// .userId(userId)
+// .activityId(activityId)
+// .build());
+// // 返回计算使用量
+// return raffleActivityAccount.getTotalCount() - raffleActivityAccount.getTotalCountSurplus();
+// }
+//
+// @Override
+// public List queryAwardRuleWeight(Long strategyId) {
+// // 优先从缓存获取
+// String cacheKey = Constants.RedisKey.STRATEGY_RULE_WEIGHT_KEY + strategyId;
+// List ruleWeightVOS = redisService.getValue(cacheKey);
+// if (null != ruleWeightVOS) return ruleWeightVOS;
+//
+// ruleWeightVOS = new ArrayList<>();
+// // 1. 查询权重规则配置
+// StrategyRule strategyRuleReq = new StrategyRule();
+// strategyRuleReq.setStrategyId(strategyId);
+// strategyRuleReq.setRuleModel(DefaultChainFactory.LogicModel.RULE_WEIGHT.getCode());
+// String ruleValue = strategyRuleDao.queryStrategyRuleValue(strategyRuleReq);
+// // 2. 借助实体对象转换规则
+// StrategyRuleEntity strategyRuleEntity = new StrategyRuleEntity();
+// strategyRuleEntity.setRuleModel(DefaultChainFactory.LogicModel.RULE_WEIGHT.getCode());
+// strategyRuleEntity.setRuleValue(ruleValue);
+// Map> ruleWeightValues = strategyRuleEntity.getRuleWeightValues();
+// // 3. 遍历规则组装奖品配置
+// Set ruleWeightKeys = ruleWeightValues.keySet();
+// for (String ruleWeightKey : ruleWeightKeys) {
+// List awardIds = ruleWeightValues.get(ruleWeightKey);
+// List awardList = new ArrayList<>();
+// // 也可以修改为一次从数据库查询
+// for (Integer awardId : awardIds) {
+// StrategyAward strategyAwardReq = new StrategyAward();
+// strategyAwardReq.setStrategyId(strategyId);
+// strategyAwardReq.setAwardId(awardId);
+// StrategyAward strategyAward = strategyAwardDao.queryStrategyAward(strategyAwardReq);
+// awardList.add(RuleWeightVO.Award.builder()
+// .awardId(strategyAward.getAwardId())
+// .awardTitle(strategyAward.getAwardTitle())
+// .build());
+// }
+//
+// ruleWeightVOS.add(RuleWeightVO.builder()
+// .ruleValue(ruleValue)
+// .weight(Integer.valueOf(ruleWeightKey.split(Constants.COLON)[0]))
+// .awardIds(awardIds)
+// .awardList(awardList)
+// .build());
+// }
+//
+// // 设置缓存 - 实际场景中，这类数据，可以在活动下架的时候统一清空缓存。
+// redisService.setValue(cacheKey, ruleWeightVOS);
+//
+// return ruleWeightVOS;
+// }
+//
+// @Override
+// public List queryOpenActivityStrategyAwardList() {
+// List strategyAwards = strategyAwardDao.queryOpenActivityStrategyAwardList();
+// if (null == strategyAwards || strategyAwards.isEmpty()) return null;
+//
+// List strategyAwardStockKeyVOS = new ArrayList<>();
+// for (StrategyAward strategyAward : strategyAwards) {
+// StrategyAwardStockKeyVO strategyAwardStockKeyVO = StrategyAwardStockKeyVO.builder()
+// .strategyId(strategyAward.getStrategyId())
+// .awardId(strategyAward.getAwardId())
+// .build();
+// strategyAwardStockKeyVOS.add(strategyAwardStockKeyVO);
+// }
+//
+// return strategyAwardStockKeyVOS;
+// }
+//
+// @Override
+// public void cacheStrategyArmoryAlgorithm(String key, String beanName) {
+// String cacheKey = Constants.RedisKey.STRATEGY_ARMORY_ALGORITHM_KEY + key;
+// redisService.setValue(cacheKey, beanName);
+// }
+//
+// @Override
+// public String queryStrategyArmoryAlgorithmFromCache(String key) {
+// String cacheKey = Constants.RedisKey.STRATEGY_ARMORY_ALGORITHM_KEY + key;
+// if (!redisService.isExists(cacheKey)) return null;
+// return redisService.getValue(cacheKey);
+// }
+
+}
diff --git a/xfg-frame-archetype-lite-infrastructure/src/main/java/cn/bugstack/infrastructure/redis/IRedisService.java b/xfg-frame-archetype-lite-infrastructure/src/main/java/cn/bugstack/infrastructure/redis/IRedisService.java
new file mode 100644
index 0000000000000000000000000000000000000000..c048230b6cef159603591b9f5c9ea6ddfb5090d1
--- /dev/null
+++ b/xfg-frame-archetype-lite-infrastructure/src/main/java/cn/bugstack/infrastructure/redis/IRedisService.java
@@ -0,0 +1,266 @@
+package cn.bugstack.infrastructure.redis;
+
+import org.redisson.api.*;
+
+import java.util.concurrent.TimeUnit;
+
+
+public interface IRedisService {
+
+ /**
+ * 设置指定 key 的值
+ *
+ * @param key 键
+ * @param value 值
+ */
+ void setValue(String key, T value);
+
+ /**
+ * 设置指定 key 的值
+ *
+ * @param key 键
+ * @param value 值
+ * @param expired 过期时间
+ */
+ void setValue(String key, T value, long expired);
+
+ /**
+ * 获取指定 key 的值
+ *
+ * @param key 键
+ * @return 值
+ */
+ T getValue(String key);
+
+ /**
+ * 获取队列
+ *
+ * @param key 键
+ * @param 泛型
+ * @return 队列
+ */
+ RQueue getQueue(String key);
+
+ /**
+ * 加锁队列
+ *
+ * @param key 键
+ * @param 泛型
+ * @return 队列
+ */
+ RBlockingQueue getBlockingQueue(String key);
+
+ /**
+ * 延迟队列
+ *
+ * @param rBlockingQueue 加锁队列
+ * @param 泛型
+ * @return 队列
+ */
+ RDelayedQueue getDelayedQueue(RBlockingQueue rBlockingQueue);
+
+ /**
+ * 设置值
+ *
+ * @param key key 键
+ * @param value 值
+ */
+ void setAtomicLong(String key, long value);
+
+ /**
+ * 获取值
+ *
+ * @param key key 键
+ */
+ Long getAtomicLong(String key);
+
+ /**
+ * 自增 Key 的值；1、2、3、4
+ *
+ * @param key 键
+ * @return 自增后的值
+ */
+ long incr(String key);
+
+ /**
+ * 指定值，自增 Key 的值；1、2、3、4
+ *
+ * @param key 键
+ * @return 自增后的值
+ */
+ long incrBy(String key, long delta);
+
+ /**
+ * 自减 Key 的值；1、2、3、4
+ *
+ * @param key 键
+ * @return 自增后的值
+ */
+ long decr(String key);
+
+ /**
+ * 指定值，自增 Key 的值；1、2、3、4
+ *
+ * @param key 键
+ * @return 自增后的值
+ */
+ long decrBy(String key, long delta);
+
+
+ /**
+ * 移除指定 key 的值
+ *
+ * @param key 键
+ */
+ void remove(String key);
+
+ /**
+ * 判断指定 key 的值是否存在
+ *
+ * @param key 键
+ * @return true/false
+ */
+ boolean isExists(String key);
+
+ /**
+ * 将指定的值添加到集合中
+ *
+ * @param key 键
+ * @param value 值
+ */
+ void addToSet(String key, String value);
+
+ /**
+ * 判断指定的值是否是集合的成员
+ *
+ * @param key 键
+ * @param value 值
+ * @return 如果是集合的成员返回 true，否则返回 false
+ */
+ boolean isSetMember(String key, String value);
+
+ /**
+ * 将指定的值添加到列表中
+ *
+ * @param key 键
+ * @param value 值
+ */
+ void addToList(String key, String value);
+
+ /**
+ * 获取列表中指定索引的值
+ *
+ * @param key 键
+ * @param index 索引
+ * @return 值
+ */
+ String getFromList(String key, int index);
+
+ /**
+ * 获取Map
+ *
+ * @param key 键
+ * @return 值
+ */
+ RMap getMap(String key);
+
+ /**
+ * 将指定的键值对添加到哈希表中
+ *
+ * @param key 键
+ * @param field 字段
+ * @param value 值
+ */
+ void addToMap(String key, String field, String value);
+
+ /**
+ * 获取哈希表中指定字段的值
+ *
+ * @param key 键
+ * @param field 字段
+ * @return 值
+ */
+ String getFromMap(String key, String field);
+
+ /**
+ * 获取哈希表中指定字段的值
+ *
+ * @param key 键
+ * @param field 字段
+ * @return 值
+ */
+ V getFromMap(String key, K field);
+
+ /**
+ * 将指定的值添加到有序集合中
+ *
+ * @param key 键
+ * @param value 值
+ */
+ void addToSortedSet(String key, String value);
+
+ /**
+ * 获取 Redis 锁（可重入锁）
+ *
+ * @param key 键
+ * @return Lock
+ */
+ RLock getLock(String key);
+
+ /**
+ * 获取 Redis 锁（公平锁）
+ *
+ * @param key 键
+ * @return Lock
+ */
+ RLock getFairLock(String key);
+
+ /**
+ * 获取 Redis 锁（读写锁）
+ *
+ * @param key 键
+ * @return RReadWriteLock
+ */
+ RReadWriteLock getReadWriteLock(String key);
+
+ /**
+ * 获取 Redis 信号量
+ *
+ * @param key 键
+ * @return RSemaphore
+ */
+ RSemaphore getSemaphore(String key);
+
+ /**
+ * 获取 Redis 过期信号量
+ *
+ * 基于Redis的Redisson的分布式信号量（Semaphore）Java对象RSemaphore采用了与java.util.concurrent.Semaphore相似的接口和用法。
+ * 同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。
+ *
+ * @param key 键
+ * @return RPermitExpirableSemaphore
+ */
+ RPermitExpirableSemaphore getPermitExpirableSemaphore(String key);
+
+ /**
+ * 闭锁
+ *
+ * @param key 键
+ * @return RCountDownLatch
+ */
+ RCountDownLatch getCountDownLatch(String key);
+
+ /**
+ * 布隆过滤器
+ *
+ * @param key 键
+ * @param 存放对象
+ * @return 返回结果
+ */
+ RBloomFilter getBloomFilter(String key);
+
+ Boolean setNx(String key);
+
+ Boolean setNx(String key, long expired, TimeUnit timeUnit);
+
+}
diff --git a/xfg-frame-archetype-lite-infrastructure/src/main/java/cn/bugstack/infrastructure/redis/RedissonService.java b/xfg-frame-archetype-lite-infrastructure/src/main/java/cn/bugstack/infrastructure/redis/RedissonService.java
new file mode 100644
index 0000000000000000000000000000000000000000..5175a39f4a7ae898ee10763005ee2cae6e0617ee
--- /dev/null
+++ b/xfg-frame-archetype-lite-infrastructure/src/main/java/cn/bugstack/infrastructure/redis/RedissonService.java
@@ -0,0 +1,176 @@
+package cn.bugstack.infrastructure.redis;
+
+import org.redisson.api.*;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.time.Duration;
+import java.util.concurrent.TimeUnit;
+
+
+@Service("redissonService")
+public class RedissonService implements IRedisService {
+
+ @Resource
+ private RedissonClient redissonClient;
+
+ public void setValue(String key, T value) {
+ redissonClient.getBucket(key).set(value);
+ }
+
+ @Override
+ public void setValue(String key, T value, long expired) {
+ RBucket bucket = redissonClient.getBucket(key);
+ bucket.set(value, Duration.ofMillis(expired));
+ }
+
+ public T getValue(String key) {
+ return redissonClient.getBucket(key).get();
+ }
+
+ @Override
+ public RQueue getQueue(String key) {
+ return redissonClient.getQueue(key);
+ }
+
+ @Override
+ public RBlockingQueue getBlockingQueue(String key) {
+ return redissonClient.getBlockingQueue(key);
+ }
+
+ @Override
+ public RDelayedQueue getDelayedQueue(RBlockingQueue rBlockingQueue) {
+ return redissonClient.getDelayedQueue(rBlockingQueue);
+ }
+
+ @Override
+ public void setAtomicLong(String key, long value) {
+ redissonClient.getAtomicLong(key).set(value);
+ }
+
+ @Override
+ public Long getAtomicLong(String key) {
+ return redissonClient.getAtomicLong(key).get();
+ }
+
+ @Override
+ public long incr(String key) {
+ return redissonClient.getAtomicLong(key).incrementAndGet();
+ }
+
+ @Override
+ public long incrBy(String key, long delta) {
+ return redissonClient.getAtomicLong(key).addAndGet(delta);
+ }
+
+ @Override
+ public long decr(String key) {
+ return redissonClient.getAtomicLong(key).decrementAndGet();
+ }
+
+ @Override
+ public long decrBy(String key, long delta) {
+ return redissonClient.getAtomicLong(key).addAndGet(-delta);
+ }
+
+ @Override
+ public void remove(String key) {
+ redissonClient.getBucket(key).delete();
+ }
+
+ @Override
+ public boolean isExists(String key) {
+ return redissonClient.getBucket(key).isExists();
+ }
+
+ public void addToSet(String key, String value) {
+ RSet set = redissonClient.getSet(key);
+ set.add(value);
+ }
+
+ public boolean isSetMember(String key, String value) {
+ RSet set = redissonClient.getSet(key);
+ return set.contains(value);
+ }
+
+ public void addToList(String key, String value) {
+ RList list = redissonClient.getList(key);
+ list.add(value);
+ }
+
+ public String getFromList(String key, int index) {
+ RList list = redissonClient.getList(key);
+ return list.get(index);
+ }
+
+ @Override
+ public RMap getMap(String key) {
+ return redissonClient.getMap(key);
+ }
+
+ public void addToMap(String key, String field, String value) {
+ RMap map = redissonClient.getMap(key);
+ map.put(field, value);
+ }
+
+ public String getFromMap(String key, String field) {
+ RMap map = redissonClient.getMap(key);
+ return map.get(field);
+ }
+
+ @Override
+ public V getFromMap(String key, K field) {
+ return redissonClient.getMap(key).get(field);
+ }
+
+ public void addToSortedSet(String key, String value) {
+ RSortedSet sortedSet = redissonClient.getSortedSet(key);
+ sortedSet.add(value);
+ }
+
+ @Override
+ public RLock getLock(String key) {
+ return redissonClient.getLock(key);
+ }
+
+ @Override
+ public RLock getFairLock(String key) {
+ return redissonClient.getFairLock(key);
+ }
+
+ @Override
+ public RReadWriteLock getReadWriteLock(String key) {
+ return redissonClient.getReadWriteLock(key);
+ }
+
+ @Override
+ public RSemaphore getSemaphore(String key) {
+ return redissonClient.getSemaphore(key);
+ }
+
+ @Override
+ public RPermitExpirableSemaphore getPermitExpirableSemaphore(String key) {
+ return redissonClient.getPermitExpirableSemaphore(key);
+ }
+
+ @Override
+ public RCountDownLatch getCountDownLatch(String key) {
+ return redissonClient.getCountDownLatch(key);
+ }
+
+ @Override
+ public RBloomFilter getBloomFilter(String key) {
+ return redissonClient.getBloomFilter(key);
+ }
+
+ @Override
+ public Boolean setNx(String key) {
+ return redissonClient.getBucket(key).trySet("lock");
+ }
+
+ @Override
+ public Boolean setNx(String key, long expired, TimeUnit timeUnit) {
+ return redissonClient.getBucket(key).trySet("lock", expired, timeUnit);
+ }
+
+}
diff --git a/xfg-frame-archetype-lite-infrastructure/src/main/java/cn/bugstack/infrastructure/redis/package-info.java b/xfg-frame-archetype-lite-infrastructure/src/main/java/cn/bugstack/infrastructure/redis/package-info.java
deleted file mode 100644
index 6c4af599f36b3ce3e4b4b9dd56a530470f9f1270..0000000000000000000000000000000000000000
--- a/xfg-frame-archetype-lite-infrastructure/src/main/java/cn/bugstack/infrastructure/redis/package-info.java
+++ /dev/null
@@ -1,4 +0,0 @@
-/**
- * 提供redis链接配置
- */
-package cn.bugstack.infrastructure.redis;
\ No newline at end of file
diff --git a/xfg-frame-archetype-lite-types/src/main/java/cn/bugstack/types/common/Constants.java b/xfg-frame-archetype-lite-types/src/main/java/cn/bugstack/types/common/Constants.java
index 3e21a0d11d286581ba84b5545c78411809a745e9..1943758bae6ec35968ac3dc73f1278dbd3821b19 100644
--- a/xfg-frame-archetype-lite-types/src/main/java/cn/bugstack/types/common/Constants.java
+++ b/xfg-frame-archetype-lite-types/src/main/java/cn/bugstack/types/common/Constants.java
@@ -3,5 +3,35 @@ package cn.bugstack.types.common;
public class Constants {
public final static String SPLIT = ",";
+ public final static String COLON = ":";
+ public final static String SPACE = " ";
+ public final static String UNDERLINE = "_";
+
+ /**
+ * 定义出缓存key的前缀标识，
+ */
+ public static class RedisKey {
+ public static String ACTIVITY_KEY = "big_market_activity_key_";
+ public static String ACTIVITY_SKU_KEY = "big_market_activity_sku_key_";
+ public static String ACTIVITY_COUNT_KEY = "big_market_activity_count_key_";
+ public static String STRATEGY_KEY = "big_market_strategy_key_";
+ public static String STRATEGY_AWARD_KEY = "big_market_strategy_award_key_";
+ public static String STRATEGY_AWARD_LIST_KEY = "big_market_strategy_award_list_key_";
+ public static String STRATEGY_RATE_TABLE_KEY = "big_market_strategy_rate_table_key_";
+ public static String STRATEGY_RATE_RANGE_KEY = "big_market_strategy_rate_range_key_";
+ public static String RULE_TREE_VO_KEY = "rule_tree_vo_key_";
+ public static String STRATEGY_AWARD_COUNT_KEY = "strategy_award_count_key_";
+ public static String STRATEGY_AWARD_COUNT_QUERY_KEY = "strategy_award_count_query_key";
+ public static String STRATEGY_RULE_WEIGHT_KEY = "strategy_rule_weight_key_";
+ public static String ACTIVITY_SKU_COUNT_QUERY_KEY = "activity_sku_count_query_key";
+ public static String ACTIVITY_SKU_STOCK_COUNT_KEY = "activity_sku_stock_count_key_";
+ public static String ACTIVITY_SKU_COUNT_CLEAR_KEY = "activity_sku_count_clear_key_";
+ public static String ACTIVITY_ACCOUNT_LOCK = "activity_account_lock_";
+ public static String ACTIVITY_ACCOUNT_UPDATE_LOCK = "activity_account_update_lock_";
+ public static String USER_CREDIT_ACCOUNT_LOCK = "user_credit_account_lock_";
+ public static String STRATEGY_ARMORY_ALGORITHM_KEY = "strategy_armory_algorithm_key_";
+
+ }
+
}