java 设计模式之策略模式

简介

策略模式：策略模式可以定制目标对象的行为，它通过传入不同的策略实现，来配置目标对象的行为。使用策略模式，就是为了定制目标对象在某个关键点的行为。

策略模式中的角色：

上下文类：持有一个策略类的引用，最终给客户端调用
策略接口：定义规范，所有的策略类都要实现
具体策略累：实现具体算法

优缺点：

优点：
- 避免多重if else语句
- 策略类之间可以自由切换；
- 增加一个新的策略只需要添加一个具体的策略类即可；
缺点：客户端必须知道所有的策略类，并自行决定使用哪一个策略类

策略模式的实现

案例：售货员和优惠策略，用户可以配置售货员使用的优惠策略

第一步：上下文类

public class SaleMan {// 上下文类持有策略接口的实例，用户通过传入策略接口的不同实现，来配置上下文类的行为private final Strategy strategy;public SaleMan() { }public SaleMan(Strategy strategy) {this.strategy = strategy;}public void saleManShow() {System.out.print("售货员促销商品时使用的优惠策略：");strategy.show();}
}

第二步：策略接口

public interface Strategy {void show();
}

第三步：具体的策略类

// 策略1
public class StrategyA implements Strategy {@Overridepublic void show() {System.out.println("买一送一");}
}// 策略2
public class StrategyB implements Strategy{@Overridepublic void show() {System.out.println("满200减50");}
}// 策略3
public class StrategyC implements Strategy{@Overridepublic void show() {System.out.println("满1000减200");}
}

测试：

public class Client {public static void main(String[] args) {SaleMan saleMan = new SaleMan(new StrategyA());saleMan.saleManShow();}
}

总结：在这个案例中，用户在创建售货员实例时，可以配置售货员使用的优惠策略

策略模式本质上就是把上下文类中的某个关键流程提取出来，抽象出接口和实现类，接口就是关键流程要做什么，实现类就是关键流程的不同实现。如果不使用策略模式，这些策略都要放到上下文类中，那么用户需要传入参数来指定走哪条链路，这会导致大量的if else。策略模式可以让目标类更简洁。

使用案例

jdk源码案例：线程池的拒绝策略

1、上下文类

public class ThreadPoolExecutor extends AbstractExecutorService {// 1、上下文类持有策略接口的实例// 拒绝策略private volatile RejectedExecutionHandler handler;// 2、用户通过构造方法来指定上下文类使用哪个拒绝策略public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) {  // 拒绝策略// 这里省略了大量代码，重点关注，外部传入策略接口的实例，来指定线程池在无法// 执行任务时该怎么做this.handler = handler;}// 3、拒绝策略在上下文类中的执行。线程池执行任务的机制public void execute(Runnable command) {if (command == null)throw new NullPointerException();int c = ctl.get();if (workerCountOf(c) < corePoolSize) {if (addWorker(command, true))return;c = ctl.get();}if (isRunning(c) && workQueue.offer(command)) {int recheck = ctl.get();if (! isRunning(recheck) && remove(command))reject(command);  else if (workerCountOf(recheck) == 0)addWorker(null, false);}else if (!addWorker(command, false))reject(command);  // 重点看这里，如果无法执行任务，就执行拒绝策略}// 执行拒绝策略final void reject(Runnable command) {handler.rejectedExecution(command, this);}
}

2、策略接口

public interface RejectedExecutionHandler {// 策略方法，任务无法执行时线程池该怎么办void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

3、具体的策略实现

// 策略1：抛异常，这是默认的拒绝策略
public static class AbortPolicy implements RejectedExecutionHandler {public AbortPolicy() { }public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {// 抛异常throw new RejectedExecutionException("Task " + r.toString() +" rejected from " +e.toString());}
}// 策略2：如果线程池没有关闭，由调用者来执行任务
public static class CallerRunsPolicy implements RejectedExecutionHandler {public CallerRunsPolicy() { }public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {if (!e.isShutdown()) {r.run();}}
}// 策略3：如果线程池没有关闭，丢弃队列中最老的任务
public static class DiscardOldestPolicy implements RejectedExecutionHandler {public DiscardOldestPolicy() { }public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {if (!e.isShutdown()) {e.getQueue().poll();  // 阻塞队列的头结点出队e.execute(r);         // 执行当前异步任务}}
}// 策略4：丢失任务，静默，不抛异常
public static class DiscardPolicy implements RejectedExecutionHandler {public DiscardPolicy() { }public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {}
}