策略模式+模板方法的使用

之前了解策略模式，都是看的一些理论知识然后敲了一些小demo。比如，

定义：

定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化不会影响到使用算法的用户

处理掉if…else…

类型：行为型

适用场景

系统有很多类，而他们的区别仅仅在于他们的行为不同
一个系统需要动态地在几种算法中选择一种
优点
开闭原则
避免使用多重条件转移语句
提高算法的保密性和安全性
缺点
客户端必须知道所有的策略类，并自行决定用哪一个策略类
产生很多策略类

小demo

策略模式，为了解决应用层的判断，再加上工厂模式

public interface PromotionStrategy {
    void doPromotion();
}

返现类

public class FanXianPromotionStrategy implements PromotionStrategy{
    @Override
    public void doPromotion() {
        System.out.println("返现促销,返回的金额存放到慕课网用户的余额中");
    }
}

立减类

public class LiJianPromotionStrategy implements PromotionStrategy {
    @Override
    public void doPromotion() {
        System.out.println("立减促销,课程的价格直接减去配置的价格");
    }
}

无促销类

public class EmptyPromotionStrategy implements PromotionStrategy {
    @Override
    public void doPromotion() {
        System.out.println("无促销");
    }
}

工厂模式

public class PromotionStrategyFactory {
 
    private static Map<String,PromotionStrategy> PROMOTION_STRATEGY_MAP=new HashMap<String, PromotionStrategy>();
 
    static {
        PROMOTION_STRATEGY_MAP.put(PromotionKey.LIJIAN,new LiJianPromotionStrategy());
        PROMOTION_STRATEGY_MAP.put(PromotionKey.FANXIAN,new FanXianPromotionStrategy());
        PROMOTION_STRATEGY_MAP.put(PromotionKey.MANJIAN,new ManJianPromotionStrategy());
    }
 
    private static final PromotionStrategy NON_PROMOTION=new EmptyPromotionStrategy();
 
    private PromotionStrategyFactory(){
 
    }
 
    public static PromotionStrategy getPromotionStrategy(String promotionType){
        PromotionStrategy promotionStrategy=PROMOTION_STRATEGY_MAP.get(promotionType);
        return promotionStrategy==null?NON_PROMOTION:promotionStrategy;
    }
 
    private interface PromotionKey{
        String LIJIAN="LIJIAN";
        String FANXIAN="FANXIAN";
        String MANJIAN="MANJIAN";
    }

main 方法

public static void main(String[] args) {
    String promotionKey="LIJIAN";
    PromotionActivity promotionActivity=new PromotionActivity(PromotionStrategyFactory.getPromotionStrategy(promotionKey));
    promotionActivity.executePromotionStrategy();
}

现在工作中也遇到了其中的一种情况，有3个特别类似的界面，之前的代码写的是if else if else 这样的一坨，对于我们有要求的程序员来说肯定是无法接受的。

先说一下大体思路吧，

1.一个接口，

2.一个抽象类实现这个接口，里面有几个抽象方法，（抽象方法是三个页面不同地方的实现）和几个私有方法，（相同的地方）

3.三个具体的实现类，继承这个抽象类，

大家看到这可能会有些疑惑，为什么会有这个抽象类，本来也是可以没有这个抽象类的，那怎么实现呢？就是每个不同的页面实现不同的逻辑呗，各自一套代码，前提都说了，这三个页面大体是一样的，这样代码不就太重复了嘛。所以这个时候就用到了模板方法了。将相同的方法封装在一起。

接下来就是激动人心的时刻了，代码来了。

接口类

public interface QueryService {

    ResponseObj<List<OrderResponse>> list(PageRequest request);
}

抽象类

public abstract class AbstractQueryService implements QueryService {
  
    @Override
    public ResponseObj<List<OrderResponse>> list(PageRequest request) {
      // 1.构造查询之前query对象
   	ResponseObj<List<OrderResponse>> responseObj = handlerBeforeQuery(query);
      // 2.构造查询对象
      List<OrderBO> list = query(query);
      // 3.构造共同的代码
              List<OrderResponse> responseList = buildQueryResponse(orderBOList, false);
      // 4.构造共同的代码。。。私有方法
 
    }

    // 抽象方法
    protected abstract ResponseObj<List<OrderResponse>> handlerBeforeQuery(Query query);
    // 抽象方法
      protected abstract List<OrderBO> query(Query query);
    // 私有方法
      private List<OrderResponse> buildQueryResponse() {}

}

具体类

里面是抽象方法，那么怎么保证不同的页面查询不同的逻辑呢

@Service("oneService")
public class OneService extends AbstractQueryService {
}

配置

    
   // 实例化
		@Autowired
    private Map<String, QueryService> queryServiceMap;		

	/** 页面一 */
    public static final String ONE_QUERY = "oneService";
    /** 页面二 */
    public static final String TWO_QUERY = "twoService";
    /** 页面三 */
    public static final String THREE_QUERY = "threeService";

      // 页面获取
    public ResponseObj<List<OrderResponse>> listChannelOrder(@RequestBody PageRequest request) {
              return queryServiceMap.get(ONE_QUERY).list(request);
          }

鉴于代码私密性，只能写个大概。