项目经理问我，你还在用switch/case？面向接口编程，彻底告别switch/case，高逼格

今天撸代码的时候，遇到一个根据type不一样，作很多处理的事情功能，我的第一想法就是if/else,或者switch/case来解决，项目经理看了我的代码，很不屑的问了一句：“你还在用switch/case?”。
看着我迷离的眼神，项目经理提笔写下了如下代码。
今天要说的是用接口的方式来取代switch/case，扩展性高，可读性高，关键是逼格高，我的观念就是：做人可以没有逼格，写的代码一定是要有逼格的。
先简单描述一下功能，一个类有n个type，前端传一个type过来，我们根据type来做不同的处理。
主要思路：初始化一个类ContextHolder，根据type，去select不同的实现类，然后做主要的逻辑处理，下面直接上代码(下面的代码忽略命名，忽略包名路径)。

1.我们现在SpringBoot的启动类里的run方法里加载ContextHolder

Class.forName("xxx.xxx.MazeContextHolder");

2.ContextHolder的具体实现
这个类里面主要就是加载具体的实现类，然后实现筛选的父类

public class MazeContextHolder {

    private static final Map<MazeGridTypeEnum, BaseMazeGridTypeInitializer> holder = new HashMap<>();
    private static final List<BaseMazeGridTypeInitializer> baseActivityInitializers = new ArrayList<>();
//静态代码块里面加载的都是type的实现类，放入内存
    static {
        String packageName = BaseMazeGridTypeInitializer.class.getPackage().getName();
        Reflections reflections = new Reflections(packageName);
        Set<Class<? extends BaseMazeGridTypeInitializer>> classes = reflections.getSubTypesOf(BaseMazeGridTypeInitializer.class);
        for (Class<? extends BaseMazeGridTypeInitializer> clazz : classes) {
            try {
                BaseMazeGridTypeInitializer baseActivityInitializer = clazz.newInstance();
                baseActivityInitializers.add(baseActivityInitializer);
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException("reflections error!");
            }
        }
    }
	//这个是检查筛选错误的处理
    public static void configChecker(int gridType) {
        MazeFailureAnalyzer failureAnalyzer = new MazeFailureAnalyzer();
        BaseMazeGridTypeInitializer activityInitializer = getHolder(gridType);
        activityInitializer.configChecker(gridType, failureAnalyzer);
        if (failureAnalyzer.hasError()) {
            failureAnalyzer.printErrors();
        }
    }
	//这个方法就是根据type去获取具体的实现类
    public static BaseMazeGridTypeInitializer getHolder(int gridType) {
        MazeGridTypeEnum mazeGridTypeEnum = getEnum(gridType);
        BaseMazeGridTypeInitializer mazeGridTypeInitializer = holder.get(mazeGridTypeEnum);
        if (mazeGridTypeInitializer != null) return mazeGridTypeInitializer;
        BaseMazeGridTypeInitializer baseMazeGridTypeInitializer = holder.computeIfAbsent(mazeGridTypeEnum, (value) -> {
        //循环前面加载好放在内存里面的实现类集合，调用supports根据type筛选
            for (BaseMazeGridTypeInitializer initializer : baseActivityInitializers) {
                if (initializer.supports(gridType)) return initializer;
            }
            return null;
        });
        if (baseMazeGridTypeInitializer == null) throw new RuntimeException("cannot find maze initializer!!!");
        holder.put(mazeGridTypeEnum, baseMazeGridTypeInitializer);
        return baseMazeGridTypeInitializer;
    }

}

3.新建一个枚举类，用来存不同的type

public enum MazeGridTypeEnum {
    NORMAL_MONSTER(1,"type1"),
    ELITE_MONSTER(2,"type2"),
    BUFF_POINT(3,"type3"),
	...

    ;
    private int type;
    private String note;

    MazeGridTypeEnum(int type, String note) {
        this.type = type;
        this.note = note;
    }

    public int getType() {
        return type;
    }

    public String getNote() {
        return note;
    }

    public static MazeGridTypeEnum getEnum(int type) {
        MazeGridTypeEnum[] MazeGridTypeEnums = MazeGridTypeEnum.values();
        for (MazeGridTypeEnum mazeGridTypeEnum : MazeGridTypeEnums) {
            if (mazeGridTypeEnum.type == type) return mazeGridTypeEnum;
        }
        throw new ConfigException(Tip.CONFIG_MISMATCH,"type错误",type);
    }

4.我们定义一个实现类的接口BaseMazeGridTypeInitializer
里面的方法可以扩展

public interface BaseMazeGridTypeInitializer {

    void configChecker(int gridType, MazeFailureAnalyzer failureAnalyzer);

    void createDetail(int type);
	//筛选判断的方法
    boolean supports(int activityType);

}

5.最后就是具体的实现了，这里可以根据type数量，创建n个实现类，由于每个实现类都是实现BaseMazeGridTypeInitializer接口，我就列一个距离，有需要的自行复制就好。

public class BuffPointInitializer implements BaseMazeGridTypeInitializer {

    @Override
    public void configChecker(int gridType, MazeFailureAnalyzer failureAnalyzer) {
        //检查type是否存在
        if ('不存在，抛出异常') failureAnalyzer.addError(String.valueOf(gridType), "grid type must not be null!");
    }

    @Override
    public void createDetail(int type) {
		//这里可以根据具体的逻辑来做不同的处理
    }

    @Override
    public boolean supports(int gridType) {
        MazeGridTypeEnum mazeGridTypeEnum = getEnum(gridType);
        return mazeGridTypeEnum == BUFF_POINT;
    }
}

6，最后把选择失败的处理类粘贴出来，可以根据需要自行修改。

public class MazeFailureAnalyzer {

    private static final Logger logger = LoggerFactory.getLogger(MazeFailureAnalyzer.class);

    private List<FailureDetails> failureDetailsList;

    public MazeFailureAnalyzer() {
        failureDetailsList = new ArrayList<>();
    }

    public void addError(String name,String details) {
        failureDetailsList.add(new FailureDetails(name,details));
    }

    public boolean hasError() {
        return !failureDetailsList.isEmpty();
    }

    public void printErrors() {
        logger.error("maze grid error:{}",failureDetailsList.toString());
    }

    private static class FailureDetails {

        private String name;
        private String details;

        public FailureDetails() {
        }

        public FailureDetails(String name, String details) {
            this.name = name;
            this.details = details;
        }

        @Override
        public String toString() {
            return "FailureDetails{" +
                    "name='" + name + '\'' +
                    ", details='" + details + '\'' +
                    '}';
        }
    }

}

最后的最后，我们使用起来就很简单了。只需两句代码就好

//这一行，我们根据传来的type，去筛选具体的实现类
BaseMazeGridTypeInitializer baseMazeGridTypeInitializer = MazeContextHolder.getHolder(type);
//调用baseMazeGridTypeInitializer的具体实现方法createDetail，这里的方法名和参数这些都可以根据需要自行修改。
baseMazeGridTypeInitializer.createDetail(type);

怎么样，这样写起来使得整个功能的耦合度很低，如果我们要加一个type
，那么只需要复制一个实现类就好了，逼格杠杠的。