[Java知识库]Java设计模式之策略模式

概念

策略模式是一种行为设计模式， 它能让你定义一系列算法， 并将每种算法分别放入独立的类中， 以使算法的对象能够相互替换。

策略模式使用场景：

当你的程序中面临着不同的功能策略耦合在业务之中，而需要大量的if-else判断去归属不同算法执行不同业务行为的时候，其实就应该思考使用策略模式将不同算法玻璃开来，统一由环境角色控制算法分发。这样做算法分离的好处就是个别算法的增加删除将不会影响到整体业务逻辑修改。一个比较典型的适用策略模式的就是计算器，加减乘除每一种其实都可以理解成一种算法，也就是对抽象策略的实现具体实现。如果后续增加了其他的取余、平方算法，也应当是基于抽象策略做具体实现，而不是修改整体的程序逻辑。

策略模式主要涉及到三个角色：

• 环境角色（Context）： 持有一个Strategy类的引用
• 抽象策略角色（Strategy）：这是一个抽象角色，通常由一个接口或者一个抽象类实现。
• 具体策略（ConcreteStrategy）：包含了相关的算法或行为。

（图片来源自https://blog.csdn.net/hguisu/article/details/7558249/）

举个栗子🌰

加入你老家在长沙，你现在在上海工作，过年你回家，可能就存在了如下方案了：

不同的方案成本也不同，你的想法可能是年终奖发了之后考虑怎么回去，钱多就飞机、钱少就班车或者单车（😭打工人伤不起）,当然可能会有其他你暂时没想到的情况，你可能几天后又有新方案了。只是一个想法方案的话，修改很简单，但是如果这是一个程序代码，可能新增一个简单的逻辑分支，就会破坏到程序的核心代码（😄当然，你用怕，我们有策略模式方便拆分算法，就不用有这么多担忧了。🍾🍾🍾）。

这里我们的核心诉求是回家（go home ~）,所以我们指定要定义一个借口作为回家策略的抽象实现。

public interface Strategy {

    /**
     * 交通工具
     */
    void transport();
}

具体策略实现，下面简单列两种

public class CarStrategy  implements Strategy {
    @Override
    public void transport() {
        System.out.println("选择自驾开车回家");
    }
}

public class BikeStrategy implements Strategy {
    @Override
    public void transport() {
        System.out.println("选择骑单车回家");
    }
}

下面是真正的容器管理，也就是我们回家，其实每种交通工具的价格、经过哪些地方等等，相关联的是具体的回家策略，作为回家的总控制器，我们其实不会单独关心到每个细节，选择了某种模式，就按既定方案执行即可。

public class Context {

    private final Strategy mStrategy;

    public Context(Strategy strategy) {
        this.mStrategy = strategy;
    }

    public void goHome() {
        mStrategy.transport();
    }
}

简单看下使用吧。

public class XiaomingTongxue {

    public static void main(String[] args) {
        
        Strategy strategy = null;
        
        //单车方式
//        strategy = new BikeStrategy();
        
        //开车方式
        strategy = new CarStrategy();
        
        Context context = new Context(strategy);
        
        //我要回家
        context.goHome();
    }
}

得~，现在老板比较好心，决定给你们过年多点福利，你可能可以提前回家，由于时间提前，你发现机票很便宜，你又想直接买机票飞了，很简单，实现抽象策略，处理即可，最终执行，你只需要告诉总控（Context），我飞机方式即可，总控不需要做任何改变。

三方代码中的经典实现

前两天刚重新读了一遍EventBus的源码，其实他的poster处理方式就是典型的策略模式。

    private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
        //根据注解方法上的threadMode来区分使用那种poster发送event出去
        switch (subscription.subscriberMethod.threadMode) {
            case POSTING:
                invokeSubscriber(subscription, event);
                break;
            case MAIN:
                if (isMainThread) {
                    //invokeSubscriber本身不关心线程，在当前线程直接发送
                    invokeSubscriber(subscription, event);
                } else {
                    //使用handler切换到主线程执行
                    mainThreadPoster.enqueue(subscription, event);
                }
                break;
            case MAIN_ORDERED:
                if (mainThreadPoster != null) {
                    mainThreadPoster.enqueue(subscription, event);
                } else {
                    // temporary: technically not correct as poster not decoupled from subscriber
                    invokeSubscriber(subscription, event);
                }
                break;
            case BACKGROUND:
                if (isMainThread) {
                    backgroundPoster.enqueue(subscription, event);
                } else {
                    invokeSubscriber(subscription, event);
                }
                break;
            case ASYNC:
                asyncPoster.enqueue(subscription, event);
                break;
            default:
                throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
        }
    }

这里使用到了poster，而根据不同线程和同步异步情况，这里使用过了三个不同的poster供选择，而每个poster都实现了Poster，每种poster方案逻辑被拆分到了不同的类实现，而核心程序只要确保执行Poster#enqueue即可。

interface Poster {

    /**
     * Enqueue an event to be posted for a particular subscription.
     *
     * @param subscription Subscription which will receive the event.
     * @param event        Event that will be posted to subscribers.
     */
    void enqueue(Subscription subscription, Object event);
}

对于上面代码感兴趣的可以看下我上一篇文章可能你的EventBus使用并不正确，是时候真正搞懂EventBus了(下)。

感谢阅读~