Java基础----jdk1.8 反射实验

（写在最前：还没入门的搬砖工的一本正经的胡说八道）

引言：  最近做到的项目中，需要给对接方提供一个公共接口，根据对方传入的XML文件的rootelement分发调用接口，最简单的使用if-else if 模式，但是看着实在太蠢。

场景一：需要根据关键字，进行接口分发

使用if-else模式缺点：

1. 看着蠢
2. 不易阅读（个人观点）
3. 不易维护
4. balabala...不想编了，就是看着不爽

如果只有一两个方法还好，如果方法多了，额。。。如下，自行体会。

 public class TestMethod {

     public Object dispatchMethod(String name, String data) {
         Object obj = null;

         if ("methodA".equal(name)) {
             obj = methodA(data);
         } else if ("methodB".equal(name)) {
             obj = methodB(data);
         } else if (...) {
             ...
         }
         return obj;
     }

     private Object methodA(String data) {
         ...
     }

     private Object methodB(String data) {
         ...
     }

     ...
 }

那么步入正题，我才用的反射模式，匹配目标方法，我认为可以降低维护和阅读成本

开发环境：jdk1.8

实现代码：

• 定义目标方法枚举，包含rootelement信息，调用方法说明，目标方法targetName

 public enum MethodEnum {

     METHODA("MethodA","调用方法A","methodA"),
     METHODB("MethodB","调用方法B","methodB"),
     ;

     @Getter
     private String code; //rootelement

     @Getter
     private String message; 

     @Getter
     private String name; //目标方法名

     private MethodEnum (String code,String message,String name) {
         this.code = code;
         this.message = message;
         this.name = name;
     }

     public static MethodEnum fromCode(String code) { //根据传入code，筛选目标方法
         for (DockingFliggyHotelEnum p : DockingFliggyHotelEnum.values()) {
             if(p.code.equalsIgnoreCase(code)) {
                 return p;
             }
         }
         return null;
     }
 }

• 定义反射方法工具类

 /**
  *  定义工具类
 **/
 public class MethodUtil {

     public static Method getTargetMethod(Class clazz, String methodName) {
         Method[] methods = clazz.getDeclaredMethods(); //获取所有方法，包含private
         if (methods != null && methods.length > 0) {
             String regEx  = "^" + methodName +"$";//获取所要查找到的方法名称要匹配此正则
             Pattern pattern = Pattern.compile(regEx);
             for (Method method : methods) {
                 Matcher matcher = pattern.matcher(method.getName());
                 boolean rs = matcher.find();
                 if(rs){
                     return method;
                 }
             }
         }
         return null;
     }

     public static Object executeTargrtMethod(Class clazz, String methodName, String xmlData) {
         Object obj = null;
         try {
             Method method = getTargetMethod(clazz, methodName);
             obj = method.invoke(clazz, xmlData);
         } catch (Exception e) {

         }
         return obj;
     }

 }

• 具体分发

 public class TestDispatch {

     public Object dispatch(String root, String xml) {
         String name = MethodEnum.fromCode(root).name;
         Object obj = executeTargrtMethod(this.getClass(), name, xml)
         return obj;
     }

     private Object methodA(String xml) {
         Object obj = null;
         ...
         return obj;
     }

     private Object methodB(String xml) {
         Object obj = null;
         ...
         return obj;
     }

     ...
 }

对于业务代码结构清晰明了，是不是看着爽多了。

对于类似的场景很多，都可以使用反射机制。

场景二：项目中多处需要大批量插入数据，提取一个公共方法，减少代码行数，何乐而不为呢？

对了，顺便说一下这个批量插入方法，数据库使用mysql，项目框架springboot，jdk1.8，5000条数据插入一次，耗时0.8s左右。

 　　 /**
      * @param batchCount 一次批量插入数据量
      * @param target 目标方法关键字
      * @param list 需要插入的大批量数据
      * @throws Exception
      */
     public static void batchInsert(Class clazz, int batchCount, String target, List<?> list) throws Exception{
         Method method = getTargetMethod(target);
         int batchLastIndex = batchCount - 1;//每批最后一个的下标
         for(int index = 0; index < list.size()-1;){
             if(batchLastIndex > list.size()-1){
                 batchLastIndex = list.size() - 1;
                 if (method != null) {
                     method.invoke(clazz,list.subList(index, batchLastIndex));
                 }
                 break;//数据插入完毕,退出循环
             }else{
                 if (method != null) {
                     method.invoke(clazz,list.subList(index, batchLastIndex));
                 }
                 index = batchLastIndex + 1;//设置下一批下标
                 batchLastIndex = index + (batchCount - 1);
             }
         }
     }

实验结束，代码分析下次在写了。

写在最后

代码是伪代码，可能啥地方写得不对，欢迎指正

对于以上两种场景，我目前只能想到这种方法。。。如果你有更好的，欢迎来怼我