资讯专栏INFORMATION COLUMN

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

silvertheo / 942人阅读

摘要:当前对象,需要搜索查询字段所属的父类对象查询字段所属字段的父类对象类型查询字段名称此处异常捕获为找不到属性名异常。通过路径以及包名,获取所有类。自定义注解名称。

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

-

一、大致介绍

</>复制代码

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

</>复制代码

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

</>复制代码

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

</>复制代码

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

</>复制代码

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

</>复制代码

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

https://git.oschina.net/ylimhhmily/SpringCloudTutorial.git

SpringCloudTutorial交流QQ群: 235322432

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

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

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/110371.html

相关文章

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

    摘要:当前对象,需要搜索查询字段所属的父类对象查询字段所属字段的父类对象类型查询字段名称此处异常捕获为找不到属性名异常。通过路径以及包名,获取所有类。自定义注解名称。 Reflect 通过反射获取自定义注解值给另外一个对象赋值 - 一、大致介绍 1、今天刚完成这么一个功能模块,需求场景是这样的,我们需要对接许多银行的接口,我们解析银行XML报文后,根据每个银行每个接口我们会解析得到很多Ban...

    岳光 评论0 收藏0
  • 第12章 元编程与注解反射 《Kotlin 项目实战开发》

    摘要:第章元编程与注解反射反射是在运行时获取类的函数方法属性父类接口注解元数据泛型信息等类的内部信息的机制。本章介绍中的注解与反射编程的相关内容。元编程本质上是一种对源代码本身进行高层次抽象的编码技术。反射是促进元编程的一种很有价值的语言特性。 第12章 元编程与注解、反射 反射(Reflection)是在运行时获取类的函数(方法)、属性、父类、接口、注解元数据、泛型信息等类的内部信息的机...

    joyqi 评论0 收藏0
  • 聊聊Java的注解及实现

    摘要:前言注解就是提供了一种元程序中的元素关联任何信息和着任何元数据的途径和方法。注解是一个接口,程序可以通过反射来获取指定程序元素的对象,然后通过对象来获取注解里面的元数据。注解是及以后版本引入的。综上所述元数据以标签的形式存在于代码中。 前言 Annotation(注解)就是Java提供了一种元程序中的元素关联任何信息和着任何元数据(metadata)的途径和方法。Annotion(注解...

    The question 评论0 收藏0
  • 注解就这么简单

    摘要:上面在将注解信息注入到方法中的时候,我们最后加上了的注解不然就会报错了那它是干什么用的呢只能用于修饰其他的,用于指定被修饰的被保留多长时间。 前言 今天要讲的是注解,对于本章节,最好是有Servlet基础的人查阅~因为单纯是Java基础的话,可能用不上注解这个东西。但如果开发过Servlet,就对@WebServlet不会陌生。 现在的开发都推崇使用注解来进行开发,这样就可以免去写XM...

    FrozenMap 评论0 收藏0
  • Java基础知识整理之注解

    摘要:注解提供了一种安全的类似注释的机制,用来将任何的信息或元数据与程序元素类方法成员变量等进行关联。为程序的元素类方法成员变量加上更直观更明了的说明,这些说明与程序的业务逻辑无关,并且提供给指定的工具或框架使用。 什么是注解? Annotation 是 Java5 之后开始引入的新特性,中文为注解。注解提供了一种安全的类似注释的机制,用来将任何的信息或元数据(metadata)与程序元素(...

    blastz 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<