利用 策略模式+反射+枚举+单例 优化if-else 或者 switch case

在最近的项目中，涉及到根据传入的参数来新建不同的类，然后调用不同类的相同方法，因为太多if-else 或者 switch case ，但是这样的写的代码看起来很累赘（性能的提升我没去验证，感兴趣的朋友可以去试试），所以想到了如题的方法。其实这个也可以用单纯的策略模式去完成。废话不多说，直接上代码

1.首先是枚举类 TypeEnum：

枚举类的作用：用于存放需要进行操作的分支

package com.railway.bigdata.electric.streaming.comm.pg;

/**
 * @author [email protected]
 * @date 2018/11/27 14:49
 */
public enum TypeEnum{
	//枚举类的values  列表
    A_PROCESS("A","com.railway.bigdata.electric.streaming.comm.pg.signalling.AProcess"),
	B_PROCESS("B","com.railway.bigdata.electric.streaming.comm.pg.signalling.BProcess"),
    C_PROCESS("C","com.railway.bigdata.electric.streaming.comm.pg.signalling.CProcess"),

    private String type;
    private String clazz;

    private RefelDbTypeEnum(String type,String clazz){
        this.type=type;
        this.clazz=clazz;
    }

    public String type() {
        return type;
    }

    public String clazz(){
        return  clazz;
    }
}

2.策略模式的父类 AbstractStrategy

package com.railway.bigdata.electric.streaming.comm.pg;
/**策略模式的抽象父类
 * @author [email protected]
 * @date 2018/11/27 15:06
 */
public abstract class AbstractStrategy{
    public void  excute(){};
}

3 策略模式子类 AStrategy

这里，我只写了A子类，其他的B、C子类和A一样，所以这里就省略了

package com.railway.bigdata.electric.streaming.comm.pg;

/**
 * 策略模式的子类
 * @author [email protected]
 * @date 2018/11/27 14:57
 */
public class AStrategy extends AbstractStrategy{

    @Override
    public void excute() {
        System.out.println("子类A的方法被调用  ....");
    }
}

4 单例类StrategySingleton

通多单例，静态加载枚举的具体操作分支，将它存入map中

package com.railway.bigdata.electric.streaming.comm.pg;

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

/**单例  ： 通过枚举类 将传入的参数 - 类路径  put到map中
 * @author [email protected]
 * @date 2018/11/27 15:01
 */
public class StrategySingleton {
    /*
    * 单例模式
    * */
    private static StrategySingleton instance=null;

    private StrategySingleton(){
    }

    private static synchronized void syncInit() {
        if (instance == null) {
            instance = new StrategySingleton();
        }
    }

    public static StrategySingleton getInstance() {
        if (instance == null) {
            syncInit();
        }
        return instance;
    }
    //使用map 存放 参数-类路径  的信息
    private static Map strategyMap = new HashMap<>();
    //使用静态块存放
    static{
        //遍历枚举类的数据
        for (TypeEnum t : TypeEnum.values()){
            strategyMap.put(t.type(), t.clazz());}
    }
    public String strategy(String type){
        return strategyMap.get(type);
    }


}

5.逻辑类接口 ManagerStrategy

用于被主类调用

package com.railway.bigdata.electric.streaming.comm.pg;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

/**用于主类调用  入口
 * @author [email protected]
 * @date 2018/11/27 14:47
 */
public   class ManagerStrategy {

    /**
     * 此方法 通过反射将TypeEnum中映射的类实例化
     * @param type
     */
    public static void excuteStrategy(String type){
        //调用单例类 获得类反射路径
        String classPath=StrategySingleton.getInstance().strategy(type);
        try {
            //方式一：先产生类，再使用类去调用方法
            Class class1=Class.forName(classPath);
            Strategy d= (AbstractStrategy) class1.newInstance();
            d.excute();

            //方式二：先得到方法，再通过invoke使得类反调过来
            //Class class1=Class.forName(classPath);
           // Method excute =class1.getDeclaredMethod("excute");
            //excute.invoke(class1.newInstance());


        } catch (ClassNotFoundException e) {
            e.printStackTrace();
      /*  } catch (NoSuchMethodException e) {
            e.printStackTrace();*/
        } catch (IllegalAccessException e) {
            e.printStackTrace();
       /* } catch (InvocationTargetException e) {
            e.printStackTrace();*/
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }


}

6 最后上一个测试主类 Test1

package com.railway.bigdata.electric.streaming.comm.pg;

/**
 * 枚举+反射 实现根据不同的参数，选择不同的类执行对应的方法
 * @author [email protected]
 * @date 2018/11/27 15:05
 */
public class Test1 {
    public static void main(String[] args) {
        String type="A";
        //调用接口类的方法
        ManagerStrategy.excuteStrategy(type);
       
    }

}

执行结果：
子类A的方法被调用 …