赞
踩
在一个收银系统中,如果普通用户、中级会员、高级会员分别对应着不同的优惠策略,常规编程就要使用一系列的判断语句,判断用户类型,这种情况下就可以使用策略模式。
策略模式的概念很好理解,它将对象和行为分开,将行为定义为 一个行为接口和具体行为的实现,每个if判断都可以理解为一个策略。
如果在收银系统中使用策略模式,要将普通、中级、高级会员分别定义一个具体策略类,并实现各自的方法,定义一个环境类,持有策略类的引用,由引用调用相应的策略类方法,客户端传入相应的具体策略对象就会调用各自的策略方法。
学过了状态模式,很多人也把状态模式和状态模式搞混,现在就可以考虑一下为什么不使用状态模式?
各个策略之间并不存在流转(比如:状态1234切换)关系,都是各自的算法实现各自的逻辑,客户端控制调用哪个策略,如果使用状态模式就变成了,先调用普通会员的策略,再调用中级会员的策略,再调用高级会员的策略,看到最后的优惠用户估计会乐疯吧!
和状态模式一样,策略模式也应包含三个角色:
抽象策略类:策略是一个接口,该接口定义若干个算法标识,即定义了若干个抽象方法
具体策略类:具体策略是实现策略接口的类
环境类 /上下文类:上下文提供一个方法,持有一个策略类的引用,最终给客户端调用。
相比于状态模式,策略模式各个角色的职责更简单,我们基于收银案例实现策略模式demo。
抽象策略类:
定义业务抽象方法,我们主要是计算价格
- /**
- * 策略抽象类
- * @author tcy
- * @Date 21-09-2022
- */
- public interface AbstractMemberStrategy {
- // 一个计算价格的抽象方法
- //price商品的价格 n商品的个数
- public double calcPrice(double price, int n);
- }
具体策略-高级会员:
各个具体策略实现各自的计算方法
- /**高级会员
- * @author tcy
- * @Date 21-09-2022
- */
- public class StrategyAdvanceMember implements AbstractMemberStrategy {
- @Override
- public double calcPrice(double price, int n) {
- double money = price * n *0.8;
- return money;
- }
- }
具体策略-中级会员:
- /**
- * 中级会员
- * @author tcy
- * @Date 21-09-2022
- */
- public class StrategyIntermediateMember implements AbstractMemberStrategy {
- @Override
- public double calcPrice(double price, int n) {
- double money = price * n*0.9;
- return money;
- }
- }
具体策略-普通会员:
- /**
- * 初级会员
- * @author tcy
- * @Date 21-09-2022
- */
- public class StrategyPrimaryMember implements AbstractMemberStrategy {
- @Override
- public double calcPrice(double price, int n) {
- return price * n;
- }
- }
环境类:
持有策略类的引用,调用时传入相应的具体策略对象,就会调用策略各自的方法。
- /**环境类
- * @author tcy
- * @Date 21-09-2022
- */
- public class Context {
- // 用户折扣策略接口
- private AbstractMemberStrategy memberStrategy;
-
- // 注入构造方法
- public Context(AbstractMemberStrategy memberStrategy) {
- this.memberStrategy = memberStrategy;
- }
-
- // 计算价格
- public double qoutePrice(double goodsPrice, int n){
- // 通过接口变量调用对应的具体策略
- return memberStrategy.calcPrice(goodsPrice, n);
- }
-
- }
客户端调用:
- /**
- * @author tcy
- * @Date 21-09-2022
- */
- public class Client {
- public static void main(String[] args) {
-
- // 具体策略类
- AbstractMemberStrategy primaryMemberStrategy = new StrategyPrimaryMember();
- AbstractMemberStrategy intermediateMemberStrategy = new StrategyIntermediateMember();
- AbstractMemberStrategy advanceMemberStrategy = new StrategyAdvanceMember();
-
- // 用户选择不同策略
- Context primaryContext = new Context(primaryMemberStrategy);
- Context intermediateContext = new Context(intermediateMemberStrategy);
- Context advanceContext = new Context(advanceMemberStrategy);
-
- //一本100块钱的书
- // 普通会员:100
- System.out.println("普通会员的价格:"+ primaryContext.qoutePrice(100,1));
- // 中级会员 90
- System.out.println("中级会员的价格:"+ intermediateContext.qoutePrice(100,1));
- // 高级会员 80
- System.out.println("高级会员的价格:"+ advanceContext.qoutePrice(100,1));
-
- }
- }
策略模式相对于状态模式理解起来更没有任何难度。
策略模式的典型应用是Jdk中线程池满之后的拒绝策略,我们在创建一个线程池时会传入以下参数:
- public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,
- TimeUnit unit,BlockingQueue<Runnable> workQueue,
- ThreadFactory threadFactory,RejectedExecutionHandler handler) {
- if (corePoolSize < 0 ||
- maximumPoolSize <= 0 ||
- maximumPoolSize < corePoolSize ||
- keepAliveTime < 0)
- throw new IllegalArgumentException();
- if (workQueue == null || threadFactory == null || handler == null)
- throw new NullPointerException();
- this.corePoolSize = corePoolSize;
- this.maximumPoolSize = maximumPoolSize;
- this.workQueue = workQueue;
- this.keepAliveTime = unit.toNanos(keepAliveTime);
- this.threadFactory = threadFactory;
- this.handler = handler;
- }
其中 RejectedExecutionHandler 是线程池满之后的拒绝策略,jdk中的多线程内置了四种拒绝策略,如下图:
这四种拒绝策略就代表策略模式角色中的具体策略角色,ThreadPoolExecutor类我们可以将其看做环境类。
我们知道执行多线程中的方法是schedule方法,可以就认为这就是角色中的客户端:
- public ScheduledFuture<?> schedule(Runnable command,
- long delay,
- TimeUnit unit) {
- if (command == null || unit == null)
- throw new NullPointerException();
- RunnableScheduledFuture<?> t = decorateTask(command,
- new ScheduledFutureTask<Void>(command, null,
- triggerTime(delay, unit)));
- delayedExecute(t);
- return t;
- }
既然是客户端,就会有时机调用拒绝策略方法,我们点进去看delayedExecute()方法。
- private void delayedExecute(RunnableScheduledFuture<?> task) {
- if (isShutdown())
- reject(task);
- else {
- super.getQueue().add(task);
- if (isShutdown() &&
- !canRunInCurrentRunState(task.isPeriodic()) &&
- remove(task))
- task.cancel(false);
- else
- ensurePrestart();
- }
- }
接着看reject()方法,该方法时机上调用的就是拒绝策略方法。传入相应的this对象,调用不同的拒绝策略。
- final void reject(Runnable command) {
- handler.rejectedExecution(command, this);
- }
调用时序如下图:
何时调用何种拒绝策略,由delayedExecute()方法自己来决定,各个拒绝策略有各自的业务逻辑,这就是策略模式的典型应用。
策略模式和状态模式虽然类图一模一样,很多博客也将他们混为一谈,实际上策略模式和状态模式没有半毛钱的关系,只有理解了两种模式的使用场景,在运用时才能游刃有余,以下为我总结的四点不同之处,状态模式的博客可以参考状态模式。
使用策略模式会让我们的代码更加的“干净”,但是如果实际的if判断中的逻辑很简单,我们仍然使用策略模式,就变成了为了使用设计模式而使用,这无疑加重系统的复杂程度。
就像商城系统中,微信支付、支付宝支付、银联支付,业务逻辑没那么简单的,使用策略模式就是一个好的选择。
整体来说策略模式在行为型模式中还属于一种比较简单的模式,无论是理解起来还是写起来都属极简单,难度堪比结构型设计模式中的单例模式。
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。