学习一策略模式(strategy)

在阎宏博士的《JAVA与模式》一书中开头是这样描述策略(Strategy)模式的:

  策略模式属于对象的行为模式。其用意是针对一组算法,将每一个算法封装到具有共同接口的独立的类中,从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。


策略模式的结构

  策略模式是对算法的包装,是把使用算法的责任和算法本身分割开来,委派给不同的对象管理。策略模式通常把一个系列的算法包装到一系列的策略类里面,作为一个抽象策略类的子类。用一句话来说,就是:“准备一组算法,并将每一个算法封装起来,使得它们可以互换”。下面就以一个示意性的实现讲解策略模式实例的结构。

  这个模式涉及到三个角色:

  ●  环境(Context)角色:持有一个Strategy的引用。

  ●  抽象策略(Strategy)角色:这是一个抽象角色,通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。

  ●  具体策略(ConcreteStrategy)角色:包装了相关的算法或行为。

源代码

  环境角色类

复制代码
public class Context {
    //持有一个具体策略的对象
    private Strategy strategy;
    /**
     * 构造函数,传入一个具体策略对象
     * @param strategy    具体策略对象
     */
    public Context(Strategy strategy){
        this.strategy = strategy;
    }
    /**
     * 策略方法
     */
    public void contextInterface(){
        
        strategy.strategyInterface();
    }
    
}
复制代码

  抽象策略类

复制代码
public interface Strategy {
    /**
     * 策略方法
     */
    public void strategyInterface();
}
复制代码

  具体策略类

复制代码
public class ConcreteStrategyA implements Strategy {

    @Override
    public void strategyInterface() {
        //相关的业务
    }

}
复制代码
复制代码
public class ConcreteStrategyB implements Strategy {

    @Override
    public void strategyInterface() {
        //相关的业务
    }

}
复制代码
复制代码
public class ConcreteStrategyC implements Strategy {

    @Override
    public void strategyInterface() {
        //相关的业务
    }

}
复制代码

  

使用场景

  假设现在要设计一个贩卖各类书籍的电子商务网站的购物车系统。一个最简单的情况就是把所有货品的单价乘上数量,但是实际情况肯定比这要复杂。比如,本网站可能对所有的高级会员提供每本20%的促销折扣;对中级会员提供每本10%的促销折扣;对初级会员没有折扣。

  根据描述,折扣是根据以下的几个算法中的一个进行的:

  算法一:对初级会员没有折扣。

  算法二:对中级会员提供10%的促销折扣。

  算法三:对高级会员提供20%的促销折扣。

  使用策略模式来实现的结构图如下:

源代码

  抽象折扣类

复制代码
public interface MemberStrategy {
    /**
     * 计算图书的价格
     * @param booksPrice    图书的原价
     * @return    计算出打折后的价格
     */
    public double calcPrice(double booksPrice);
}
复制代码

  初级会员折扣类

复制代码
public class PrimaryMemberStrategy implements MemberStrategy {

    @Override
    public double calcPrice(double booksPrice) {
        
        System.out.println("对于初级会员的没有折扣");
        return booksPrice;
    }

}
复制代码

  中级会员折扣类

复制代码
public class IntermediateMemberStrategy implements MemberStrategy {

    @Override
    public double calcPrice(double booksPrice) {

        System.out.println("对于中级会员的折扣为10%");
        return booksPrice * 0.9;
    }

}
复制代码

  高级会员折扣类

复制代码
public class AdvancedMemberStrategy implements MemberStrategy {

    @Override
    public double calcPrice(double booksPrice) {
        
        System.out.println("对于高级会员的折扣为20%");
        return booksPrice * 0.8;
    }
}
复制代码

   价格类

复制代码
public class Price {
    //持有一个具体的策略对象
    private MemberStrategy strategy;
    /**
     * 构造函数,传入一个具体的策略对象
     * @param strategy    具体的策略对象
     */
    public Price(MemberStrategy strategy){
        this.strategy = strategy;
    }
    
    /**
     * 计算图书的价格
     * @param booksPrice    图书的原价
     * @return    计算出打折后的价格
     */
    public double quote(double booksPrice){
        return this.strategy.calcPrice(booksPrice);
    }
}
复制代码

  客户端

复制代码
public class Client {

    public static void main(String[] args) {
        //选择并创建需要使用的策略对象
        MemberStrategy strategy = new AdvancedMemberStrategy();
        //创建环境
        Price price = new Price(strategy);
        //计算价格
        double quote = price.quote(300);
        System.out.println("图书的最终价格为:" + quote);
    }

}
复制代码

   从上面的示例可以看出,策略模式仅仅封装算法,提供新的算法插入到已有系统中,以及老算法从系统中“退休”的方法,策略模式并不决定在何时使用何种算法。在什么情况下使用什么算法是由客户端决定的。

认识策略模式

  策略模式的重心

  策略模式的重心不是如何实现算法,而是如何组织、调用这些算法,从而让程序结构更灵活,具有更好的维护性和扩展性。

  算法的平等性

  策略模式一个很大的特点就是各个策略算法的平等性。对于一系列具体的策略算法,大家的地位是完全一样的,正因为这个平等性,才能实现算法之间可以相互替换。所有的策略算法在实现上也是相互独立的,相互之间是没有依赖的。

  所以可以这样描述这一系列策略算法:策略算法是相同行为的不同实现。

  运行时策略的唯一性

  运行期间,策略模式在每一个时刻只能使用一个具体的策略实现对象,虽然可以动态地在不同的策略实现中切换,但是同时只能使用一个。

  公有的行为

  经常见到的是,所有的具体策略类都有一些公有的行为。这时候,就应当把这些公有的行为放到共同的抽象策略角色Strategy类里面。当然这时候抽象策略角色必须要用Java抽象类实现,而不能使用接口。

  这其实也是典型的将代码向继承等级结构的上方集中的标准做法。

 

策略模式的优点

  (1)策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族。恰当使用继承可以把公共的代码移到父类里面,从而避免代码重复。

  (2)使用策略模式可以避免使用多重条件(if-else)语句。多重条件语句不易维护,它把采取哪一种算法或采取哪一种行为的逻辑与算法或行为的逻辑混合在一起,统统列在一个多重条件语句里面,比使用继承的办法还要原始和落后。

策略模式的缺点

  (1)客户端必须知道所有的策略类,并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别,以便适时选择恰当的算法类。换言之,策略模式只适用于客户端知道算法或行为的情况。

  (2)由于策略模式把每个具体的策略实现都单独封装成为类,如果备选的策略很多的话,那么对象的数目就会很可观。


策略模式在程序设计中也很常用,在板桥(banq)的博客里有篇文章叫 “你还在用if else吗?”
http://www.jdon.com/artichect/ifelse.htm”讲的很好,策略模式不但是继承的代替方案而且能很好地解决if else问题,下面举个实例来说明,怎么使用策略模式。

需求如下:

某支付系统接入以下几种商户进行充值:易宝网易,快线网银,19pay手机支付,支付宝支付,骏网一卡通,由于每家充值系统的结算比例不一样,而且同一家商户的不同充值方式也有所不同,具体系统情况比较复杂,像支付宝既有支付宝账号支付和支付宝网银支付等这些暂时不考虑,为了讲述策略模式这里简单描述,假如分为四种,手机支付,网银支付,商户账号支付和点卡支付。因为没个支付结算比例不同,所以对手续费低的做一些优惠活动,尽可能让用户使用手续费低的支付方式来充值,这样降低渠道费用,增加收入,具体优惠政策如下:

①网银充值,8.5折;

②商户充值,9折;

③手机充值,没有优惠;

④点卡充值,收取1%的渠道费;

对于一个新手的代码如下:

Java代码  收藏代码
  1. package strategy;  
  2.   
  3. public class Example {  
  4.   
  5.     /** 
  6.      *  
  7.      *作者:alaric 
  8.      *时间:2013-8-5上午11:00:06 
  9.      *描述:计算用户所付金额 
  10.      */  
  11.     public Double calRecharge(Double charge ,RechargeTypeEnum type ){  
  12.           
  13.         if(type.equals(RechargeTypeEnum.E_BANK)){  
  14.             return charge*0.85;  
  15.         }else if(type.equals(RechargeTypeEnum.BUSI_ACCOUNTS)){  
  16.             return charge*0.90;  
  17.         }else if(type.equals(RechargeTypeEnum.MOBILE)){  
  18.             return charge;  
  19.         }else if(type.equals(RechargeTypeEnum.CARD_RECHARGE)){  
  20.             return charge+charge*0.01;  
  21.         }else{  
  22.             return null;  
  23.         }  
  24.   
  25.     }  
  26.       
  27. }  

 

Java代码  收藏代码
  1. package strategy;  
  2.   
  3. public enum RechargeTypeEnum {  
  4.   
  5.     E_BANK(1"网银"),  
  6.       
  7.     BUSI_ACCOUNTS(2"商户账号"),  
  8.       
  9.     MOBILE(3,"手机卡充值"),  
  10.       
  11.     CARD_RECHARGE(4,"充值卡")  
  12.     ;  
  13.       
  14.     /** 
  15.      * 状态值 
  16.      */  
  17.     private int value;  
  18.       
  19.     /** 
  20.      * 类型描述 
  21.      */  
  22.     private String description;  
  23.       
  24.       
  25.       
  26.     private RechargeTypeEnum(int value, String description) {  
  27.         this.value = value;  
  28.         this.description = description;  
  29.     }  
  30.           
  31.     public int value() {  
  32.         return value;  
  33.     }  
  34.     public String description() {  
  35.         return description;  
  36.     }  
  37.       
  38.   
  39.     public static RechargeTypeEnum valueOf(int value) {  
  40.         for(RechargeTypeEnum type : RechargeTypeEnum.values()) {  
  41.             if(type.value() == value) {  
  42.                 return type;  
  43.             }  
  44.         }  
  45.         return null;   
  46.     }  
  47. }  

 可以看出上面四种不同的计算方式在一个方法内部,不利于扩展和维护,当然也不符合面向对象设计原则。对以上的代码利用策略模式进行修改,类图如下:

 


 实例代码如下:

 

Java代码  收藏代码
  1. package strategy.strategy;  
  2.   
  3. import strategy.RechargeTypeEnum;  
  4.   
  5. /** 
  6.  *  
  7.  *作者:alaric 
  8.  *时间:2013-8-5上午11:03:17 
  9.  *描述:策略抽象类 
  10.  */  
  11. public interface Strategy {  
  12.   
  13.     /** 
  14.      *  
  15.      *作者:alaric 
  16.      *时间:2013-8-5上午11:05:11 
  17.      *描述:策略行为方法 
  18.      */  
  19.     public Double calRecharge(Double charge ,RechargeTypeEnum type );  
  20. }  

 

Java代码  收藏代码
  1. package strategy.strategy;  
  2.   
  3. import strategy.RechargeTypeEnum;  
  4. /** 
  5.  *  
  6.  *作者:alaric 
  7.  *时间:2013-8-5上午11:14:23 
  8.  *描述:网银充值 
  9.  */  
  10. public class EBankStrategy implements Strategy{  
  11.   
  12.     @Override  
  13.     public Double calRecharge(Double charge, RechargeTypeEnum type) {  
  14.         return charge*0.85;  
  15.     }  
  16.   
  17.       
  18.   
  19. }  

 

Java代码  收藏代码
  1. package strategy.strategy;  
  2.   
  3. import strategy.RechargeTypeEnum;  
  4. /** 
  5.  *  
  6.  *作者:alaric 
  7.  *时间:2013-8-5上午11:14:08 
  8.  *描述:商户账号充值 
  9.  */  
  10. public class BusiAcctStrategy implements Strategy{  
  11.   
  12.     @Override  
  13.     public Double calRecharge(Double charge, RechargeTypeEnum type) {  
  14.         // TODO Auto-generated method stub  
  15.         return charge*0.90;  
  16.     }  
  17.   
  18. }  

 

Java代码  收藏代码
  1. package strategy.strategy;  
  2.   
  3. import strategy.RechargeTypeEnum;  
  4. /** 
  5.  *  
  6.  *作者:alaric 
  7.  *时间:2013-8-5上午11:14:43 
  8.  *描述:手机充值 
  9.  */  
  10. public class MobileStrategy implements Strategy {  
  11.   
  12.     @Override  
  13.     public Double calRecharge(Double charge, RechargeTypeEnum type) {  
  14.         // TODO Auto-generated method stub  
  15.         return charge;  
  16.     }  
  17.   
  18. }  

 

Java代码  收藏代码
  1. package strategy.strategy;  
  2.   
  3. import strategy.RechargeTypeEnum;  
  4. /** 
  5.  *  
  6.  *作者:alaric 
  7.  *时间:2013-8-5上午11:13:46 
  8.  *描述:充值卡充值 
  9.  */  
  10. public class CardStrategy implements Strategy{  
  11.   
  12.     @Override  
  13.     public Double calRecharge(Double charge, RechargeTypeEnum type) {  
  14.         return charge+charge*0.01;  
  15.     }  
  16.   
  17. }  

 

Java代码  收藏代码
  1. package strategy.strategy;  
  2.   
  3. import strategy.RechargeTypeEnum;  
  4.   
  5. /** 
  6.  *  
  7.  *作者:alaric 
  8.  *时间:2013-8-5上午11:03:38 
  9.  *描述:场景类 
  10.  */  
  11. public class Context {  
  12.   
  13.     private Strategy strategy;  
  14.       
  15.     public Double calRecharge(Double charge, Integer type) {  
  16.         strategy = StrategyFactory.getInstance().creator(type);  
  17.         return strategy.calRecharge(charge, RechargeTypeEnum.valueOf(type));  
  18.     }  
  19.   
  20.     public Strategy getStrategy() {  
  21.         return strategy;  
  22.     }  
  23.   
  24.     public void setStrategy(Strategy strategy) {  
  25.         this.strategy = strategy;  
  26.     }  
  27.       
  28. }  

 

Java代码  收藏代码
  1. package strategy.strategy;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.Map;  
  5.   
  6. import strategy.RechargeTypeEnum;  
  7. /** 
  8.  *  
  9.  *作者:alaric 
  10.  *时间:2013-8-5上午11:31:12 
  11.  *描述:策略工厂 使用单例模式 
  12.  */  
  13. public class StrategyFactory {  
  14.   
  15.     private static StrategyFactory factory = new StrategyFactory();  
  16.     private StrategyFactory(){  
  17.     }  
  18.     private static Map<Integer ,Strategy> strategyMap = new HashMap<>();  
  19.     static{  
  20.         strategyMap.put(RechargeTypeEnum.E_BANK.value(), new EBankStrategy());  
  21.         strategyMap.put(RechargeTypeEnum.BUSI_ACCOUNTS.value(), new BusiAcctStrategy());  
  22.         strategyMap.put(RechargeTypeEnum.MOBILE.value(), new MobileStrategy());  
  23.         strategyMap.put(RechargeTypeEnum.CARD_RECHARGE.value(), new CardStrategy());  
  24.     }  
  25.     public Strategy creator(Integer type){  
  26.         return strategyMap.get(type);  
  27.     }  
  28.     public static StrategyFactory getInstance(){  
  29.         return factory;  
  30.     }  
  31. }  

 

Java代码  收藏代码
  1. package strategy.strategy;  
  2.   
  3. import strategy.RechargeTypeEnum;  
  4.   
  5. public class Client {  
  6.   
  7.     /** 
  8.      * 作者:alaric 时间:2013-8-5上午11:33:52 描述: 
  9.      */  
  10.     public static void main(String[] args) {  
  11.   
  12.         Context context = new Context();  
  13.         // 网银充值100 需要付多少  
  14.         Double money = context.calRecharge(100D,  
  15.                 RechargeTypeEnum.E_BANK.value());  
  16.         System.out.println(money);  
  17.   
  18.         // 商户账户充值100 需要付多少  
  19.         Double money2 = context.calRecharge(100D,  
  20.                 RechargeTypeEnum.BUSI_ACCOUNTS.value());  
  21.         System.out.println(money2);  
  22.   
  23.         // 手机充值100 需要付多少  
  24.         Double money3 = context.calRecharge(100D,  
  25.                 RechargeTypeEnum.MOBILE.value());  
  26.         System.out.println(money3);  
  27.   
  28.         // 充值卡充值100 需要付多少  
  29.         Double money4 = context.calRecharge(100D,  
  30.                 RechargeTypeEnum.CARD_RECHARGE.value());  
  31.         System.out.println(money4);  
  32.     }  
  33.   
  34. }  

运行结果:

 

85.0

90.0

100.0

101.0

从上面类图和代码可以看出,策略模式把具体的算法封装到了具体策略角色内部,增强了可扩展性,隐蔽了实现细节;它替代继承来实现,避免了if-else这种不易维护的条件语句。当然我们也可以看到,策略模式由于独立策略实现,使得系统内增加了很多策略类;对客户端来说必须知道兜友哪些具体策略,而且需要知道选择具体策略的条件。

发布了92 篇原创文章 · 获赞 37 · 访问量 24万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览