策略模式项目中实际使用

 FusionCheck和CommonCheck是ILiveCheck的实现类，当我们需要使用这两个实现类的时候，使用LiveCheckWrapper里面传入相应的需要的实现类即可。

具体的代码结构如下图所示：

仿写的代码如下：

一个抽象策略接口：

public interface Strategy {
    int doOperation(int num1, int num2, Strategy.StrategyCallback callback);

    interface StrategyCallback {
        void onSuccess();
        void onFail();
    }
}

加减乘的三个具体实现：

public class OperationAdd implements Strategy {
    @Override
    public int doOperation(int num1, int num2, StrategyCallback callback) {
        if (num1 + num2 > 10) {
            callback.onFail();
            return 100;
        } else {
            callback.onSuccess();
            return num1 + num2;
        }
    }
}

public class OperationSubstract implements Strategy {

    @Override
    public int doOperation(int num1, int num2, StrategyCallback callback) {
        if (num1 - num2 < 0) {
            callback.onFail();
            return -1;
        } else {
            callback.onSuccess();
            return num1 - num2;
        }
    }
}

public class OperationMultiply implements Strategy {

    @Override
    public int doOperation(int num1, int num2, StrategyCallback callback) {
        if (num1 * num2 > 10) {
            callback.onFail();
            return 100;
        } else {
            callback.onSuccess();
            return num1 * num2;
        }
    }
}

针对上述三个实现的包装/封装转化，屏蔽外界的选择：

public class StrategyWrapper implements Strategy {

    private Strategy strategy;

    /**
     * 方式一调用：从外面传入行为策略
     *
     * @param strategy
     */
    public StrategyWrapper(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2, Strategy.StrategyCallback callback) {
        return strategy.doOperation(num1, num2, callback);
    }
    /**
     * 方式一调用：从外面传入行为策略
     */


    /**
     * 方式二调用：直接在里面判断策略选择
     */
    private int chooseWitch = 1;
    // getInstance 获取系统需要的取值策略

    public StrategyWrapper() {
        if (chooseWitch == 1) {
            strategy = new OperationAdd();
        } else if (chooseWitch == 2) {
            strategy = new OperationSubstract();
        } else {
            strategy = new OperationMultiply();
        }
    }

    @Override
    public int doOperation(int num1, int num2, StrategyCallback callback) {
        return strategy.doOperation(num1, num2, callback);
    }
    /**
     * 方式二调用 end
     */
}

外界的调用方式一，直接往策略包装类中传入需要的具体策略

StrategyWrapper wrapper = new StrategyWrapper(new OperationAdd());
StrategyWrapper wrapper = new StrategyWrapper(new OperationSubstract());
StrategyWrapper wrapper = new StrategyWrapper(new OperationMultiply());

public class computeManager {

    private void doDiffComputeStrategy() {
        /**
         * 方式一 begin：在这里选择使用的策略，方便不同策略回调不同结果
         */
        StrategyWrapper wrapper = new StrategyWrapper(new OperationAdd());
        wrapper.executeStrategy(1, 2, new Strategy.StrategyCallback() {
            @Override
            public void onSuccess() {

            }

            @Override
            public void onFail() {

            }
        });

    }
}

外界的调用方式二，不在初始策略中传，而是在包装类中进行选择：

public class computeManager2 {

    /**
     * 方式二 begin：不需要在这里选择使用的策略，方便不同策略回调后走相同的处理流程
     */
    private void doDiffComputeStrategy() {
        Strategy strategy = new StrategyWrapper();
        strategy.doOperation(1, 2, new Strategy.StrategyCallback() {
            @Override
            public void onSuccess() {
                System.out.println("manager 2 success");
            }

            @Override
            public void onFail() {
                System.out.println("manager 2 failed");
            }
        });
    }
}

整个项目在git上：https://github.com/buder-cp/DesignPattern/tree/master/mvp-rx-loginStrategy-master/strategymode