营销系统是一个动态的、有机地结合的系统，经常会随着业务的不断变化发生调整，因此从事这一业务的开发可让我头疼了。

之前在工作中就不乏一次遇到过随意调整营销策略的情况，在部分场景下由于使用了硬编码的方式来实现，因此在调整策略的时候显得特别不灵活。

下边我列举一个曾经遇到过的应用场景：

业务部门需要上线一款新型的产品，用户在线上购买了对应的产品，然后下单支付之后需要享受不同的服务内容，这些服务包含了赠送优惠券，发送红包补贴，加积分，升级等服务项。并且上线之后，可能会随着市场的因素的调整，部分服务内容也会有所下架，后期调整因素极高。

下边是一张用户建模的图：

策略模式在公司项目中的运用实践，看完又可以涨一波实战经验了！

线上买单，到选择购买的产品类型，再到后续下单之后执行不同的营销规则，每个产品对应不同的服务项目并且服务项目的内容还可能会随时调整。

举个实际案例来说，线上有这么几款服务产品供消费者选购：

1.999元会员套餐

  • 正常会员服务期1个月

  • 发放5张优惠券

2.1999元会员套餐

  • 正常会员服务期2个月

  • 发放6张优惠券

  • 邀请新人加入app，新人在n天内购买套餐有优惠

3.2999元会员套餐

  • 正常会员服务期3个月

  • 发放7张优惠券

  • 满2500元消费，返现50元红包

….
大致看看，不同的产品对应不同的促销规则，似乎毫无规律可言。

但是如果通过抽象的逻辑将其中的共同部分抽取出来，就会发现其实是有规则可循了。

下边我给出来一段 “不那么完整的代码案例” （关于这种营销手段的设计核心在于思路，没有完美的代码，只有不断精进的设计）

这段代码主要采用来策略模式的设计思路，不同的产品对应不同的策略，产品和策略之间的关联可以通过使用数据库的方式来做绑定。

首先可以将每个服务项目看作是一条营销的规则手段，因此我定义来一个marketing对象：

  1. /**
  2.  * 营销对象实体类
  3.  *
  4.  * @Author idea
  5.  * @Date created in 9:39 上午 2020/5/4
  6.  */
  7. @NoArgsConstructor
  8. @Data
  9. @Builder
  10. @AllArgsConstructor
  11. public class MarketingPO {
  13.     /**
  14.      * 主键id
  15.      */
  16.     private Integer id;
  18.     /**
  19.      * 营销手段名称 存储class的名称
  20.      */
  21.     private String marketingName;
  23.     /**
  24.      * 入参 多个可以逗号分割
  25.      */
  26.     private String inputVal;
  28.     /**
  29.      * 描述
  30.      */
  31.     private String des;
  33.     /**
  34.      * 创建时间
  35.      */
  36.     private Date createTime;
  38.     /**
  39.      * 更新时间
  40.      */
  41.     private Date updateTime;
  45. }

 

接着便是产品和不同营销手段之间做关联

  1. /**
  2.  * 通过产品id和营销手段做关联
  3.  *
  4.  * @Author idea
  5.  * @Date created in 3:37 下午 2020/5/4
  6.  */
  7. @Data
  8. @Builder
  9. @AllArgsConstructor
  10. @NoArgsConstructor
  11. public class MarketingProductPO {
  13.     /**
  14.      * 主键id
  15.      */
  16.     private Integer id;
  18.     /**
  19.      * 营销工具id
  20.      */
  21.     private Integer marketingId;
  23.     /**
  24.      * 产品编号
  25.      */
  26.     private String productNo;
  28.     /**
  29.      * 描述
  30.      */
  31.     private String des;
  33.     /**
  34.      * 是否有效
  35.      */
  36.     private Integer validStatus;
  38.     /**
  39.      * 创建时间
  40.      */
  41.     private Date createTime;
  43.     /**
  44.      * 更新时间
  45.      */
  46.     private Date updateTime;
  47. }

 

接着是dao层的部分，不过这里我简单化地将持久层逻辑写在来代码里面，只做参考：

  1. /**
  2.  * 模拟dao层操作
  3.  *
  4.  * @Author idea
  5.  * @Date created in 10:20 上午 2020/5/4
  6.  */
  7. @Repository
  8. public class MarketingDao implements IMarketingDao {
  10.     private static List<MarketingPO> MARKETING_LIST = new ArrayList();
  12.     static {
  13.         MarketingPO disCountMarket = MarketingPO.builder()
  14.                 .id(1).marketingName("com.sise.idea.present.impl.DiscountStrategy").des("折扣优惠").inputVal("7").build();
  15.         MarketingPO redPacketMarket = MarketingPO.builder()
  16.                 .id(2).marketingName("com.sise.idea.present.impl.RedPacketStrategy").des("红包优惠").inputVal("8").build();
  17.         MarketingPO newMemberCouponMarket = MarketingPO.builder()
  18.                 .id(3).marketingName("com.sise.idea.present.impl.NewMemberCouponStrategy").des("新人优惠券发送").inputVal("10").build();
  19.         MARKETING_LIST.add(newMemberCouponMarket);
  20.         MARKETING_LIST.add(disCountMarket);
  21.         MARKETING_LIST.add(redPacketMarket);
  22.     }
  24.     @Override
  25.     public List<MarketingPO> selectMarketingByIds(List<Integer> idList) {
  26.         List<MarketingPO> marketingPOS = new ArrayList<>(idList.size());
  27.         for (MarketingPO marketingPO : MARKETING_LIST) {
  28.             if (idList.contains(marketingPO.getId())) {
  29.                 marketingPOS.add(marketingPO);
  30.             }
  31.         }
  32.         return marketingPOS;
  33.     }
  34. }
  1. /**
  2.  * @Author idea
  3.  * @Date created in 3:45 下午 2020/5/4
  4.  */
  5. @Repository
  6. public class MarketingProductDao implements IMarketingProductDao {
  8.     private static List<MarketingProductPO> MARKET_PRODUCT_LIST = new ArrayList<>();
  10.     static {
  11.         MarketingProductPO marketingProductPO = MarketingProductPO.builder()
  12.                 .productNo("p111")
  13.                 .marketingId(2)
  14.                 .validStatus(1)
  15.                 .des("2999套餐-发放优惠券")
  16.                 .build();
  17.         MarketingProductPO marketingProductPO2 = MarketingProductPO.builder()
  18.                 .productNo("p111")
  19.                 .marketingId(3)
  20.                 .validStatus(1)
  21.                 .des("2999套餐-满额红包返现")
  22.                 .build();
  24.         MARKET_PRODUCT_LIST.add(marketingProductPO);
  25.         MARKET_PRODUCT_LIST.add(marketingProductPO2);
  26.     }
  28.     @Override
  29.     public List<MarketingProductPO> selectByProductNo(String productNo) {
  30.         List<MarketingProductPO> marketingProductPOS = new ArrayList<>();
  31.         for (MarketingProductPO marketingProductPO : MARKET_PRODUCT_LIST) {
  32.             //产品编码一致 而且规则有效
  33.             if(marketingProductPO.getProductNo().equals(productNo) && marketingProductPO.getValidStatus()==1){
  34.                 marketingProductPOS.add(marketingProductPO);
  35.             }
  36.         }
  37.         return marketingProductPOS;
  38.     }
  39. }

 

接着便是对所有的营销手段都做了一层统一的封装和抽象：

  1. package com.sise.策略模式.present;
  3. /**
  4.  * 关于营销手段的策略
  5.  *
  6.  * @Author idea
  7.  * @Date created in 9:20 上午 2020/5/4
  8.  */
  9. public interface IMarketingStrategy {
  11.     /**
  12.      * 服务赠送的策略执行
  13.      *
  14.      * @param param 参数
  15.      * @return
  16.      */
  17.     boolean doMarketing(Object ...param);
  18. }

 

接下来便是不同的营销手段对应不同的实现，这里面我简单做了一些实现：

  1. @Service
  2. public class RedPacketStrategy implements IMarketingStrategy {
  4.     @Override
  5.     public boolean doMarketing(Object... param) {
  6.         System.out.println("红包赠送策略");
  7.         return false;
  8.     }
  9. }
  11. @Service
  12. public class DiscountStrategy implements IMarketingStrategy {
  14.     @Override
  15.     public boolean doMarketing(Object... param) {
  16.         System.out.println("打折优惠");
  17.         return false;
  18.     }
  19. }
  21. @Service
  22. public class NewMemberCouponStrategy implements IMarketingStrategy {
  24.     @Override
  25.     public boolean doMarketing(Object... param) {
  26.         System.out.println("新人赠送策略");
  27.         return false;
  28.     }
  29. }
  31. @Service
  32. public class UpgradeStrategy implements IMarketingStrategy {
  34.     @Override
  35.     public boolean doMarketing(Object... param) {
  36.         System.out.println("升级策略");
  37.         return false;
  38.     }
  39. }

 

既然有了不同营销手段的具体实现方式，那么对于购买不同的产品也需要查询到不同的营销手段，这个时候就需要有一个转换中间者的角色出现了：

  1. /**
  2.  * 营销工具核心执行器
  3.  *
  4.  * @Author idea
  5.  * @Date created in 9:34 上午 2020/5/4
  6.  */
  7. public interface IMarketingCoreService {
  9.     /**
  10.      * 执行不同的营销工具
  11.      *
  12.      * @param productNo 产品编码
  13.      * @return
  14.      */
  15.     boolean doMarketingJob(String productNo) throws Exception;
  16. }
  19. /**
  20.  * 营销工具核心执行器
  21.  *
  22.  * @Author idea
  23.  * @Date created in 9:34 上午 2020/5/4
  24.  */
  25. @Service
  26. public class MarketingCoreService implements IMarketingCoreService {
  28.     @Resource
  29.     private IMarketingDao iMarketingDao;
  31.     @Resource
  32.     private IMarketingProductDao iMarketingProductDao;
  34.     @Resource
  35.     private ApplicationContext applicationContext;
  37.     @Override
  38.     public boolean doMarketingJob(String productNo) throws ClassNotFoundException {
  39.         System.out.println("doMarketingJob begin =============");
  40.         System.out.println(productNo);
  41.         List<MarketingProductPO> marketingProductPOS = iMarketingProductDao.selectByProductNo(productNo);
  42.         if (marketingProductPOS != null) {
  43.             List<Integer> marketingIdList = marketingProductPOS.stream().map(MarketingProductPO::getMarketingId).collect(Collectors.toList());
  44.             List<MarketingPO> marketingPOS = iMarketingDao.selectMarketingByIds(marketingIdList);
  45.             for (MarketingPO marketingPO : marketingPOS) {
  46.                 String marketingName = marketingPO.getMarketingName();
  47.                 Class<?> clazz = Class.forName(marketingName);
  48.                 IMarketingStrategy marketingStrategy = (IMarketingStrategy) applicationContext.getBean(clazz);
  49.                 marketingStrategy.doMarketing(marketingPO.getInputVal());
  50.             }
  51.             System.out.println("doMarketingJob end =============");
  52.             return true;
  53.         }
  54.         System.out.println("doMarketingJob setting is empty ===========");
  55.         return false;
  56.     }
  57. }

 

具体的思路就和策略模式有点类似：

策略模式

模式定义：定义一系列算法，将每个算法都封装起来，并且它们可以互换。策略模式是一种对象行为模式。

例如下图：

策略模式在公司项目中的运用实践，看完又可以涨一波实战经验了！

最后为了方便测试，我在工程里面引入了spring-context的依赖：

  1.  <!-- 关于spring的核型模块代码       -->
  2.         <dependency>
  3.             <groupId>org.springframework</groupId>
  4.             <artifactId>spring-context</artifactId>
  5.             <version>5.0.1.RELEASE</version>
  6.         </dependency>

 

测试的入口代码：

  1. /**
  2.  * @Author idea
  3.  * @Date created in 10:14 上午 2020/5/4
  4.  */
  5. public class ApplicationDemo {
  7.     public static void main(String[] args) throws Exception {
  8.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
  9.         applicationContext.scan("com.sise.idea.present");
  10.         //启动上下文
  11.         applicationContext.refresh();
  12.         IMarketingCoreService marketingCoreService = applicationContext.getBean(MarketingCoreService.class);
  13.         marketingCoreService.doMarketingJob("p111");
  14.     }
  15. }

 

最后根据规则，通过产品编码来搜索到指定的营销手段，并执行对应的程序逻辑：

策略模式在公司项目中的运用实践，看完又可以涨一波实战经验了！

文章上边我曾经提及过，没有完美点代码，只有随着业务需求不断变化的设计思路，因此在真正落地整套营销系统的时候，还需要额外考虑很多的要素。例如说目前的这种设计只能满足于针对单个产品层面，如果以后有出现针对完整订单层面（例如说总支付订单满xxx元，享受xxx优惠）的还需要额外去思考，加上不同的营销手段之间是否有出现互斥的场景都是会有可能遇到的情况。

设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。文中我并没有过多地去讲解什么是xx模式，但是当通过某种较为灵活的方式来实现某样功能时，可能就已经使用了设计模式。

https://gitee.com/IdeaHome_admin/design_pattern/tree/master/design-model/src/main/java/com/sise/%E7%AD%96%E7%95%A5%E6%A8%A1%E5%BC%8F/present

END

Java面试题专栏

【61期】MySQL行锁和表锁的含义及区别（MySQL面试第四弹）
【62期】解释一下MySQL中内连接，外连接等的区别（MySQL面试第五弹）
【63期】谈谈MySQL 索引，B+树原理，以及建索引的几大原则（MySQL面试第六弹）
【64期】MySQL 服务占用cpu 100%，如何排查问题? （MySQL面试第七弹）
【65期】Spring的IOC是啥?有什么好处?
【66期】Java容器面试题：谈谈你对 HashMap 的理解
【67期】谈谈ConcurrentHashMap是如何保证线程安全的？
【68期】面试官：对并发熟悉吗？说说Synchronized及实现原理
【69期】面试官：对并发熟悉吗？谈谈线程间的协作(wait/notify/sleep/yield/join)
【70期】面试官：对并发熟悉吗？谈谈对volatile的使用及其原理

版权声明：本文为javazhiyin原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/javazhiyin/p/12840885.html