JAVA策略模式

在多场景的代码中，需要根据前端传来的参数走不同的代码逻辑，例如：

public static void main(String[] args) {
        String code = "前端传来的场景码";
        String param = "前端传来的参数";
        if (("0001").equals(code)) {
            System.out.println("开始执行场景0001的逻辑,参数" + param);
        } else if (("0002").equals(code)) {
            System.out.println("开始执行场景0002的逻辑,参数" + param);
        } else if (("0003").equals(code)) {
            System.out.println("开始执行场景0003的逻辑,参数" + param);
        } else if (("0004").equals(code)) {
            System.out.println("开始执行场景0004的逻辑,参数" + param);
        } else if (("0005").equals(code)) {
            System.out.println("开始执行场景0005的逻辑,参数" + param);
        } else if (("0006").equals(code)) {
            System.out.println("开始执行场景0006的逻辑,参数" + param);
        } else {
            System.out.println("场景编码不合适");
        }
}

每当有新的场景需要走新的逻辑的时候，就会需要修改代码，添加新的else if判断，这种情况修改同一个类的代码很容易不小心修改了前面的逻辑，可能把以前已经写好的代码弄出bug

在设计模式中，有几个准则，其中一个准则是 “对修改关闭，对新增开放”，意思是当有新需求来的时候，尽量不修改代码，只新增代码，那么就可以用以下的代码来实现：

###策略主类

package com.example.strategy;

import java.util.HashMap;
import java.util.Map;

public class Strategy {

    private static Strategy instance = new Strategy();

    public static Strategy GetInstance() {
        return instance;
    }

    private static final Map<String, AbstractStrategy> map = new HashMap<>();

    public static void excute(String code, String param) {
        map.get(code).excute(param);
    }

    abstract public class AbstractStrategy {

        public abstract String getSceneCode();

        public abstract void excute(String param);

        public AbstractStrategy() {
            map.put(this.getSceneCode(), this);
        }

    }

    public static void main(String[] args) {
        String code = "前端传来的场景码";
        String param = "前端传来的参数";
        Strategy.excute("code",param);
    }

}

#策略实现类0001

package com.example.strategy;

@Component
public class Strategy0001 extends Strategy.AbstractStrategy {

    Strategy0001() {
        //类上添加@Component注解， spring初始化bean时，会调用父类的构造函数，将当前bean注册到map中
        Strategy.GetInstance().super();
    }

    @Override
    public String getSceneCode() {
        return "0001";
    }

    @Override
    public void excute(String param) {
        System.out.println("开始执行场景0001的逻辑，参数为：" + param);
    }

}

#策略实现类0002

package com.example.strategy;

@Component
public class Strategy0002 extends Strategy.AbstractStrategy {

    Strategy0002() {
        //类上添加@Component注解， spring初始化bean时，会调用父类的构造函数，将当前bean注册到map中
        Strategy.GetInstance().super();
    }

    @Override
    public String getSceneCode() {
        return "0002";
    }

    @Override
    public void excute(String param) {
        System.out.println("开始执行场景0002的逻辑，参数为：" + param);
    }

}

通过以上代码，每当有新的业务场景来的时候，不用修改已经上线的代码，只需新增场景代码类，达到”对修改关闭，对新增开放”的效果。