【java设计模式】(7)---策略模式(案例解析)

1年前 (2022) 程序员胖胖胖虎阿
165 0 0

一、概念

1、理解策略模式

策略模式是一种行为型模式,它将对象和行为分开,将行为定义为 一个行为接口具体行为的实现。策略模式最大的特点是行为的变化,行为之间可以相互替换。每个if判断都可以理解为就是一个策略。

2、策略模式特点

策略模式把对象本身和行为区分开来,因此我们整个模式也分为三个部分。

1、抽象策略类(Strategy):策略的抽象,行为方式的抽象
2、具体策略类(ConcreteStrategy):具体的策略实现,每一种行为方式的具体实现。
3、环境类(Context):用来封装具体行为,操作策略的上下文环境。

3、举例理解(打车)

这里举个简单的例子,来理解开发中运用策略模式的场景。

有一个打车软件,现在有三种计费模式给 用户 选择,1、拼车 2、快车 3、豪车这个时候用户就是对象,三种计费方式就是行为,可以根据不同的行为计算不同不通的费用。

1)传统实现方式

代码

    /**
      * @Description: 这里只展示计费最终费用示例
      *
      * @param  type 计费类型
      * @param  originalPrice 原始价格
      */
    public Double calculationPrice(String type, Double originalPrice) {

        //拼车计费
        if (type.equals("pc")) {
            return originalPrice * 0.5;
        }
        //快车计费
        if (type.equals("kc")) {
            return originalPrice * 1;
        }
        //豪车计费
        if (type.equals("hc")) {
            return originalPrice * 2;
        }
        return originalPrice;
    }

传统的实现方式,通过传统if代码判断。这样就会导致后期的维护性非常差。当后期需要新增计费方式,还需要在这里再加上if(),也不符合设计模式的开闭原则。

2)策略模式实现

抽象策略类

/**
 * 出行策略接口
 */
public interface PriceStrategy {
	/**
	 * @param originalPrice 原始价格
	 * @return  计算后的价格
	 */
	Double countPrice(Double originalPrice);
}

具体策略实现类

/**
  * @Description: 拼车的计费方式
  */
public class PcStrategy implements PriceStrategy {
    @Override
    public Double countPrice(Double originalPrice) {
        return originalPrice * 0.5;
    }
}

/**
  * @Description: 快车的计费方式
  */
public class KcStrategy implements PriceStrategy {
    @Override
    public Double countPrice(Double originalPrice) {
        return originalPrice * 1;
    }
}

/**
  * @Description: 拼车的计费方式
  */
public class HcStrategy implements PriceStrategy {
    @Override
    public Double countPrice(Double originalPrice) {
        return originalPrice * 2;
    }
}

环境类

也叫做上下文类或环境类,起承上启下封装作用。

/**
 * 负责和具体的策略类交互
 * 这样的话,具体的算法和直接的客户端调用分离了,使得算法可以独立于客户端独立的变化。
 * 如果使用spring的依赖注入功能,还可以通过配置文件,动态的注入不同策略对象,动态的切换不同的算法.
 */
public class PriceContext {

    /**
     * 出行策略接口
     */
    private PriceStrategy riceStrategy;
    /**
     * 构造函数注入
     */
    public PriceContext(PriceStrategy riceStrategy) {
        this.riceStrategy = riceStrategy;
    }
    /**
     * 计算价格
     */
    public Double countPrice(Double originalPrice) {
        return riceStrategy.countPrice(originalPrice);
    }
}

测试类

    public static void main(String[] args) {
        //具体行为策略
        PriceStrategy pcStrategy = new PcStrategy();
        PriceStrategy kcStrategy = new KcStrategy();
        PriceStrategy hcStrategy = new HcStrategy();

        //用户选择不同的策略
        PriceContext pcContext = new PriceContext(pcStrategy);
        PriceContext kcContext = new PriceContext(kcStrategy);
        PriceContext hcContext = new PriceContext(hcStrategy);

        System.out.println("拼车价格 = " +  pcContext.countPrice(10D));
        System.out.println("快车价格 = " +  kcContext.countPrice(10D));
        System.out.println("豪车价格 = " +  hcContext.countPrice(10D));
    }

运行结果

拼车价格 = 5.0
快车价格 = 10.0
豪车价格 = 20.0

整理流程就是这个样的,这里有一点需要注意 我在做测试的时候具体策略对象都是new出来,而实际运用应该通过spring来管理,这样才能做到真正的开闭原则。下面会在举例。

4、策略模式优缺点

优点

1)避免使用多重条件判断

如果没有策略模式,一个策略家族有多个策略算法,一会要使用A策略,一会要使用B策略,怎么设计呢?使用多重if的条件语句?多重条件语句不易维护,而且出错的概率大大增强。使用策略模式后,简化了操作,同时避免了条件语句判断。

2)扩展性良好

在现有的系统中增加一个策略太容易了只要实现接口就可以,其他都不用修改,类似于一个可反复拆卸的插件,这大大地符合了OCP原则。

缺点

1)策略类数量增多

策略模式一个明显的缺点是当备用行为过多时,行为对象会非常庞大

5、策略模式运用场景

通过上面的优缺点我们可以很好的去思考,什么场景下可以考虑用策略模式?

我的理解就是:每个if判断都可以理解为就是一个策略。按理说都可以采用策略模式,但是如果if else里面的逻辑不多,且复用性很低,那就不需要。如果if里面的行为比较大而且这些行为复用性比较高就可以考虑通过采用策略模式。

在我们生活中比较常见的应用模式有:

1、电商网站支付方式,一般分为银联、微信、支付宝,可以采用策略模式
2、电商网站活动方式,一般分为满减送、限时折扣、包邮活动,拼团等可以采用策略模式

二、策略模式实战示例

最近正在做到电商项目,因为有多个活动,所以我就考虑用策略模式来实现。我们活动分为很多种满减送,包邮活动,限时折扣等等,这里大致写下对于多个活动如何去使用策略模式。

1、Order实体

活动是跟订单绑定在一起的,只有下了单才去计算这个订单走了哪个活动。

/**
  * @Description: 订单实体
  */
public class Order {
    /**
     * 用户ID
     */
    private Long userId;
    /**
     * 订单编号
     */
    private String orderNumber;
    /**
     * 购买数量
     */
    private Integer goodsNumber;
    /**
     * 订单运费
     */
    private Double orderFreight;
    /**
     * 订单总价(订单价格 + 运费)
     */
    private Double orderPrice;
    /**
     * 活动类型 1、包邮 2、满减送 3、限时折扣
     */
    private String activityType;
    /**
     * 活动ID
     */
    private String activityId;
  //省略get set方法

2、ActivityTypeEnum活动枚举

/**
 *  当前活动的枚举
 */
@NoArgsConstructor
@AllArgsConstructor
public enum ActivityTypeEnum {

    FREE_SHIPPING(1, "包邮活动"),

    FULL_DELIVERY(2, "满减活动"),

    LIMIT_DISCOUNT(3, "现实折扣");

    private Integer code;

    private String name;

    /**
     * 通过code获取枚举信息
     */
    public static ActivityTypeEnum decode(int code) {
        ActivityTypeEnum activity = null;
        for (ActivityTypeEnum type : ActivityTypeEnum.values()) {
            if (type.code==code) {
                activity = type;
                break;
            }
        }
        return activity;
    }
//省略get set方法
}

3、ActivityStrategy

活动策略接口

/**
 * 定义一个总的活动抽象
 */
public interface ActivityStrategy {

    /**
      * 属于哪种活动
      */
     ActivityTypeEnum getActivityType();
 
     /**
      * 定义一个我们优惠活动的价格算法方法
      */
     Order calculate(Order order);
}

4、具体活动策略实现类

FreeShippingActivity 包邮

/**
  * @Description: 包邮活动
  */
@Service
public class FreeShippingActivity implements ActivityStrategy {

    @Override
    public ActivityTypeEnum getActivityType() {
        //返回包邮活动
        return ActivityTypeEnum.FREE_SHIPPING;
    }

    @Override
    public Order calculate(Order order) {
        //包邮活动是一个大的主题 ,里面可以创建很多小活动 比如价格满100包邮活动,或者满2件以上包邮活动,江浙沪包邮活动等等
        //如果这里通过活动ID获取用户具体选择了哪一个活动。
        String activityId = order.getActivityId();
        //查询数据库
        System.out.println("模拟查询数据库 ,当前的活动是满100包邮");
        order.setOrderFreight(0.0D);
        return order;
    }
}

FullDeliveryActivity (满减送活动)

/**
  * @Description: 满减送活动
  */
@Service
public class FullDeliveryActivity implements ActivityStrategy {
    @Override
    public ActivityTypeEnum getActivityType() {
        //满减活动
        return ActivityTypeEnum.FULL_DELIVERY;
    }

    @Override
    public Order calculate(Order order) {
        //如果这里通过活动ID获取用户具体选择了哪一个活动。
        String activityId = order.getActivityId();
        //查询数据库
        System.out.println("模拟查询数据库 ,当前的活动是满100减20的");
        if (order.getOrderPrice() > 100) {
            order.setOrderPrice(order.getOrderPrice() - 20);
        }
        return order;
    }
}

LimitDiscountActivity (限时折扣活动)

/**
  * @Description: 限时折扣活动
  */
@Service
public class LimitDiscountActivity implements ActivityStrategy {
    @Override
    public ActivityTypeEnum getActivityType() {
        //返回限时活动枚举
        return ActivityTypeEnum.LIMIT_DISCOUNT;
    }

    @Override
    public Order calculate(Order order) {
        //如果这里通过活动ID获取用户具体选择了哪一个活动。
        String activityId = order.getActivityId();
        //查询数据库
        System.out.println("模拟查询数据库 ,当前的活动是截至2020.10.1前 打9折");
        order.setOrderPrice(order.getOrderPrice() * 0.9);

        return order;
    }
}

5、环境类

/**
 * @Description: 通过spring容器来管理该策略 负责和具体的策略类交互 动态的切换不同的算法
 */
@Component
public class ActivityContext  implements ApplicationContextAware {

    /**
     * 将策略存放在map中
     */
    private Map<ActivityTypeEnum, ActivityStrategy> activityStrategyMap = new ConcurrentHashMap<>();

    /**
     * 获取对应策略
     */
    public Order resolveFile(ActivityTypeEnum activityTypeEnum, Order order) {
        ActivityStrategy activityStrategy = activityStrategyMap.get(activityTypeEnum);
        if (activityStrategy != null) {
           return activityStrategy.calculate(order);
        }
        return order;
    }
    
    /**
     * 把不同策略放到map
     */ 
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        //获取ActivityStrategy接口所有的实现
        Map<String, ActivityStrategy> tmepMap = applicationContext.getBeansOfType(ActivityStrategy.class);
        //存入上面的map中
        tmepMap.values().forEach(strategyService -> activityStrategyMap.put(strategyService.getActivityType(), strategyService));
    }
}

4、测试类

@RestController
public class PayController {

    @Autowired
    private ActivityContext activityContext;

    @RequestMapping("/test")
    public  Object test(){
        Order order = new Order();
        //1 代表包邮
        order.setActivityType("1");
        //具体活动ID
        order.setActivityId("12");
        //总价
        order.setOrderPrice(200D);
        //运费
        order.setOrderFreight(10D);
       return activityContext.resolveFile(ActivityTypeEnum.decode(order.getActivityType()),order);
    }
}
//输出: 模拟查询数据库 ,当前的活动是包邮

总结 这里我们没有用到if else来判断用户到底选择了哪个活动类型,而是通过先把所有活动的bean实体装入一个map中,然后通过activityType 来获取具体是哪个活动类型。以后新添加一个活动,比如拼团活动,我们只需做两步

1、新建一个拼团活动策略类 实现总策略接口 2、ActivityTypeEnum中添加这个活动。

这里只是列了个架构,实际开发中比这个复杂多了,因为可以同时选择多个活动,活动于活动之间又会有互斥关系。

参考

1、策略模式
2、支付平台选择(策略模式)
3、Java设计模式-策略模式

【java设计模式】(7)---策略模式(案例解析)

相关文章

暂无评论

暂无评论...