大营销平台 —— 抽奖前置规则过滤

一、前言上一期我们实现了权重配置的装配这一期我们将实现抽奖业务的前置规则过滤这里主要涉及了两个规则第一个是黑名单要求这些用户100积分只能抽到1积分第二个是权重抽奖在幸运值达到指定分数时触发保底机制为什么叫做前置过滤呢因为黑名单和权重都需要在每次抽奖前就判断好也就类似于一个拦截器。我认为在实现这些复杂业务的时候应该遵循“找核心”的思维从整体推到局部并且应该先确定整体的核心类然后再确定核心类中的核心方法接着确定核心方法中的核心流程最后再去看想要实现这个流程需要补充哪些实体/工厂/实现类。二、核心流程抽象类这里的基本准备很重要后面的规则过滤都需要通过这些准备内容来实现我们在这里需要准备两部分内容1.过滤器的整体框架接口2.各种实体类1. 核心类AbstractRaffleStrategy我们以往写对请求的过滤器时我们看到的preHandle/postHandle这些方法其实就是前置/后置过滤当然我们这里不能使用这个因为我们不是对请求拦截只是在抽奖业务内部对业务规则进行拦截所以我们在这里选择创建一个抽象类来充当一个过滤器框架。public interface HandlerInterceptor { // 在 Controller 方法执行前调用 boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception; // 在 Controller 方法执行后视图渲染前调用 void postHandle(...); // 在整个请求结束后调用 void afterCompletion(...); }首先要明确整体流程这个是最重要的视频中在这部分就讲得不好如果结构没有理清楚后面基本上都是在抄代码。整体流程1.开始抽奖 —— 从抽象类AbstractRaffleStrategy中开始2.校验参数3.过滤4.在过滤时检验userId是否在黑名单在的话就返回一个固定的奖品5.如果不在就再去检验有没有权重规则检查幸运值搞清楚流程过后就可以开始写代码了首先应该先写出刚刚我们看到的类似于请求拦截器的过滤结构框架然后再在其中的抽奖前过滤方法中增加过滤逻辑首先要注意我们是要创建一个抽象类确实很久没有写过抽象类了一直以来都是通过实现接口的方式来规定方法在这里回顾一下抽象类的作用抽象类的存在就是为了让子类继承的子类会继承抽象父类的所有非私有方法。这里的这个抽奖策略抽象类是本小节的核心类它规定了整个抽奖的流程也就是建立了一个抽奖框架。/** * author 印东升 * description 抽奖策略抽象类定义抽奖的标准流程 * create 2026-04-10 11:19 */ Slf4j public abstract class AbstractRaffleStrategy implements IRaffleStrategy { //策略仓储服务 protected IStrategyRepository repository; //策略调度服务 protected IStrategyDispatch strategyDispatch; public AbstractRaffleStrategy(IStrategyRepository repository, IStrategyDispatch strategyDispatch) { this.repository repository; this.strategyDispatch strategyDispatch; } Override public RaffleAwardEntity performRaffle(RaffleFactorEntity raffleFactorEntity) { // 1. 参数校验 String userId raffleFactorEntity.getUserId(); Long strategyId raffleFactorEntity.getStrategyId(); if (null strategyId || StringUtils.isBlank(userId)) { throw new AppException(ResponseCode.ILLEGAL_PARAMETER.getCode(), ResponseCode.ILLEGAL_PARAMETER.getInfo()); } // 2. 策略查询 StrategyEntity strategy repository.queryStrategyEntityByStrategyId(strategyId); // 3. 抽奖前 - 规则过滤 RuleActionEntityRuleActionEntity.RaffleBeforeEntity ruleActionEntity this.doCheckRaffleBeforeLogic(RaffleFactorEntity.builder().userId(userId).strategyId(strategyId).build(), strategy.ruleModels()); if (RuleLogicCheckTypeVO.TAKE_OVER.getCode().equals(ruleActionEntity.getCode())) { if (DefaultLogicFactory.LogicModel.RULE_BLACKLIST.getCode().equals(ruleActionEntity.getRuleModel())) { // 黑名单返回固定的奖品ID return RaffleAwardEntity.builder() .awardId(ruleActionEntity.getData().getAwardId()) .build(); } else if (DefaultLogicFactory.LogicModel.RULE_WIGHT.getCode().equals(ruleActionEntity.getRuleModel())) { // 权重根据返回的信息进行抽奖 RuleActionEntity.RaffleBeforeEntity raffleBeforeEntity ruleActionEntity.getData(); String ruleWeightValueKey raffleBeforeEntity.getRuleWeightValueKey(); Integer awardId strategyDispatch.getRandomAwardId(strategyId, ruleWeightValueKey); return RaffleAwardEntity.builder() .awardId(awardId) .build(); } } // 4. 默认抽奖流程 Integer awardId strategyDispatch.getRandomAwardId(strategyId); return RaffleAwardEntity.builder() .awardId(awardId) .build(); } protected abstract RuleActionEntityRuleActionEntity.RaffleBeforeEntity doCheckRaffleBeforeLogic(RaffleFactorEntity raffleFactorEntity, String... logics); }2.核心方法performRaffle()我们必须好好分析这个类必须理解它每一部分在干什么因为这个类是核心。首先performRaffle()是这个抽象类中最核心的方法是用于进行抽奖前置过滤的方法我们需要传入userId和strategyId封装到了一个RaffleFactorEntity实体类用于校验参数因为我们需要知道当前的userId才能知道其是否在黑名单之中同时我们需要知道当前的strategyId用于获取当前策略的所有规则比如这里的100001号策略里面就有两个规则一个是黑名单一个是权重规则后续要一个一个地去过滤它们public RaffleAwardEntity performRaffle(RaffleFactorEntity raffleFactorEntity)然后我们来看看这个核心方法里面的流程1.参数校验从传入的raffleFactorEntity对象中获取我们想要的userId和strategyId判空//抽奖因子实体 Data Builder AllArgsConstructor NoArgsConstructor public class RaffleFactorEntity { /** * 用户id */ private String userId; /** * 策略id */ private Long strategyId; }// 1. 参数校验 String userId raffleFactorEntity.getUserId(); Long strategyId raffleFactorEntity.getStrategyId(); if (null strategyId || StringUtils.isBlank(userId)) { throw new AppException(ResponseCode.ILLEGAL_PARAMETER.getCode(), ResponseCode.ILLEGAL_PARAMETER.getInfo()); }2.查询策略这里查询策略实体是为了获取策略本质还是通过从表中获取策略规则ruleModels这里调用仓储然后仓储再调用Dao最后Dao查表// 2. 策略查询 StrategyEntity strategy repository.queryStrategyEntityByStrategyId(strategyId);3.核心流程规则过滤// 3. 抽奖前 - 规则过滤 RuleActionEntityRuleActionEntity.RaffleBeforeEntity ruleActionEntity this.doCheckRaffleBeforeLogic(RaffleFactorEntity.builder().userId(userId).strategyId(strategyId).build(), strategy.ruleModels()); if (RuleLogicCheckTypeVO.TAKE_OVER.getCode().equals(ruleActionEntity.getCode())) { if (DefaultLogicFactory.LogicModel.RULE_BLACKLIST.getCode().equals(ruleActionEntity.getRuleModel())) { // 黑名单返回固定的奖品ID return RaffleAwardEntity.builder() .awardId(ruleActionEntity.getData().getAwardId()) .build(); } else if (DefaultLogicFactory.LogicModel.RULE_WIGHT.getCode().equals(ruleActionEntity.getRuleModel())) { // 权重根据返回的信息进行抽奖 RuleActionEntity.RaffleBeforeEntity raffleBeforeEntity ruleActionEntity.getData(); String ruleWeightValueKey raffleBeforeEntity.getRuleWeightValueKey(); Integer awardId strategyDispatch.getRandomAwardId(strategyId, ruleWeightValueKey); return RaffleAwardEntity.builder() .awardId(awardId) .build(); } }这里就是核心方法中的核心流程了接下来一步一步来拆开理解核心流程分为四步RuleActionEntityRuleActionEntity.RaffleBeforeEntity ruleActionEntity this.doCheckRaffleBeforeLogic(RaffleFactorEntity.builder().userId(userId).strategyId(strategyId).build(), strategy.ruleModels());1.核心流程的第一步中我们定义了一个新的实体类RuleActionEntity这个实体类结构有点复杂但是目的其实就是通过泛型和内部静态类来做到一个大实体类中含多个用途实体类。再说详细一点也就是这一个实体类中有三个用途分别是前中后过滤那么我们就写三个内部静态类通过泛型我们就可以知道当前是用的哪个实体类这样的好处是可以将这三个用途的实体类放在一起统一管理并且它们三个用途实体类的一些共有的属性可以不用重复写了直接写在大实体类中就行了。而这个前置用途实体类里面放什么呢就放我们前置过滤需要用的属性就行了所以有7个属性code、info、ruleModel、data共有和strategyId、ruleWeightValueKey、awardId前置这里调用了doCheckRaffleBeforeLogic()方法暂时按下不表。//规则动作实体 Data Builder AllArgsConstructor NoArgsConstructor public class RuleActionEntityT extends RuleActionEntity.RaffleEntity { private String code RuleLogicCheckTypeVO.ALLOW.getCode(); private String info RuleLogicCheckTypeVO.ALLOW.getInfo(); private String ruleModel; private T data; static public class RaffleEntity {} EqualsAndHashCode(callSuper true) Data Builder AllArgsConstructor NoArgsConstructor static public class RaffleBeforeEntity extends RaffleEntity { /** * 策略id */ private Long strategyId; /** * 权重key用于抽奖时可以选择权重抽奖 */ private String ruleWeightValueKey; /** * 奖品id */ private Integer awardId; } //抽奖之中 static public class RaffleCenterEntity extends RaffleEntity {} //抽奖之后 static public class RaffleAfterEntity extends RaffleEntity {} }if (RuleLogicCheckTypeVO.TAKE_OVER.getCode().equals(ruleActionEntity.getCode()))2.核心流程第第二步时我们已经拿到了规则动作实体对象了现在要做的是判断是放行还是接管如果放行就直接走默认抽奖了如果接管就要开始过滤规则了。//规则过滤校验类型值对象 Getter AllArgsConstructor public enum RuleLogicCheckTypeVO { ALLOW(0000, 放行执行后续的流程不受规则引擎影响), TAKE_OVER(0001, 接管后续的流程受规则引擎执行结果影响), ; private final String code; private final String info; }-----------------------------------------分割线-------------------------------------------------if (DefaultLogicFactory.LogicModel.RULE_BLACKLIST.getCode().equals(ruleActionEntity.getRuleModel())) { // 黑名单返回固定的奖品ID return RaffleAwardEntity.builder() .awardId(ruleActionEntity.getData().getAwardId()) .build(); }3.核心流程第三步进行黑名单过滤这里涉及到了规则工厂的事情了这里面的代码看着很复杂还涉及到了注解其实不要想复杂了这个工厂的核心作用是映射我们创建了一个注解LogicStrategy这个注解专门标记规则的实现类标记后让Spring放到容器里面这个工厂就是将容器中的规则过滤实现类整理到一个map中比如黑名单和权重规则。那么显然的当命中了黑名单规则我们就写死一个奖品返回给用户。//规则工厂 Service public class DefaultLogicFactory { public MapString, ILogicFilter? logicFilterMap new ConcurrentHashMap(); public DefaultLogicFactory(ListILogicFilter? logicFilters) { logicFilters.forEach(logic - { LogicStrategy strategy AnnotationUtils.findAnnotation(logic.getClass(), LogicStrategy.class); if (null ! strategy) { logicFilterMap.put(strategy.logicMode().getCode(), logic); } }); } public T extends RuleActionEntity.RaffleEntity MapString, ILogicFilterT openLogicFilter() { return (MapString, ILogicFilterT) (Map?, ?) logicFilterMap; } Getter AllArgsConstructor public enum LogicModel { RULE_WIGHT(rule_weight,【抽奖前规则】根据抽奖权重返回可抽奖范围KEY), RULE_BLACKLIST(rule_blacklist,【抽奖前规则】黑名单规则过滤命中黑名单则直接返回), ; private final String code; private final String info; } }//策略自定义枚举 Target({ElementType.TYPE}) Retention(RetentionPolicy.RUNTIME) public interface LogicStrategy { DefaultLogicFactory.LogicModel logicMode(); }-----------------------------------------分割线-----------------------------------------------else if (DefaultLogicFactory.LogicModel.RULE_WIGHT.getCode().equals(ruleActionEntity.getRuleModel())) { // 权重根据返回的信息进行抽奖 RuleActionEntity.RaffleBeforeEntity raffleBeforeEntity ruleActionEntity.getData(); String ruleWeightValueKey raffleBeforeEntity.getRuleWeightValueKey(); Integer awardId strategyDispatch.getRandomAwardId(strategyId, ruleWeightValueKey); return RaffleAwardEntity.builder() .awardId(awardId) .build(); }4.核心流程第四步权重规则过滤这里比较好理解就是拿到指定权重的权重值比如4000:101,102,103然后调用前面一节课的权重概率装配获取权重配置中的随机奖品最后返回给用户。-----------------------------------------分割线-----------------------------------------------最后就是规则都没有被命中就直接走默认的抽奖流程了很好理解。// 4. 默认抽奖流程 Integer awardId strategyDispatch.getRandomAwardId(strategyId); return RaffleAwardEntity.builder() .awardId(awardId) .build();别忘了在核心类里面还有一个方法这个方法我们放下一个板块讲protected abstract RuleActionEntityRuleActionEntity.RaffleBeforeEntity doCheckRaffleBeforeLogic(RaffleFactorEntity raffleFactorEntity, String... logics);三、规则过滤的实现类1.核心子类DefaultRaffleStrategy接下来的两个类就是刚刚提到的被注解标记的过滤规则的实现类了你可能会有疑惑我怎么感觉没用到这个实现类呢其实是因为我们还没有讲刚刚提到的doCheckRaffleBeforeLogic()方法这个方法是protected的也就是是供子类重写的所以我们真正执行这个流程的不是刚刚的核心抽象类而是核心抽象类的子类——DefaultRaffleStrategy 。Service Slf4j public class DefaultRaffleStrategy extends AbstractRaffleStrategy{ Resource private DefaultLogicFactory logicFactory; public DefaultRaffleStrategy(IStrategyRepository repository, IStrategyDispatch strategyDispatch) { super(repository, strategyDispatch); } Override protected RuleActionEntityRuleActionEntity.RaffleBeforeEntity doCheckRaffleBeforeLogic(RaffleFactorEntity raffleFactorEntity, String... logics) { MapString, ILogicFilterRuleActionEntity.RaffleBeforeEntity logicFilterGroup logicFactory.openLogicFilter(); // 黑名单规则优先过滤 String ruleBackList Arrays.stream(logics) .filter(str - str.contains(DefaultLogicFactory.LogicModel.RULE_BLACKLIST.getCode())) .findFirst() .orElse(null); if (StringUtils.isNotBlank(ruleBackList)) { ILogicFilterRuleActionEntity.RaffleBeforeEntity logicFilter logicFilterGroup.get(DefaultLogicFactory.LogicModel.RULE_BLACKLIST.getCode()); RuleMatterEntity ruleMatterEntity new RuleMatterEntity(); ruleMatterEntity.setUserId(raffleFactorEntity.getUserId()); ruleMatterEntity.setAwardId(ruleMatterEntity.getAwardId()); ruleMatterEntity.setStrategyId(raffleFactorEntity.getStrategyId()); ruleMatterEntity.setRuleModel(DefaultLogicFactory.LogicModel.RULE_BLACKLIST.getCode()); RuleActionEntityRuleActionEntity.RaffleBeforeEntity ruleActionEntity logicFilter.filter(ruleMatterEntity); if (!RuleLogicCheckTypeVO.ALLOW.getCode().equals(ruleActionEntity.getCode())) { return ruleActionEntity; } } // 顺序过滤剩余规则 ListString ruleList Arrays.stream(logics) .filter(s - !s.equals(DefaultLogicFactory.LogicModel.RULE_BLACKLIST.getCode())) .collect(Collectors.toList()); RuleActionEntityRuleActionEntity.RaffleBeforeEntity ruleActionEntity null; for (String ruleModel : ruleList) { ILogicFilterRuleActionEntity.RaffleBeforeEntity logicFilter logicFilterGroup.get(ruleModel); RuleMatterEntity ruleMatterEntity new RuleMatterEntity(); ruleMatterEntity.setUserId(raffleFactorEntity.getUserId()); ruleMatterEntity.setAwardId(ruleMatterEntity.getAwardId()); ruleMatterEntity.setStrategyId(raffleFactorEntity.getStrategyId()); ruleMatterEntity.setRuleModel(ruleModel); ruleActionEntity logicFilter.filter(ruleMatterEntity); // 非放行结果则顺序过滤 log.info(抽奖前规则过滤 userId: {} ruleModel: {} code: {} info: {}, raffleFactorEntity.getUserId(), ruleModel, ruleActionEntity.getCode(), ruleActionEntity.getInfo()); if (!RuleLogicCheckTypeVO.ALLOW.getCode().equals(ruleActionEntity.getCode())) return ruleActionEntity; } return ruleActionEntity; } }这里面就可以很容易地看到它实现了doCheckRaffleBeforeLogic()方法这里面就把刚刚注解那里讲的——被Spring放到容器中的实现类map给取出来了取出来了然后就可以按照优先级顺序处理了。两个规则过滤实现类如下2.黑名单过滤规则实现类/** * author 印东升 * description 【抽奖前规则】黑名单用户过滤规则 * create 2026-04-10 11:53 */ Slf4j Component LogicStrategy(logicMode DefaultLogicFactory.LogicModel.RULE_BLACKLIST) public class RuleBlackListLogicFilter implements ILogicFilterRuleActionEntity.RaffleBeforeEntity { Resource private IStrategyRepository repository; Override public RuleActionEntityRuleActionEntity.RaffleBeforeEntity filter(RuleMatterEntity ruleMatterEntity) { log.info(规则过滤-黑名单 userId:{} strategyId:{} ruleModel:{}, ruleMatterEntity.getUserId(), ruleMatterEntity.getStrategyId(), ruleMatterEntity.getRuleModel()); String userId ruleMatterEntity.getUserId(); String ruleValue repository.queryStrategyRuleValue(ruleMatterEntity.getStrategyId(),ruleMatterEntity.getAwardId(),ruleMatterEntity.getRuleModel()); String[] splitRuleValue ruleValue.split(Constants.COLON); Integer awardId Integer.parseInt(splitRuleValue[0]); //100:user001,user002,user003 // 过滤其他规则 String[] userBlackIds splitRuleValue[1].split(Constants.SPLIT); for (String userBlackId : userBlackIds) { if (userId.equals(userBlackId)) { return RuleActionEntity.RuleActionEntity.RaffleBeforeEntitybuilder() .ruleModel(DefaultLogicFactory.LogicModel.RULE_BLACKLIST.getCode()) .data(RuleActionEntity.RaffleBeforeEntity.builder() .strategyId(ruleMatterEntity.getStrategyId()) .awardId(awardId) .build()) .code(RuleLogicCheckTypeVO.TAKE_OVER.getCode()) .info(RuleLogicCheckTypeVO.TAKE_OVER.getInfo()) .build(); } } return RuleActionEntity.RuleActionEntity.RaffleBeforeEntitybuilder() .code(RuleLogicCheckTypeVO.ALLOW.getCode()) .info(RuleLogicCheckTypeVO.ALLOW.getInfo()) .build(); } }3.权重过滤规则的实现类/** * author 印东升 * description 【抽奖前规则】根据抽奖权重返回可抽奖范围KEY * create 2026-04-10 12:30 */ Slf4j Component LogicStrategy(logicMode DefaultLogicFactory.LogicModel.RULE_WIGHT) public class RuleWeightLogicFilter implements ILogicFilterRuleActionEntity.RaffleBeforeEntity { Resource private IStrategyRepository repository; private Long userScore 4500L; /** * 权重规则过滤 * 1. 权重规则格式4000:102,103,104,105 5000:102,103,104,105,106,107 6000:102,103,104,105,106,107,108,109 * 2. 解析数据格式判断哪个范围符合用户的特定抽奖范围 * * param ruleMatterEntity 规则物料实体对象 * return 规则过滤结果 */ Override public RuleActionEntityRuleActionEntity.RaffleBeforeEntity filter(RuleMatterEntity ruleMatterEntity) { log.info(规则过滤-权重范围 userId:{} strategyId:{} ruleModel:{}, ruleMatterEntity.getUserId(), ruleMatterEntity.getStrategyId(), ruleMatterEntity.getRuleModel()); //查询表中的规则值比如4000:102,103,104,105 String userId ruleMatterEntity.getUserId(); Long strategyId ruleMatterEntity.getStrategyId(); String ruleValue repository.queryStrategyRuleValue(ruleMatterEntity.getStrategyId(), ruleMatterEntity.getAwardId(), ruleMatterEntity.getRuleModel()); // 1. 根据用户ID查询用户抽奖消耗的积分值本章节我们先写死为固定的值。后续需要从数据库中查询。 MapLong, String analyticalValueGroup getAnalyticalValue(ruleValue); if (null analyticalValueGroup || analyticalValueGroup.isEmpty()) { return RuleActionEntity.RuleActionEntity.RaffleBeforeEntitybuilder() .code(RuleLogicCheckTypeVO.ALLOW.getCode()) .info(RuleLogicCheckTypeVO.ALLOW.getInfo()) .build(); } // 2. 转换Keys值并默认排序 ListLong analyticalSortedKeys new ArrayList(analyticalValueGroup.keySet()); Collections.sort(analyticalSortedKeys); // 3. 找出最小符合的值也就是【4500 积分能找到 4000:102,103,104,105】、【5000 积分能找到 5000:102,103,104,105,106,107】 Long nextValue analyticalSortedKeys.stream() .filter(key - userScore key) .findFirst() .orElse(null); if (null ! nextValue) { return RuleActionEntity.RuleActionEntity.RaffleBeforeEntitybuilder() .data(RuleActionEntity.RaffleBeforeEntity.builder() .strategyId(strategyId) .ruleWeightValueKey(analyticalValueGroup.get(nextValue)) .build()) .ruleModel(DefaultLogicFactory.LogicModel.RULE_WIGHT.getCode()) .code(RuleLogicCheckTypeVO.TAKE_OVER.getCode()) .info(RuleLogicCheckTypeVO.TAKE_OVER.getInfo()) .build(); } return RuleActionEntity.RuleActionEntity.RaffleBeforeEntitybuilder() .code(RuleLogicCheckTypeVO.ALLOW.getCode()) .info(RuleLogicCheckTypeVO.ALLOW.getInfo()) .build(); } private MapLong, String getAnalyticalValue(String ruleValue) { String[] ruleValueGroups ruleValue.split(Constants.SPACE); MapLong, String ruleValueMap new HashMap(); for (String ruleValueKey : ruleValueGroups) { // 检查输入是否为空 if (ruleValueKey null || ruleValueKey.isEmpty()) { return ruleValueMap; } // 分割字符串以获取键和值 String[] parts ruleValueKey.split(Constants.COLON); if (parts.length ! 2) { throw new IllegalArgumentException(rule_weight rule_rule invalid input format ruleValueKey); } ruleValueMap.put(Long.parseLong(parts[0]), ruleValueKey); } return ruleValueMap; } }四、测试注意哈我们刚刚的大抽象类是实现了IRaffleStrategy接口的哦所以它的子类也是实现了的这就是专门为了后续直接调用接口来实现整个规则过滤业务面向接口编程。这里注入这个接口实际上是注入了子类也就是那个完整实现了doCheckRaffleBeforeLogic和performRaffle的DefaultRaffleStrategy 。public interface IRaffleStrategy { RaffleAwardEntity performRaffle(RaffleFactorEntity raffleFactorEntity); }//抽奖策略测试 Slf4j RunWith(SpringRunner.class) SpringBootTest public class RaffleStrategyTest { Resource private IRaffleStrategy raffleStrategy; Resource private RuleWeightLogicFilter ruleWeightLogicFilter; Before public void setUp() { ReflectionTestUtils.setField(ruleWeightLogicFilter, userScore, 4050L); } Test public void test_performRaffle() { RaffleFactorEntity raffleFactorEntity RaffleFactorEntity.builder() .userId(yds) .strategyId(100001L) .build(); RaffleAwardEntity raffleAwardEntity raffleStrategy.performRaffle(raffleFactorEntity); log.info(请求参数{}, JSON.toJSONString(raffleFactorEntity)); log.info(测试结果{}, JSON.toJSONString(raffleAwardEntity)); } Test public void test_performRaffle_blacklist() { RaffleFactorEntity raffleFactorEntity RaffleFactorEntity.builder() .userId(user003) // 黑名单用户 user001,user002,user003 .strategyId(100001L) .build(); RaffleAwardEntity raffleAwardEntity raffleStrategy.performRaffle(raffleFactorEntity); log.info(请求参数{}, JSON.toJSONString(raffleFactorEntity)); log.info(测试结果{}, JSON.toJSONString(raffleAwardEntity)); } }测试结果如下五、本节的设计模式1.模板方法模式读到这里你可能会有一些疑惑比如我们在其他地方都是使用的DefaultRaffleStrategy这个流程子类那为啥不把AbstructRaffleStrategy中的performRaffle()直接写到DefaultRaffleStrategy中呢答这是一种设计模式——模板方法模式定义在一个方法中定义一个算法的骨架将某些步骤延迟到子类中实现。子类可以在不改变算法结构的情况下重新定义算法的某些特定步骤。这里我们将doCheckRaffleBeforeLogic()方法延迟到子类中实现但是在父类中的performRaffle()方法中使用doCheckRaffleBeforeLogic()方法是用于规定规则过滤的顺序的如果后续我们想改变这个顺序或者想用另外一个顺序那就直接更改子类或者创建一个新子类重写新顺序方法即可而不会去动父类的骨架。优点1.代码复用AbstructRaffleStrategy抽象类中的骨架方法是每个过滤流程必定要走的并且是固定的。2.反向控制父类控制流程在合适的时候调用子类的方法3.防止子类破坏算法结构确保所有子类的抽奖流程都遵循相同的步骤顺序。另外围绕模板方法模式补充模板方法模式中包含了三种方法1.模板方法——我们代码中的performRaffle()2.抽象方法——我们代码中的doCheckRaffleBeforeLogic()3.钩子方法——在我们的代码中没有体现其实就是抽象模板类里面的非抽象方法子类不一定要实现但是可以选择性重写。用钩子把自定义的逻辑挂到子类上去2.工厂模式显然的我们这一节中的工厂就是DefaultLogicFactory规则工厂了。这个工厂的作用体现在将被注解标记的过滤实现类整理到一个map中所以这个工厂制造的就是这个map对象供我们在流程类DefaultRaffleStrategy中调用。好处解耦对象的创建和使用我们不需要自己去拿这两个过滤实现类了而是统一地在工厂中拿生产好的map。3.策略模式策略模式的核心思想是定义一系列算法将每个算法封装起来让它们可以互相替换。在我们的项目中的ILogicFilter是策略模式的体现我们的两个过滤实现类黑名单和权重都实现了ILogicFilter接口在流程类DefaultRaffleStrategy的doCheckRaffleBeforeLogic()方法中我们获取了工厂生产的map然后从map中分别拿出了这两种策略根据策略名的key。这里就符合策略模式的核心思想了我们将每种规则过滤的实现类都封装起来了然后放进一个map中在处理不同的过滤规则时分别被调用相当于替换策略。ILogicFilterRuleActionEntity.RaffleBeforeEntity logicFilter logicFilterGroup.get(DefaultLogicFactory.LogicModel.RULE_BLACKLIST.getCode()); ILogicFilterRuleActionEntity.RaffleBeforeEntity logicFilter logicFilterGroup.get(ruleModel);所以事实上这里是也是工厂模式和策略模式的混合运用。六、总结这种业务极度复杂的项目真的太难啃了我觉得按照“找核心”的方式去剖析才能理清楚关系这一节其实是很开阔眼界的当然我认为这里面最厉害的还是那个抽象类之所以认为它是核心就是因为它起到了承上启下的作用上承工厂、接口下启子类、注解实现类它本身又是设计模式中模板方法模式的体现。其实我觉得这一节的具体实现逻辑我后面很快就会忘但是这样的业务结构非常值得去深度理解确实是大开眼界了。