devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Reflect 通过反射获取自定义注解值给另外一个对象赋值

作者：我家小花儿 | 2024-03-17 12:32:46

赞

踩

reflector 反射赋值

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

Reflect 通过反射获取自定义注解值给另外一个对象赋值

一、大致介绍

  1. 1、今天刚完成这么一个功能模块，需求场景是这样的，我们需要对接许多银行的接口，我们解析银行XML报文后，根据每个银行每个接口我们会解析得到很多BankDTO;
  2. 2、然后我们需要在BankDTO挑出一些必要的字段放到另外一个 ResultDTO 中去，然后将 ResultDTO 的数据入库处理；
  3. 3、而且最关键的是，每个银行的字段五花八门，我们根本没办法统一字段，最初的办法我们是对每个 BankDTO 写了一个转换类转成 ResultDTO；
  4. 4、但是随着接入的银行越来越多了，开发效率也就慢慢的降下来了，然而我就在思考如何优化这个字段转换来转换去的笨重方法；
  5.  
  6. 5、经过辗转反侧的思考，最终自己定义一个注解类，然后将这些注解安插在BankDTO上，而我们需要做的事情就是反射获取注解值然后给ResultDTO赋值即可；
  7. 6、原理就是这么简单，这样写好之后，银行一多，开发人员不够，我们找些不会开发的人员只要告诉他们如何写 BankDTO 对象即可，如何映射字段值即可，最后提交代码就搞定了；
  8. 7、而我在这里主要将一些类贴出来仅供大家参考，如果这种思路在大家工作中用得着的话，相信稍微复用我这思路，功能很快就能水到渠成；

二、实现步骤

2.1 反射工具类，参考网上代码做了稍微调整，整理成符合自己业务逻辑的公用工具类

  1. package com.springms.cloud.reflect.util;
  2.  
  3. import org.slf4j.LoggerFactory;
  4.  
  5. import java.io.File;
  6. import java.io.IOException;
  7. import java.lang.reflect.Field;
  8. import java.lang.reflect.Method;
  9. import java.net.URL;
  10. import java.util.ArrayList;
  11. import java.util.Arrays;
  12. import java.util.Enumeration;
  13. import java.util.List;
  14.  
  15. /**
  16.  * 反射工具类。
  17.  *
  18.  * @author hmilyylimh
  19.  *
  20.  * @version 0.0.1
  21.  *
  22.  * @date 2017/10/24
  23.  */
  24. public class ReflectionUtil {
  25.  
  26.     private static final org.slf4j.Logger Logger = LoggerFactory.getLogger(ReflectionUtil.class);
  27.  
  28.     /**
  29.      * 循环向上转型, 获取对象的 DeclaredField。
  30.      *
  31.      * @param object    : 子类对象，也就是实现类对象；
  32.      * @param fieldName : 父类中的属性名；
  33.      * @return 父类中的属性对象
  34.      */
  35.     public static Field getDeclaredField(Object object, String fieldName) {
  36.         Field field = null;
  37.  
  38.         Class<?> clazz = object.getClass();
  39.         for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
  40.             try {
  41.                 field = clazz.getDeclaredField(fieldName);
  42.                 return field;
  43.             } catch (Exception e) {
  44.                 // 这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
  45.                 // 如果这里的异常打印或者往外抛，则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了
  46.                 // Logger.error("循环向上转型, 获取对象的 DeclaredField 异常, fieldName: {}, object: {}, \n\ne: {}", fieldName, object, CommonUtil.getExceptionStackTrace(e));
  47.             }
  48.         }
  49.  
  50.         return null;
  51.     }
  52.  
  53.     /**
  54.      * 循环向上转型, 获取当前对象以及父类所有对象的属性 Field 字段。
  55.      *
  56.      * @param objectClass
  57.      * @return
  58.      */
  59.     public static List<Field> getDeclaredSuperFields(Class<?> objectClass) {
  60.         List<Field> declaredFieldList = new ArrayList<Field>();
  61.  
  62.         Class<?> tempClass = objectClass;
  63.         try {
  64.             while(true){
  65.                 if(tempClass == Object.class){
  66.                     break;
  67.                 }
  68.  
  69.                 declaredFieldList.addAll(Arrays.asList(tempClass.getDeclaredFields()));
  70.                 tempClass = tempClass.getSuperclass();
  71.             }
  72.         } catch (Exception e) {
  73.             // 这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
  74.             // 如果这里的异常打印或者往外抛，则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了
  75.             Logger.error("循环向上转型, 获取当前对象以及父类所有对象的属性 Field 字段异常, objectClass: {}, \n\ne: {}", objectClass, e);
  76.         }
  77.  
  78.         return declaredFieldList;
  79.     }
  80.  
  81.     /**
  82.      * 循环向上转型, 获取对象的 DeclaredMethod。
  83.      *
  84.      * @param object         : 子类对象，也就是实现类对象；
  85.      * @param methodName     : 父类中的方法名；
  86.      * @param parameterTypes : 父类中的方法参数类型；
  87.      * @return 父类中的方法对象
  88.      */
  89.     public static Method getDeclaredMethod(Object object, String methodName, Class<?>... parameterTypes) {
  90.         Method method = null;
  91.  
  92.         for (Class<?> clazz = object.getClass(); clazz != Object.class; clazz = clazz.getSuperclass()) {
  93.             try {
  94.                 method = clazz.getDeclaredMethod(methodName, parameterTypes);
  95.                 return method;
  96.             } catch (Exception e) {
  97.                 // 这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
  98.                 // 如果这里的异常打印或者往外抛，则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了
  99.                 // Logger.error("循环向上转型, 获取对象的 DeclaredMethod 异常, methodName: {}, object: {}, parameterTypes: {}, \n\ne: {}", methodName, object, parameterTypes, CommonUtil.getExceptionStackTrace(e));
  100.             }
  101.         }
  102.  
  103.         return null;
  104.     }
  105.  
  106.     /**
  107.      * 获取 Field 字段的值。
  108.      *
  109.      * @param field
  110.      * @param fieldParentObj
  111.      * @return
  112.      */
  113.     public static Object getFieldValue(Field field, Object fieldParentObj) {
  114.         Object value = null;
  115.         try {
  116.             field.setAccessible(true);
  117.             value = field.get(fieldParentObj);
  118.         } catch (Exception e) {
  119.             Logger.error("获取 Field 字段的值异常, field: {}, fieldParentObj: {}, \n\ne: {}", field, fieldParentObj, e);
  120.         }
  121.         return value;
  122.     }
  123.  
  124.     /**
  125.      * 设置 Field 字段的值。
  126.      *
  127.      * @param field
  128.      * @param fieldParentObj
  129.      * @param newValueObj
  130.      */
  131.     public static void setFieldValue(Field field, Object fieldParentObj, Object newValueObj) {
  132.         try {
  133.             field.setAccessible(true);
  134.             field.set(fieldParentObj, newValueObj);
  135.         } catch (Exception e) {
  136.             Logger.error("设置 Field 字段的值异常, field: {}, fieldParentObj: {}, newValueObj: {}, \n\ne: {}", field,
  137.                     fieldParentObj,
  138.                     newValueObj, e);
  139.         }
  140.     }
  141.  
  142.     /**
  143.      * 获取当前对象中子对象的属性。
  144.      *
  145.      * @param parentObj：当前对象，需要搜索查询字段所属的父类对象；
  146.      * @param searchFieldParentClass：查询字段所属字段的父类对象Class类型；
  147.      * @param searchFieldName：查询字段名称；
  148.      * @return new Object[] { searchFieldParentObject, searchField, searchFieldValue }
  149.      */
  150.     public static Object[] getChildAttr(Object parentObj, Class<?> searchFieldParentClass, String searchFieldName) {
  151.         if (parentObj == null) {
  152.             return null;
  153.         }
  154.  
  155.         Class<?> parentObjClass = parentObj.getClass();
  156.         Field foundedField = null;
  157.         Object foundedFieldValue = null;
  158.         Object[] result = null;
  159.         try {
  160.             foundedField = parentObjClass.getDeclaredField(searchFieldName);
  161.             foundedField.setAccessible(true);
  162.             foundedFieldValue = foundedField.get(parentObj);
  163.  
  164.             return new Object[]{parentObj, foundedField, foundedFieldValue};
  165.         } catch (SecurityException e) {
  166.             e.printStackTrace();
  167.         } catch (NoSuchFieldException e) {
  168.             // 此处异常捕获为：找不到属性名异常。
  169.             // 注意在此处我们要手工去帮它找到field应该对象到哪个对象里的值，因为我们不知道它们之间的关系，所以需要手工指定关系，找哪个对象去关联
  170.             result = getChildObjAttr(parentObj, parentObjClass, searchFieldParentClass, searchFieldName);
  171.         } catch (IllegalArgumentException e) {
  172.             Logger.error("获取当前对象中子对象的属性异常, searchFieldParentClass: {}, searchFieldName: {}, parentObj: {}, \n\ne: " +
  173.                             "{}", searchFieldParentClass, searchFieldName,
  174.                     parentObj, e);
  175.         } catch (IllegalAccessException e) {
  176.             Logger.error("获取当前对象中子对象的属性异常, searchFieldParentClass: {}, searchFieldName: {}, parentObj: {}, \n\ne: " +
  177.                             "{}", searchFieldParentClass, searchFieldName,
  178.                     parentObj, e);
  179.         }
  180.         return result;
  181.     }
  182.  
  183.     /**
  184.      * 获取 parentObj 对象中子类对象的属性。
  185.      *
  186.      * @param parentObj：当前对象，需要搜索查询字段所属的父类对象；
  187.      * @param parentObjClass：当前对象类名称类型，需要搜索查询字段所属的父类类名称类型；
  188.      * @param searchFieldParentClass：查询字段所属字段的父类对象Class类型；
  189.      * @param searchFieldName：查询字段名称；
  190.      * @return new Object[] { searchFieldParentObject, searchField, searchFieldValue }
  191.      */
  192.     private static Object[] getChildObjAttr(Object parentObj, Class<?> parentObjClass, Class<?>
  193.             searchFieldParentClass, String
  194.                                                     searchFieldName) {
  195.         Field[] childFields = parentObjClass.getDeclaredFields();
  196.         Field childField = null;
  197.         Class<?> childFieldType = null;
  198.         for (int i = 0; i < childFields.length; i++) {
  199.             childField = childFields[i];
  200.             childFieldType = childField.getType();
  201.  
  202.             if (!childFieldType.isMemberClass()) {
  203.                 if (childFieldType.equals(searchFieldParentClass)) {
  204.                     return getChildObjAttrDetail(parentObj, childField, searchFieldName);
  205.                 }
  206.             } else {
  207.                 return getChildAttr(getFieldValue(childField, parentObj), searchFieldParentClass, searchFieldName);
  208.             }
  209.         }
  210.         return null;
  211.     }
  212.  
  213.     /**
  214.      * 获取 parentObj 对象中子类对象的明细属性。
  215.      *
  216.      * @param parentObj：当前对象，需要搜索查询字段所属的父类对象；
  217.      * @param parentObjChildField：当前对象子对象，需要搜索查询字段所属的父类对象的子对象；
  218.      * @param searchFieldName：查询字段名称；
  219.      * @return new Object[] { searchFieldParentObject, searchField, searchFieldValue }
  220.      */
  221.     private static Object[] getChildObjAttrDetail(Object parentObj, Field parentObjChildField, String searchFieldName) {
  222.         parentObjChildField.setAccessible(true);
  223.         Object searchFieldParentObject = null;
  224.         Class<?> childClass = null;
  225.         Field searchField = null;
  226.         Object searchFieldValue = null;
  227.         try {
  228.             searchFieldParentObject = parentObjChildField.get(parentObj);
  229.             childClass = searchFieldParentObject.getClass();
  230.             searchField = childClass.getDeclaredField(searchFieldName);
  231.  
  232.             searchField.setAccessible(true);
  233.             searchFieldValue = searchField.get(searchFieldParentObject);
  234.  
  235.             return new Object[]{searchFieldParentObject, searchField, searchFieldValue};
  236.         } catch (IllegalArgumentException e) {
  237.             Logger.error("获取 parentObj 对象中子类对象的明细属性异常, searchFieldName: {}, parentObj: {}, parentObjChildField: {}, " +
  238.                     "\n\ne: " +
  239.                     "{}", searchFieldName, parentObj, parentObjChildField, e);
  240.         } catch (SecurityException e) {
  241.             Logger.error("获取 parentObj 对象中子类对象的明细属性异常, searchFieldName: {}, parentObj: {}, parentObjChildField: {}, " +
  242.                     "\n\ne: " +
  243.                     "{}", searchFieldName, parentObj, parentObjChildField, e);
  244.         } catch (IllegalAccessException e) {
  245.             Logger.error("获取 parentObj 对象中子类对象的明细属性异常, searchFieldName: {}, parentObj: {}, parentObjChildField: {}, " +
  246.                     "\n\ne: " +
  247.                     "{}", searchFieldName, parentObj, parentObjChildField, e);
  248.         } catch (NoSuchFieldException e) {
  249.             Logger.error("获取 parentObj 对象中子类对象的明细属性异常, searchFieldName: {}, parentObj: {}, parentObjChildField: {}, " +
  250.                     "\n\ne: " +
  251.                     "{}", searchFieldName, parentObj, parentObjChildField, e);
  252.         }
  253.  
  254.         return null;
  255.     }
  256.  
  257.     /**
  258.      * 获取接口中所有实现类。
  259.      *
  260.      * @param interfaceClass
  261.      * @return
  262.      */
  263.     public static List<Class<?>> getAllImplClasses(Class<?> interfaceClass) {
  264.         if (!interfaceClass.isInterface()) {
  265.             return null;
  266.         }
  267.  
  268.         try {
  269.             List<Class<?>> resultClassList = new ArrayList<Class<?>>();
  271.             // 获得接口所在的当前包名
  272.             String packageName = interfaceClass.getPackage().getName();
  273.  
  274.             // 获取接口所在处的包名下的所有实现类
  275.             List<Class<?>> allClass = getClassesByPackageName(packageName);
  276.             for (int i = 0; i < allClass.size(); i++) {
  277.                 if (interfaceClass.isAssignableFrom(allClass.get(i))) {
  278.                     if (!interfaceClass.equals(allClass.get(i))) {// 本身加不进去
  279.                         resultClassList.add(allClass.get(i));
  280.                     }
  281.                 }
  282.             }
  283.  
  284.             return resultClassList;
  285.         } catch (Exception e) {
  286.             Logger.error("获取接口中所有实现类异常, interfaceClass: {}, \n\ne: {}", interfaceClass, e);
  287.             return null;
  288.         }
  289.     }
  290.  
  291.     /**
  292.      * 通过包名获取当前包名下所有的类。
  293.      *
  294.      * @param packageName
  295.      * @return
  296.      * @throws IOException
  297.      * @throws ClassNotFoundException
  298.      */
  299.     private static List<Class<?>> getClassesByPackageName(String packageName) throws IOException,
  300.             ClassNotFoundException {
  301.         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
  302.         String path = packageName.replace('.', '/');
  303.         Enumeration<URL> resources = classLoader.getResources(path);
  304.         List<File> dirs = new ArrayList<File>();
  305.         while (resources.hasMoreElements()) {
  306.             URL resource = resources.nextElement();
  307.             dirs.add(new File(resource.getFile()));
  308.         }
  309.         List<Class<?>> resultClassList = new ArrayList<Class<?>>();
  310.         for (File directory : dirs) {
  311.             resultClassList.addAll(findClasses(directory, packageName));
  312.         }
  313.         return resultClassList;
  314.     }
  315.  
  316.     /**
  317.      * 通过路径以及包名，获取所有类。
  318.      *
  319.      * @param directory
  320.      * @param packageName
  321.      * @return
  322.      * @throws ClassNotFoundException
  323.      */
  324.     private static List<Class<?>> findClasses(File directory, String packageName) throws ClassNotFoundException {
  325.         List<Class<?>> resultClassList = new ArrayList<Class<?>>();
  326.         if (!directory.exists()) {
  327.             return resultClassList;
  328.         }
  329.  
  330.         File[] files = directory.listFiles();
  331.         for (File file : files) {
  332.             if (file.isDirectory()) {
  333.                 assert !file.getName().contains(".");
  334.  
  335.                 resultClassList.addAll(findClasses(file, packageName + '.' + file.getName()));
  336.             } else if (file.getName().endsWith(".class")) {
  337.                 resultClassList.add(Class.forName(packageName + "." + file.getName().substring(0, file.getName()
  338.                         .length() - 6)));
  339.             }
  340.         }
  341.         return resultClassList;
  342.     }
  343. }

2.2 自定义注解类，主要用来安插在银行响应类BankDTO身上的；

  1. package com.springms.cloud.reflect.util;
  2.  
  3. import java.lang.annotation.*;
  4.  
  5. /**
  6.  * 成员字段注解（注解加在解析银行返回的对象中）。
  7.  *
  8.  * @author hmilyylimh
  9.  *
  10.  * @version 0.0.1
  11.  *
  12.  * @date 2017/10/24
  13.  *
  14.  */
  15. @Target(ElementType.FIELD)
  16. @Retention(RetentionPolicy.RUNTIME)
  17. @Inherited
  18. public @interface CustomFieldAnnotation {
  19.  
  20.     /**
  21.      * 自定义注解名称。
  22.      *
  23.      * @return
  24.      */
  25.     String customFieldName() default "";
  26.  
  27.     /**
  28.      * 自定义注解类型。
  29.      *
  30.      * @return
  31.      */
  32.     CustomFieldType customFieldType() default CustomFieldType.PRIMITIVE;
  33.  
  34.     /**
  35.      * 标识字段是否有效。
  36.      *
  37.      * @return
  38.      */
  39.     boolean isEnable() default true;
  40.  
  41.     /**
  42.      * 是否重新刷写。
  43.      *
  44.      * @return
  45.      */
  46.     boolean isReWrite() default true;
  47.  
  48.     /**
  49.      * 是否是子类属性，是的话，则根据后面的子类所属 Class 寻找字段属性。
  50.      *
  51.      * @return
  52.      */
  53.     boolean isChild() default false;
  54.  
  55.     /**
  56.      * 自定义注解类型
  57.      */
  58.     public static enum CustomFieldType {
  59.  
  60.         /**
  61.          * 未知类型
  62.          */
  63.         Unknow,
  64.  
  65.         /**
  66.          * 原生类型
  67.          */
  68.         PRIMITIVE,
  69.  
  70.         /**
  71.          * 类成员类型
  72.          */
  73.         CLASS,
  74.  
  75.         /**
  76.          * 数组类型
  77.          */
  78.         ARRAY,
  79.  
  80.         /**
  81.          * 列表类型
  82.          */
  83.         LIST;
  84.  
  85.         public static CustomFieldType valueof(String fieldType) {
  86.             if (CustomFieldType.PRIMITIVE.toString().equalsIgnoreCase(fieldType)) {
  87.                 return PRIMITIVE;
  88.             } else if (CustomFieldType.CLASS.toString().equalsIgnoreCase(fieldType)) {
  89.                 return CLASS;
  90.             } else if (CustomFieldType.ARRAY.toString().equalsIgnoreCase(fieldType)) {
  91.                 return ARRAY;
  92.             } else if (CustomFieldType.LIST.toString().equalsIgnoreCase(fieldType)) {
  93.                 return LIST;
  94.             } else {
  95.                 return Unknow;
  96.             }
  97.         }
  98.     }
  99. }

2.3 反射获取注解值并给 ResultDTO 赋值的解析器类，非常非常重要的类

  1. package com.springms.cloud.reflect.util;
  2.  
  3. import org.apache.commons.lang3.StringUtils;
  4. import org.slf4j.LoggerFactory;
  5.  
  6. import java.lang.reflect.Array;
  7. import java.lang.reflect.Field;
  8. import java.lang.reflect.ParameterizedType;
  9. import java.lang.reflect.Type;
  10. import java.util.ArrayList;
  11. import java.util.List;
  12.  
  13. /**
  14.  * 注解反射解析器。
  15.  *
  16.  * @author hmilyylimh
  17.  *
  18.  * @version 0.0.1
  19.  *
  20.  * @date 2017/10/24
  21.  *
  22.  */
  23. public class AnnotationReflectParser {
  24.  
  25.     private static final org.slf4j.Logger Logger = LoggerFactory.getLogger(AnnotationReflectParser.class);
  26.  
  27.     /**
  28.      * 开始解析。
  29.      *
  30.      * @param bankObject：银行报文对象。
  31.      * @param resultObject：解析后的通用对象。
  32.      */
  33.     public static boolean start(Object bankObject, Object resultObject) {
  34.         try {
  35.             convert(bankObject, resultObject);
  36.             return true;
  37.         } catch (Exception e) {
  38.             Logger.error("开始解析出现最外层异常，bankObject: {}, resultObject: {}", bankObject, resultObject);
  39.             return false;
  40.         }
  41.     }
  42.  
  43.     /**
  44.      * 循环嵌套解析，该方法会被循环调用多次。
  45.      *
  46.      * @param bankObject：银行报文对象。
  47.      * @param resultObject：解析后的通用对象。
  48.      */
  49.     private static void convert(Object bankObject, Object resultObject) {
  50.         if (bankObject == null) {
  51.             Logger.error("循环嵌套解析，传入 bankObject 为空, bankObject: {}, resultObject: {}", bankObject, resultObject);
  52.             throw new RuntimeException("循环嵌套解析，传入 bankObject 为空");
  53.         }
  54.         if (resultObject == null) {
  55.             Logger.error("循环嵌套解析，传入 resultObject 为空, bankObject: {}, resultObject: {}", bankObject, resultObject);
  56.             throw new RuntimeException("循环嵌套解析，传入 resultObject 为空");
  57.         }
  58.  
  59.         Class<?> bankObjClass = bankObject.getClass();
  60.         List<Field> bankFields = ReflectionUtil.getDeclaredSuperFields(bankObjClass);
  61.         if (bankFields == null || bankFields.isEmpty()) {
  62.             Logger.error("循环嵌套解析，bankObject 对象内没有 Field 属性字段, bankObject: {}, resultObject: {}", bankObject,
  63.                     resultObject);
  64.             return;
  65.         }
  66.  
  67.         CustomFieldAnnotation customFieldAnnotation = null;
  68.         CustomFieldAnnotation.CustomFieldType customFieldType = null;
  69.         for (Field bankField : bankFields) {
  70.             customFieldAnnotation = bankField.getAnnotation(CustomFieldAnnotation.class);
  71.             // 过滤没有注解的字段
  72.             if (customFieldAnnotation == null) {
  73.                 // Logger.error("循环嵌套解析，过滤没有注解的字段, bankField: {}, bankObject: {}, resultObject: {}", bankField, bankObject, resultObject);
  74.                 continue;
  75.             }
  76.  
  77.             // 过滤已经禁用的字段
  78.             if (!customFieldAnnotation.isEnable()) {
  79.                 Logger.error("循环嵌套解析，过滤已经禁用的字段, bankField: {}, bankObject: {}, resultObject: {}", bankField,
  80.                         bankObject, resultObject);
  81.                 continue;
  82.             }
  83.  
  84.             // 过滤没有定义类型的字段
  85.             customFieldType = customFieldAnnotation.customFieldType();
  86.             if (customFieldType == null || customFieldType == CustomFieldAnnotation.CustomFieldType.Unknow) {
  87.                 Logger.error("循环嵌套解析，过滤没有定义类型的字段, bankField: {}, bankObject: {}, resultObject: {}", bankField,
  88.                         bankObject, resultObject);
  89.                 continue;
  90.             }
  91.  
  92.             // 针对不同类型走不同分支处理
  93.             switch (customFieldType) {
  94.                 case PRIMITIVE: {
  95.                     setPrimitiveType(bankField, bankObject, customFieldAnnotation, resultObject);
  96.                     break;
  97.                 }
  98.                 case CLASS: {
  99.                     setClassType(bankField, bankObject, customFieldAnnotation, resultObject);
  100.                     break;
  101.                 }
  102.                 case ARRAY: {
  103.                     setArrayType(bankField, bankObject, customFieldAnnotation, resultObject);
  104.                     break;
  105.                 }
  106.                 case LIST: {
  107.                     setListType(bankField, bankObject, customFieldAnnotation, resultObject);
  108.                     break;
  109.                 }
  110.                 case Unknow: {
  111.                     String msg = String.format("循环嵌套解析, 走进了没有逻辑处理的分支类型, customFieldName: %s, bankFieldName: %s",
  112.                             customFieldAnnotation.customFieldName(), bankField.getName());
  113.                     Logger.error(msg);
  114.                     throw new RuntimeException(msg);
  115.                 }
  116.             }
  117.         }
  118.     }
  119.  
  120.     /**
  121.      * 设置基本类型字段。
  122.      *
  123.      * @param bankField
  124.      * @param bankFieldParentObj
  125.      * @param customFieldAnnotation
  126.      * @param resultObject
  127.      */
  128.     private static void setPrimitiveType(Field bankField, Object bankFieldParentObj, CustomFieldAnnotation
  129.             customFieldAnnotation, Object resultObject) {
  130.         try {
  131.             String customFieldName = customFieldAnnotation.customFieldName();
  132.             Object bankFieldValue = ReflectionUtil.getFieldValue(bankField, bankFieldParentObj);
  133.  
  134.             Object[] fieldMapping = AnnotationMapping.getGeneralFieldMapping().get(customFieldName);
  135.             if (fieldMapping == null) {
  136.                 String msg = String.format("设置基本类型字段, 没有设置通用字段映射关系, customFieldName: %s, bankFieldName: %s",
  137.                         customFieldName, bankField.getName());
  138.                 Logger.error(msg);
  139.                 throw new RuntimeException(msg);
  140.             }
  141.             String commonMappingFieldName = (String) fieldMapping[0];
  142.             if (StringUtils.isEmpty(commonMappingFieldName)) {
  143.                 String msg = String.format("设置基本类型字段, 通用对象中的属性字段为空, customFieldName: %s, bankFieldName: %s", customFieldName, bankField.getName());
  144.                 Logger.error(msg);
  145.                 throw new RuntimeException(msg);
  146.             }
  147.  
  148.             // 获取 resultObject 结果对象中 commonMappingFieldName 字段对象 Field
  149.             // 从 resultObject 当前对象找，以及从 resultObject 父类找 commonMappingFieldName 属性字段
  150.             Field commonMappingField = ReflectionUtil.getDeclaredField(resultObject, commonMappingFieldName);
  151.             Object fieldParentObj = resultObject;
  152.             if (customFieldAnnotation.isChild() || commonMappingField == null) {
  153.                 // 如果找不到的话，那么则尝试从 resultObject 对象的子对象递归子对象找 commonMappingFieldName 属性字段
  154.                 Class<?> commonMappingFieldSuperClass = (Class<?>) fieldMapping[1];
  155.                 Object[] childAttr = ReflectionUtil.getChildAttr(resultObject, commonMappingFieldSuperClass,
  156.                         commonMappingFieldName);
  157.                 if (childAttr == null) {
  158.                     String msg = String.format("设置基本类型字段, 在通用对象的子类中没有搜索到通用属性字段, customFieldName: %s, bankFieldName: %s, " +
  159.                             "commonMappingFieldName: %s", customFieldName, bankField.getName(), commonMappingFieldName);
  160.                     Logger.error(msg);
  161.                     throw new RuntimeException(msg);
  162.                 }
  163.  
  164.                 fieldParentObj = childAttr[0];
  165.                 commonMappingField = (Field) childAttr[1];
  166.             }
  167.  
  168.             // 给结果对象 resultObject 赋值，类型对等则直接赋值
  169.             if (customFieldAnnotation.isReWrite()) {
  170.                 ReflectionUtil.setFieldValue(commonMappingField, fieldParentObj, bankFieldValue);
  171.             } else if (commonMappingField.getType() == bankFieldValue.getClass()) {
  172.                 ReflectionUtil.setFieldValue(commonMappingField, fieldParentObj, bankFieldValue);
  173.             }
  174.             // 类型不对等的话，则记录错误日志
  175.             else {
  176.                 Logger.error("设置基本类型字段, 类型不对等的话, 银行字段名称: {}, 通用对象字段名称: {}, bankFieldParentObj: {}, customFieldAnnotation: {}, " +
  177.                         "resultObject: {}", bankField.getName(), customFieldAnnotation.customFieldName(), bankFieldParentObj, customFieldAnnotation, resultObject);
  178.             }
  179.         } catch (Exception e) {
  180.             Logger.error("设置基本类型字段异常, 银行字段名称: {}, 通用对象字段名称: {}, bankFieldParentObj: {}, customFieldAnnotation: {}, " +
  181.                     "resultObject: {}, \n\ne: " +
  182.                     "{}", bankField.getName(), customFieldAnnotation.customFieldName(), bankFieldParentObj, customFieldAnnotation, resultObject, e);
  183.             throw new RuntimeException("设置基本类型字段异常");
  184.         }
  185.     }
  186.  
  187.     /**
  188.      * 设置类成员类型字段。
  189.      *
  190.      * @param bankField
  191.      * @param bankFieldParentObj
  192.      * @param customFieldAnnotation
  193.      * @param resultObject
  194.      */
  195.     private static void setClassType(Field bankField, Object bankFieldParentObj, CustomFieldAnnotation
  196.             customFieldAnnotation, Object resultObject) {
  197.         try {
  198.             String customFieldName = customFieldAnnotation.customFieldName();
  199.             Object bankFieldValue = ReflectionUtil.getFieldValue(bankField, bankFieldParentObj);
  200.  
  201.             if (bankFieldValue == null) {
  202.                 Logger.error("设置类成员类型字段，解析银行对象中 {} 属性字段值为空。", bankField.getName());
  203.                 return;
  204.             }
  205.  
  206.             Class<?> bankFieldObjClass = bankFieldValue.getClass();
  207.             Field[] bankFieldObjFields = bankFieldObjClass.getDeclaredFields();
  208.             if (bankFieldObjFields == null || bankFieldObjFields.length == 0) {
  209.                 Logger.error("设置类成员类型字段，bankField 对象内没有 Field 属性字段, bankFieldName: {}, bankFieldParentObj: {}, " +
  210.                         "customFieldAnnotation: {}, resultObject: {}, ", bankField.getName(), bankFieldParentObj,
  211.                         customFieldAnnotation, resultObject);
  212.                 return;
  213.             }
  214.  
  215.             // resultObject 该对象有数据，那么就得在 resultObject 中实例化对应的对象
  216.             Object[] fieldMapping = AnnotationMapping.getGeneralFieldMapping().get(customFieldName);
  217.             if (fieldMapping == null) {
  218.                 String msg = String.format("设置类成员类型字段, 没有设置通用字段映射关系, customFieldName: %s, bankFieldName: %s", customFieldName, bankField.getName());
  219.                 Logger.error(msg);
  220.                 throw new RuntimeException(msg);
  221.             }
  222.             String commonMappingFieldName = (String) fieldMapping[0];
  223.             if (StringUtils.isEmpty(commonMappingFieldName)) {
  224.                 String msg = String.format("设置类成员类型字段, 通用对象中的属性字段为空, customFieldName: %s, bankFieldName: %s", customFieldName, bankField.getName());
  225.                 Logger.error(msg);
  226.                 throw new RuntimeException(msg);
  227.             }
  228.  
  229.             // 从 resultObject 当前对象找，以及从 resultObject 父类找 commonMappingFieldName 属性字段
  230.             Field commonMappingField = ReflectionUtil.getDeclaredField(resultObject, commonMappingFieldName);
  231.             Object fieldParentObj = resultObject;
  232.             if (commonMappingField == null) {
  233.                 // 如果找不到的话，那么则尝试从 resultObject 对象的子对象递归子对象找 commonMappingFieldName 属性字段
  234.                 Class<?> commonMappingFieldSuperClass = (Class<?>) fieldMapping[1];
  235.                 Object[] childAttr = ReflectionUtil.getChildAttr(resultObject, commonMappingFieldSuperClass,
  236.                         commonMappingFieldName);
  237.                 if (childAttr == null) {
  238.                     String msg = String.format("设置类成员类型字段, 在通用对象的子类中没有搜索到通用属性字段, customFieldName: %s, bankFieldName: %s, " +
  239.                             "commonMappingFieldName: %s", customFieldName, bankField.getName(), commonMappingFieldName);
  240.                     Logger.error(msg);
  241.                     throw new RuntimeException(msg);
  242.                 }
  243.  
  244.                 fieldParentObj = childAttr[0];
  245.                 commonMappingField = (Field) childAttr[1];
  246.             }
  247.  
  248.             // 获取 resultObject 结果对象中 Field 字段的值
  249.             if (ReflectionUtil.getFieldValue(commonMappingField, fieldParentObj) == null) {
  250.                 Object newInstance = commonMappingField.getType().newInstance();
  251.                 ReflectionUtil.setFieldValue(commonMappingField, resultObject, newInstance);
  252.             }
  253.  
  254.             convert(bankFieldValue, resultObject);
  255.         } catch (Exception e) {
  256.             Logger.error("设置类成员类型字段异常, bankField: {}, bankFieldParentObj: {}, customFieldAnnotation: {}, " +
  257.                     "resultObject: {}, \n\ne: " +
  258.                     "{}", bankField, bankFieldParentObj, customFieldAnnotation, resultObject, e);
  259.             throw new RuntimeException("设置类成员类型字段异常");
  260.         }
  261.     }
  262.  
  263.     /**
  264.      * 设置数组类型字段。
  265.      *
  266.      * @param bankField
  267.      * @param bankFieldParentObj
  268.      * @param customFieldAnnotation
  269.      * @param resultObject
  270.      */
  271.     private static void setArrayType(Field bankField, Object bankFieldParentObj, CustomFieldAnnotation
  272.             customFieldAnnotation, Object resultObject) {
  273.         try {
  274.             String customFieldName = customFieldAnnotation.customFieldName();
  275.             Object bankFieldValue = ReflectionUtil.getFieldValue(bankField, bankFieldParentObj);
  276.  
  277.             if (bankFieldValue == null) {
  278.                 Logger.error("设置数组类型字段，解析银行对象中 {} 属性字段值为空。", bankField.getName());
  279.                 return;
  280.             }
  281.  
  282.             int length = Array.getLength(bankFieldValue);
  283.             if (length <= 0) {
  284.                 String msg = String.format("设置数组类型字段, 银行数组长度为空, customFieldName: %s, bankFieldName: %s",
  285.                         customFieldName, bankField.getName());
  286.                 Logger.error(msg);
  287.                 return;
  288.             }
  289.  
  290.             // resultObject 该对象有数据，那么就得在 resultObject 中实例化对应的对象
  291.             Object[] fieldMapping = AnnotationMapping.getGeneralFieldMapping().get(customFieldName);
  292.             if (fieldMapping == null) {
  293.                 String msg = String.format("设置数组类型字段, 没有设置通用字段映射关系, customFieldName: %s, bankFieldName: %s", customFieldName, bankField.getName());
  294.                 Logger.error(msg);
  295.                 throw new RuntimeException(msg);
  296.             }
  297.             String commonMappingFieldName = (String) fieldMapping[0];
  298.             if (StringUtils.isEmpty(commonMappingFieldName)) {
  299.                 String msg = String.format("设置数组类型字段, 通用对象中的属性字段为空, customFieldName: %s, bankFieldName: %s", customFieldName, bankField.getName());
  300.                 Logger.error(msg);
  301.                 throw new RuntimeException(msg);
  302.             }
  303.  
  304.             // 从 resultObject 当前对象找，以及从 resultObject 父类找 commonMappingFieldName 属性字段
  305.             Field commonMappingField = ReflectionUtil.getDeclaredField(resultObject, commonMappingFieldName);
  306.             Object fieldParentObj = resultObject;
  307.             if (commonMappingField == null) {
  308.                 // 如果找不到的话，那么则尝试从 resultObject 对象的子对象递归子对象找 commonMappingFieldName 属性字段
  309.                 Class<?> commonMappingFieldSuperClass = (Class<?>) fieldMapping[1];
  310.                 Object[] childAttr = ReflectionUtil.getChildAttr(resultObject, commonMappingFieldSuperClass,
  311.                         commonMappingFieldName);
  312.                 if (childAttr == null) {
  313.                     String msg = String.format("设置数组类型字段, 在通用对象的子类中没有搜索到通用属性字段, customFieldName: %s, bankFieldName: %s, " +
  314.                             "commonMappingFieldName: %s", customFieldName, bankField.getName(), commonMappingFieldName);
  315.                     Logger.error(msg);
  316.                     throw new RuntimeException(msg);
  317.                 }
  318.  
  319.                 fieldParentObj = childAttr[0];
  320.                 commonMappingField = (Field) childAttr[1];
  321.             }
  322.  
  323.             // 获取 resultObject 结果对象中 Field 字段的值
  324.             if (ReflectionUtil.getFieldValue(commonMappingField, fieldParentObj) == null) {
  325.                 Class<?> elementType = commonMappingField.getType();
  326.                 String elementTypeName = elementType.getName();
  327.                 int startIndex = elementTypeName.indexOf("com");
  328.                 int endIndex = elementTypeName.lastIndexOf(";");
  329.                 String innerClassName = elementTypeName.substring(startIndex, endIndex);
  330.                 Class<?> innerClass = Class.forName(innerClassName);
  331.  
  332.                 // 实例化数组
  333.                 Object newInstance = Array.newInstance(innerClass, length);
  334.  
  335.                 // 数组赋值空对象
  336.                 Object[] arrays = (Object[]) newInstance;
  337.                 Object[] bankFieldValueArrays = (Object[]) bankFieldValue;
  338.                 for (int i = 0; i < length; i++) {
  339.                     arrays[i] = innerClass.newInstance();
  340.                 }
  341.                 // 将空数组赋值到 resultObject 结果对象中
  342.                 ReflectionUtil.setFieldValue(commonMappingField, fieldParentObj, newInstance);
  343.  
  344.                 // 循环解析 bankFieldValueArrays 的值放到结果对象中对应的索引位置中
  345.                 for (int i = 0; i < length; i++) {
  346.                     Object itemResultObject = arrays[i];
  347.                     convert(bankFieldValueArrays[i], itemResultObject);
  348.                 }
  349.             }
  350.         } catch (Exception e) {
  351.             Logger.error("设置数组类型字段异常, bankField: {}, bankFieldParentObj: {}, customFieldAnnotation: {}, " +
  352.                     "resultObject: {}, \n\ne: " +
  353.                     "{}", bankField, bankFieldParentObj, customFieldAnnotation, resultObject, e);
  354.             throw new RuntimeException("设置数组类型字段异常");
  355.         }
  356.     }
  357.  
  358.     /**
  359.      * 设置列表类型字段。
  360.      *
  361.      * @param bankField
  362.      * @param bankFieldParentObj
  363.      * @param customFieldAnnotation
  364.      * @param resultObject
  365.      */
  366.     private static void setListType(Field bankField, Object bankFieldParentObj, CustomFieldAnnotation
  367.             customFieldAnnotation, Object resultObject) {
  368.         try {
  369.             String customFieldName = customFieldAnnotation.customFieldName();
  370.             Object bankFieldValue = ReflectionUtil.getFieldValue(bankField, bankFieldParentObj);
  371.  
  372.             if (bankFieldValue == null) {
  373.                 Logger.error("设置列表类型字段，解析银行对象中 {} 属性字段值为空。", bankField.getName());
  374.                 return;
  375.             }
  376.  
  377.             List bankFieldValueList = (List) bankFieldValue;
  378.             int size = bankFieldValueList.size();
  379.             if (size <= 0) {
  380.                 String msg = String.format("设置列表类型字段, 银行列表长度为空, customFieldName: %s, bankFieldName: %s",
  381.                         customFieldName, bankField.getName());
  382.                 Logger.error(msg);
  383.                 return;
  384.             }
  385.  
  386.             // resultObject 该对象有数据，那么就得在 resultObject 中实例化对应的对象
  387.             Object[] fieldMapping = AnnotationMapping.getGeneralFieldMapping().get(customFieldName);
  388.             if (fieldMapping == null) {
  389.                 String msg = String.format("设置列表类型字段, 没有设置通用字段映射关系, customFieldName: %s, bankFieldName: %s", customFieldName, bankField.getName());
  390.                 Logger.error(msg);
  391.                 throw new RuntimeException(msg);
  392.             }
  393.             String commonMappingFieldName = (String) fieldMapping[0];
  394.             if (StringUtils.isEmpty(commonMappingFieldName)) {
  395.                 String msg = String.format("设置列表类型字段, 通用对象中的属性字段为空, customFieldName: %s, bankFieldName: %s", customFieldName, bankField.getName());
  396.                 Logger.error(msg);
  397.                 throw new RuntimeException(msg);
  398.             }
  399.  
  400.             // 从 resultObject 当前对象找，以及从 resultObject 父类找 commonMappingFieldName 属性字段
  401.             Field commonMappingField = ReflectionUtil.getDeclaredField(resultObject, commonMappingFieldName);
  402.             Object fieldParentObj = resultObject;
  403.             if (commonMappingField == null) {
  404.                 // 如果找不到的话，那么则尝试从 resultObject 对象的子对象递归子对象找 commonMappingFieldName 属性字段
  405.                 Class<?> commonMappingFieldSuperClass = (Class<?>) fieldMapping[1];
  406.                 Object[] childAttr = ReflectionUtil.getChildAttr(resultObject, commonMappingFieldSuperClass,
  407.                         commonMappingFieldName);
  408.                 if (childAttr == null) {
  409.                     String msg = String.format("设置列表类型字段, 在通用对象的子类中没有搜索到通用属性字段, customFieldName: %s, bankFieldName: %s, " +
  410.                             "commonMappingFieldName: %s", customFieldName, bankField.getName(), commonMappingFieldName);
  411.                     Logger.error(msg);
  412.                     throw new RuntimeException(msg);
  413.                 }
  414.  
  415.                 fieldParentObj = childAttr[0];
  416.                 commonMappingField = (Field) childAttr[1];
  417.             }
  418.             Type genericType = commonMappingField.getGenericType();
  419.             if(!(genericType instanceof ParameterizedType)){
  420.                 String msg = String.format("设置列表类型字段, 通用对象中的属性字段类型设置有误，设置的不是列表类型, customFieldName: %s, bankFieldName: %s", customFieldName, bankField.getName());
  421.                 Logger.error(msg);
  422.                 return;
  423.             }
  424.  
  425.             // 获取 resultObject 结果对象中 Field 字段的值
  426.             if (ReflectionUtil.getFieldValue(commonMappingField, fieldParentObj) == null) {
  427.                 ParameterizedType parameterizedType = (ParameterizedType)genericType;
  428.                 Class<?> innerClass = (Class) parameterizedType.getActualTypeArguments()[0];//得到对象list中实例的类型
  429.  
  430.                 // 实例化数组
  431.                 List newInstance = new ArrayList();
  432.  
  433.                 // 数组赋值空对象
  434.                 for (int i = 0; i < size; i++) {
  435.                     newInstance.add(innerClass.newInstance());
  436.                 }
  437.                 // 将空数组赋值到 resultObject 结果对象中
  438.                 ReflectionUtil.setFieldValue(commonMappingField, fieldParentObj, newInstance);
  439.  
  440.                 // 循环解析 bankFieldValueArrays 的值放到结果对象中对应的索引位置中
  441.                 for (int i = 0; i < size; i++) {
  442.                     Object itemResultObject = newInstance.get(i);
  443.                     convert(bankFieldValueList.get(i), itemResultObject);
  444.                 }
  445.             }
  446.         } catch (Exception e) {
  447.             Logger.error("设置列表类型字段异常, bankField: {}, bankFieldParentObj: {}, customFieldAnnotation: {}, " +
  448.                     "resultObject: {}, \n\ne: " +
  449.                     "{}", bankField, bankFieldParentObj, customFieldAnnotation, resultObject, e);
  450.             throw new RuntimeException("设置列表类型字段异常");
  451.         }
  452.     }
  453. }

2.4 测试代码，如何调用起我们写的这套功能

  1. package com.springms.cloud.reflect;
  2.  
  3. import com.springms.cloud.reflect.util.AnnotationReflectParser;
  4. import com.springms.cloud.reflect.util.xml.BeanXml;
  5.  
  6. /**
  7.  * 测试类。
  8.  *
  9.  * @author hmilyylimh
  10.  *
  11.  * @version 0.0.1
  12.  *
  13.  * @date 2017/10/24
  14.  *
  15.  */
  16. public class TestReflectDemo {
  17.  
  18.     public static void main(String[] args) {
  19.  
  20.         try {
  21.             String xmlData = getXml();
  22.             Class<?> beanClass = getBeanClassPath();
  23.  
  24.             Object respBankDTO = BeanXml.xml2Bean(xmlData, beanClass);
  25.  
  26.             ResultDTO resultObject = new ResultDTO();
  27.             ResultDTO.Record record = new ResultDTO.Record();
  28.             resultObject.setRecord(record);
  29.  
  30.             boolean finished = AnnotationReflectParser.start(respBankDTO, resultObject);
  31.             System.out.println("finished: " + finished);
  32.             System.out.println("=====================================");
  33.         } catch (Exception e) {
  34.             e.printStackTrace();
  35.         }
  36.     }
  37.  
  38.     /**
  39.      * 这里可以通过路径反射得到 Class 类，如果你的类有规律的话，那完成可以在这个地方通过设定规则出来得到类名路径。
  40.      *
  41.      * 那么我这里呢，就直接拿个例子来试试而已。
  42.      *
  43.      * @return
  44.      */
  45.     private static Class<?> getBeanClassPath() {
  46.         String className = "com.springms.cloud.reflect.BankDTO";
  47.         return getRespBeanClass(className);
  48.     }
  49.  
  50.     private static String getXml() {
  51.         String recvContent = "<?xml version='1.0' encoding='GB2312'?>\n" +
  52.                 "<packet>\n" +
  53.                 "<head>\n" +
  54.                 "<transCode>4469</transCode>  \n" +
  55.                 "<signFlag>0</signFlag>   \n" +
  56.                 "<packetID>1234567890</packetID>      \n" +
  57.                 "<timeStamp>2004-07-28 16:14:29</timeStamp> \n" +
  58.                 "<returnCode>AAAAAAA</returnCode>  \n" +
  59.                 "</head>\n" +
  60.                 "<body>\n" +
  61.                 "<acctNo>246333388999</acctNo>\n" +
  62.                 "<acctName>张三</acctName>\n" +
  63.                 "<acctBalance>199098777.97</acctBalance>\n" +
  64.                 "<subTotBalance>199098777.97</subTotBalance>\n" +
  65.                 "<lists name=\"LoopResult\">\n" +
  66.                 "<list>\n" +
  67.                 "<subAcctNo>1234567890000000</subAcctNo>\n" +
  68.                 "<subAcctBalance>234.56</subAcctBalance>\n" +
  69.                 "<subAcctName>账户名称甲</subAcctName>\n" +
  70.                 "</list>\n" +
  71.                 "</lists>\n" +
  72.                 "</body>\n" +
  73.                 "</packet>";
  74.  
  75.         return recvContent;
  76.     }
  77.  
  78.     /**
  79.      * 获取响应类名的 Class 对象。
  80.      *
  81.      * @return
  82.      */
  83.     private static Class<?> getRespBeanClass(String className) {
  84.         Class<?> respClass = null;
  85.         try {
  86.             respClass = Class.forName(className);
  87.             return respClass;
  88.         } catch (ClassNotFoundException e) {
  89.             throw new RuntimeException(className + " 该响应类路径不存在", e);
  90.         }
  91.     }
  92. }
  93.

2.5 总结

  1. 1、虽然这样写可以偷懒了，也可以招非开发人员直接上手撸代码直接开发功能模块，但是不方便的地方就是得发版升级；
  2. 2、后期想法，我们不是有 "Java运行时动态加载类" 这么一说么？后期准备将这一套代码放在某个目录上传，或者直接放到数据库存储，然后动态加载执行对应功能；
  3. 3、想法虽然不错，路漫漫其修远兮，慢慢努力吧，顺便祝各位猿猿们节日快乐；

三、下载地址

https://gitee.com/ylimhhmily/SpringCloudTutorial.git

SpringCloudTutorial交流QQ群: 235322432

SpringCloudTutorial交流微信群: 微信沟通群二维码图片链接

欢迎关注，您的肯定是对我最大的支持!!!

转载于:https://my.oschina.net/hmilyylimh/blog/1555754

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/256047
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号