利用递归遍历获取复杂对象中所有目标属性的值（三）

待我称王封你为后i 2022-03-14 15:08 586阅读 0赞 
  1.    关于遍历复杂对象中目标属性的值的文章，这是我写的第三篇，也是目前为止我能想到的遍历效率最高的一篇，再前两篇基础上做了相关完善和优化，主要是思路改变了。
  3.   具体实现思路：在复杂对象的目标属性上增加自定义注解，目标属性所属类也可能是某个bo的属性，则在这个属性上增加另一个自定义注解，然后利用递归遍历。
  5.   闲话少说，直接上代码

一、两个自定义注解

  1. /**
  2.  * @author: lsl
  3.  * @date: 2019/3/1
  4.  *  作用：字典类属性注解
  5.  */
  6. @Target(value = {ElementType.TYPE,ElementType.FIELD})
  7. @Retention(RetentionPolicy.RUNTIME)
  8. public @interface DictClass {
  9.     public String value() default "";
  10. }
  12. /**
  13.  * @author: lsl
  14.  * @date: 2019/3/1
  15.  *  字典属性注解
  16.  */
  17. @Target(value = {ElementType.FIELD})
  18. @Retention(RetentionPolicy.RUNTIME)
  19. public @interface DictField {
  20.     public String dictCode();
  22.     public String transColumName() default "";
  24.     public String isSpeRule() default "0";
  25. }

二、核心代码，递归遍历类。主要方法是ergodicObject。入口方法是objectCodeTrans。

  1. package com.newcore.pcms.common.support.codetrans.util;
  3. import com.halo.core.cache.api.CacheMetaInfoFactory;
  4. import com.halo.core.cache.api.CacheService;
  5. import com.halo.core.cache.models.IndexItem;
  6. import com.halo.core.cache.support.redis.holder.TableHolder;
  7. import com.halo.core.common.SpringContextHolder;
  8. import com.halo.core.common.models.XOR;
  9. import com.halo.core.exception.BusinessException;
  10. import com.newcore.pcms.common.support.codetrans.annotation.DictClass;
  11. import com.newcore.pcms.common.support.codetrans.annotation.DictField;
  12. import com.newcore.pcms.common.support.codetrans.dao.api.ServiceAttrDictDao;
  13. import com.newcore.pcms.common.support.codetrans.models.po.pcms.PCodeTransDefPO;
  14. import com.newcore.pcms.common.support.codetrans.models.po.pcms.ServiceAttrDictBO;
  15. import org.apache.commons.lang3.StringUtils;
  16. import org.slf4j.Logger;
  17. import org.slf4j.LoggerFactory;
  19. import java.beans.IntrospectionException;
  20. import java.beans.PropertyDescriptor;
  21. import java.lang.reflect.Field;
  22. import java.lang.reflect.InvocationTargetException;
  23. import java.lang.reflect.Method;
  24. import java.util.ArrayList;
  25. import java.util.List;
  26. import java.util.Map;
  28. /**
  29.  * 对象级的码表转换工具类
  30.  * @author: lsl
  31.  * @date: 2018/12/12
  32.  */
  33. public class CodeTransHolderUtils {
  35.     private static Logger logger = LoggerFactory.getLogger(CodeTransHolderUtils.class);
  37.     int num=0;
  38. //    public static CacheMetaInfoFactory getCacheMetaInfoFactory() {
  39. //        return (CacheMetaInfoFactory) SpringContextHolder.getBean("cacheMetaInfoFactory");
  40. //    }
  41. //
  42. //    public static CacheService getCacheService() {
  43. //        return (CacheService) SpringContextHolder.getBean("cacheService");
  44. //    }
  46.     /**
  47.      * 对服务中参数中的属性是字典，进行全部码值转换
  48.      * @param srcSysCode            源系统
  49.      * @param destSysCode           目标系统
  50.      * @param obj                    服务中方法入参
  51.      * @return
  52.      */
  53.     public static List<String> objectCodeTrans(String srcSysCode, String destSysCode,  Object obj) {
  54.         List<String> listNotIncludeAttr = new ArrayList<>();
  55. //        boolean methodParamNameNotBlank = (ConstantTools.FLAG_Y).equals(forwardFlag) ? StringUtils.isNotBlank(serMethodParamName) : true;
  56.         boolean notBlankFlag = StringUtils.isNotBlank(srcSysCode) && StringUtils.isNotBlank(destSysCode) && (null!= obj) ;
  57.         logger.info("objectCodeTrans方法的参数：srcSysCode=" + srcSysCode + ",destSysCode=" + destSysCode );
  58.         CodeTransHolderUtils utils = new CodeTransHolderUtils();
  59.         long startTime = System.currentTimeMillis();
  60.         if (notBlankFlag){
  62.             if (obj instanceof List<?>) {
  63.                 utils.ergodicList(srcSysCode, destSysCode,  (List) obj , listNotIncludeAttr);
  64.             } else {
  65.                 utils.ergodicObject(srcSysCode, destSysCode,  obj, listNotIncludeAttr);
  66.             }
  67.         }
  68.         long endTime = System.currentTimeMillis();
  69.         System.err.println("对象级码表转换耗时=" + (endTime-startTime) + ",递归次数=" + utils.num);
  70.         return listNotIncludeAttr;
  71.     }
  75.     /**
  76.      *
  77.      * @param srcSysCode            源系统
  78.      * @param destSysCode           目标系统
  79.      * @param listParam             服务方法入参(list)
  80.      * @param listNotIncludeAttr   入参字典属性未在码表中找到对应的目标系统字典值的属性名
  81.      * @param <T>                    码表转换后的入参
  82.      */
  83.     public  <T> void ergodicList(String srcSysCode, String destSysCode,  List<T> listParam,  List<String> listNotIncludeAttr) {
  84.         listParam.stream().forEach(t -> {
  85.             ergodicObject(srcSysCode, destSysCode,  t, listNotIncludeAttr);
  86.         });
  87.     }
  89.     /**
  90.      * 对象级码表转换。把t中指定attribute属性的值更改为目标系统的字典值，并把在目标系统中没有找到字典值的属性放到listNotIncludeAttr
  91.      * 注意：
  92.      * 1、t中的属性类型不能包含以下集合嵌套类型：Set、List<Map<K,V>、Map<K,List<BO>>
  93.      * 2、t中的属性类型可以是BO、数组、List<BO>、Map<K,BO>
  94.      * 3、属性名一定要规范，比如private PCodeTransDefPO pCodeTransDefPO(不规范)，这样利用反射找不到getter方法，应该改成codeTransDefPO或者PCodeTransDefPO
  95.      * @param srcSysCode            源系统
  96.      * @param destSysCode           目标系统
  97.      * @param t                       入参对象(是BO非list)
  98.      * @param listNotIncludeAttr    没有在码表中找到目标系统中对应的码值的字典属性
  99.      * @param <T>                      码表转换后的入参
  100.      */
  101.     public  <T> void ergodicObject(String srcSysCode, String destSysCode,  T t,  List<String> listNotIncludeAttr) {
  102.         num++;
  103.         Class clazz = t.getClass();
  104.         Field[] fields = clazz.getDeclaredFields();
  105.         try {
  106.             for (Field field : fields) {
  107.                 field.setAccessible(true);
  108. //                String attrType = field.getType().getSimpleName();//属性类型
  109.                 String attrShortName = field.getName();//属性名
  111.                 if (field.isAnnotationPresent(DictField.class)){
  112.                     String attrValue = (String)field.get(t);//属性值
  113.                     String dictCode = field.getAnnotation(DictField.class).dictCode();//字典名
  114.                     String transColumName = field.getAnnotation(DictField.class).transColumName();//词汇名
  115.                     String isSpeRule = field.getAnnotation(DictField.class).isSpeRule();//是否特殊
  116.                     if(ConstantTools.DEFAULT_0.equals(isSpeRule) ){
  117.                         transColumName="";
  118.                     }
  119. //                    String destCodeVal = "";
  120.                     String destCodeVal =CodeTransDefTools.queryOneUnCodeTransValPOrder(srcSysCode,destSysCode,dictCode,attrValue,isSpeRule,transColumName);
  121.                     //如果t中的目标属性的值为null或者""，则不需要修改其值
  122.                     if (attrValue != null && !"".equals(attrValue)){
  123.                         if (destCodeVal != null && !"".equals(destCodeVal)) {
  124.                             //如果从目标系统中查到的字典值非null或者非空字符串，则重新给属性赋值，否则把属性放到listNotIncludeAttr
  125.                             field.set(t, destCodeVal);
  126.                         } else {
  127.                             listNotIncludeAttr.add(attrShortName);
  128.                             logger.info("在目标系统" + destSysCode + "中,没有找到源系统" + srcSysCode + "中属性是" + attrShortName + "对应的字典" + dictCode + ",找到的字典值是：" + destCodeVal);
  129.                         }
  130.                     }
  131.                 }else if (field.isAnnotationPresent(DictClass.class)){
  132.                     if (isList(field)){
  133.                         //对List/ArrayList类型的属性遍历
  134.                         try {
  135.                             PropertyDescriptor descriptor = new PropertyDescriptor(attrShortName, clazz);
  136.                             Method method = descriptor.getReadMethod();
  137.                             List list = (List) method.invoke(t);
  138.                             if (list != null && list.size() > 0) {
  139.                                 list.stream().forEach(p -> {
  140.                                     // 递归
  141.                                     ergodicObject(srcSysCode, destSysCode, p,  listNotIncludeAttr);
  142.                                 });
  143.                             }
  144.                         } catch (IntrospectionException e) {
  145.                             logger.info(e.getMessage());
  146.                         } catch (InvocationTargetException e) {
  147.                             logger.info(e.getMessage());
  148.                         }
  149.                     }else if(isMap(field)){
  150.                         //对Map/HashMap类型的属性遍历
  151.                         try {
  152.                             PropertyDescriptor descriptor = new PropertyDescriptor(attrShortName, clazz);
  153.                             Method method = descriptor.getReadMethod();
  154.                             Map map = (Map) method.invoke(t);
  155.                             if (map != null && map.size() > 0) {
  156.                                 for (Object obj : map.values()) {
  157.                                     // 递归
  158.                                     ergodicObject(srcSysCode, destSysCode,  obj,  listNotIncludeAttr);
  159.                                 }
  160.                             }
  161.                         } catch (IntrospectionException e) {
  162.                             logger.info(e.getMessage());
  163.                         } catch (InvocationTargetException e) {
  164.                             logger.info(e.getMessage());
  165.                         }
  166.                     }else if (field.getType().isArray()) {
  167.                         //对数组类型的属性遍历
  168.                         field.setAccessible(true);
  169.                         Object[] objArr = (Object[]) field.get(t);
  170.                         if (objArr != null && objArr.length > 0) {
  171.                             for (Object arr : objArr) {
  172.                                 //递归
  173.                                 ergodicObject(srcSysCode, destSysCode, arr, listNotIncludeAttr);
  174.                             }
  175.                         }
  176.                     }else {
  177.                         //对自定义类的属性递归
  178.                         try {
  179.                             PropertyDescriptor descriptor = new PropertyDescriptor(attrShortName, clazz);
  180.                             Method method = descriptor.getReadMethod();
  181.                             Object obj = method.invoke(t);
  182.                             if (obj != null) {
  183.                                 //递归
  184.                                 ergodicObject(srcSysCode, destSysCode, obj, listNotIncludeAttr);
  185.                             } else {
  186.                                 continue;
  187.                             }
  188.                         } catch (IntrospectionException e) {
  189.                             logger.info(e.getMessage());
  190.                         } catch (InvocationTargetException e) {
  191.                             logger.info(e.getMessage());
  192.                         }
  193.                     }
  194.                 }else {
  195.                     continue;
  196.                 }
  198.             }
  199.         } catch (IllegalAccessException e) {
  200.             logger.info(e.getMessage());
  201.         }
  203.     }
  205.     /**
  206.      * 判断是否是List或者ArrayList
  207.      * @param field
  208.      * @return
  209.      */
  210.     public  boolean isList(Field field){
  211.         boolean flag = false;
  212.         String simpleName = field.getType().getSimpleName();
  213.         if ("List".equals(simpleName) || "ArrayList".equals(simpleName)){
  214.             flag = true;
  215.         }
  216.         return flag;
  217.     }
  219.     /**
  220.      * 判断是否是Map或者HashMap
  221.      * @param field
  222.      * @return
  223.      */
  224.     public  boolean isMap(Field field){
  225.         boolean flag = false;
  226.         String simpleName = field.getType().getSimpleName();
  227.         if ("Map".equals(simpleName) || "HashMap".equals(simpleName)){
  228.             flag = true;
  229.         }
  230.         return flag;
  231.     }
  234. }

三、如何使用

复杂对象如下：

  1. package com.lsl.model;
  3. import com.lsl.annotion.DictClass;
  5. import java.util.List;
  7. /**
  8.  * @author: lsl
  9.  * @date: 2019/2/27
  10.  */
  11. public class ParentClass {
  12.     private String fatherName;
  13.     private int fatherAge;
  14.     @DictClass
  15.     private List<SubClass> list;
  16.     @DictClass
  17.     private SubClass subClass;
  18.     public String getFatherName() {
  19.         return fatherName;
  20.     }
  22.     public void setFatherName(String fatherName) {
  23.         this.fatherName = fatherName;
  24.     }
  26.     public int getFatherAge() {
  27.         return fatherAge;
  28.     }
  30.     public void setFatherAge(int fatherAge) {
  31.         this.fatherAge = fatherAge;
  32.     }
  34.     public List<SubClass> getList() {
  35.         return list;
  36.     }
  38.     public void setList(List<SubClass> list) {
  39.         this.list = list;
  40.     }
  42.     public SubClass getSubClass() {
  43.         return subClass;
  44.     }
  46.     public void setSubClass(SubClass subClass) {
  47.         this.subClass = subClass;
  48.     }
  49. }

复杂对象ParentClass包含子对象SubClass

子对象SubClass代码：

  1. package com.lsl.model;
  3. import com.lsl.annotion.DictField;
  5. /**
  6.  * @author: lsl
  7.  * @date: 2019/2/27
  8.  */
  9. public class SubClass {
  10.     @DictField(dictCode = "aaa")
  11.     private String subName;
  12.     private int subAge;
  13.     public String getSubName() {
  14.         return subName;
  15.     }
  17.     public void setSubName(String subName) {
  18.         this.subName = subName;
  19.     }
  21.     public int getSubAge() {
  22.         return subAge;
  23.     }
  25.     public void setSubAge(int subAge) {
  26.         this.subAge = subAge;
  27.     }
  28. }

简单测试，和二、核心代码部分略有区别

  1. package com.lsl;
  3. import com.alibaba.fastjson.JSON;
  4. import com.lsl.annotion.DictClass;
  5. import com.lsl.annotion.DictField;
  6. import com.lsl.model.ParentClass;
  7. import com.lsl.model.SubClass;
  8. import com.lsl.service.MyService;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.stereotype.Controller;
  11. import org.springframework.stereotype.Service;
  12. import org.springframework.transaction.annotation.Transactional;
  13. import org.springframework.web.bind.annotation.RequestMapping;
  15. import java.beans.IntrospectionException;
  16. import java.beans.PropertyDescriptor;
  17. import java.lang.reflect.Field;
  18. import java.lang.reflect.InvocationTargetException;
  19. import java.lang.reflect.Method;
  20. import java.sql.Timestamp;
  21. import java.util.ArrayList;
  22. import java.util.List;
  23. import java.util.Map;
  25. /**
  26.  * @author: lsl
  27.  * @date: 2019/2/15
  28.  */
  29. @Controller
  30. @RequestMapping("/lsl")
  31. public class MyTest {
  33.     public static void main(String [] args){
  35.         SubClass sub1 = new SubClass();
  36.         sub1.setSubAge(21);
  37.         sub1.setSubName("aaa");
  38.         SubClass sub2 = new SubClass();
  39.         sub2.setSubName("bbb");
  40.         sub2.setSubAge(20);
  41.         SubClass sub3 = new SubClass();
  42.         sub3.setSubName("ccc");
  43.         sub3.setSubAge(22);
  44.         List<SubClass> list = new ArrayList();
  45.         list.add(sub1);
  46.         list.add(sub2);
  48.         ParentClass parent = new ParentClass();
  49.         parent.setFatherAge(18);
  50.         parent.setFatherName("aaa");
  51.         parent.setSubClass(sub3);
  52.         parent.setList(list);
  54.         ergodicObject(parent);
  55.     }
  57.     public static <T> void ergodicObject(T t){
  58.         Class clazz = t.getClass();
  59.         Field[] fields = clazz.getDeclaredFields();
  60.         try {
  61.             for (Field field : fields) {
  62.                 field.setAccessible(true);
  63.     //                String attrType = field.getType().getSimpleName();//属性类型
  64.                 String attrShortName = field.getName();//属性名
  65.                 if (field.isAnnotationPresent(DictField.class)){
  66.                     String attrValue = (String)field.get(t);//属性值
  67.                 }else if (field.isAnnotationPresent(DictClass.class)){
  68.                     if (isList(field)){
  69.                         //对List/ArrayList类型的属性遍历
  70.                         try {
  71.                             PropertyDescriptor descriptor = new PropertyDescriptor(attrShortName, clazz);
  72.                             Method method = descriptor.getReadMethod();
  73.                             List list = (List) method.invoke(t);
  74.                             if (list != null && list.size() > 0) {
  76.                                 for(Object obj : list){
  77.                                     ergodicObject(obj);
  78.                                 }
  79.                             }
  80.                         } catch (IntrospectionException e) {
  81.     //                        logger.info(e.getMessage());
  82.                         } catch (InvocationTargetException e) {
  83.     //                        logger.info(e.getMessage());
  84.                         }
  85.                     }else if(isMap(field)){
  86.                         //对Map/HashMap类型的属性遍历
  87.                         try {
  88.                             PropertyDescriptor descriptor = new PropertyDescriptor(attrShortName, clazz);
  89.                             Method method = descriptor.getReadMethod();
  90.                             Map map = (Map) method.invoke(t);
  91.                             if (map != null && map.size() > 0) {
  92.                                 for (Object obj : map.values()) {
  93.                                     // 递归
  94.                                     ergodicObject( obj);
  95.                                 }
  96.                             }
  97.                         } catch (IntrospectionException e) {
  98.     //                        logger.info(e.getMessage());
  99.                         } catch (InvocationTargetException e) {
  100.     //                        logger.info(e.getMessage());
  101.                         }
  102.                     }else if (field.getType().isArray()) {
  103.                         //对数组类型的属性遍历
  104.                         field.setAccessible(true);
  105.                         Object[] objArr = (Object[]) field.get(t);
  106.                         if (objArr != null && objArr.length > 0) {
  107.                             for (Object arr : objArr) {
  108.                                 //递归
  109.                                 ergodicObject( arr);
  110.                             }
  111.                         }
  112.                     }else {
  113.                         //对自定义类的属性递归
  114.                         try {
  115.                             PropertyDescriptor descriptor = new PropertyDescriptor(attrShortName, clazz);
  116.                             Method method = descriptor.getReadMethod();
  117.                             Object obj = method.invoke(t);
  118.                             if (obj != null) {
  119.                                 //递归
  120.                                 ergodicObject( obj);
  121.                             } else {
  122.                                 continue;
  123.                             }
  124.                         } catch (IntrospectionException e) {
  125.     //                        logger.info(e.getMessage());
  126.                         } catch (InvocationTargetException e) {
  127.     //                        logger.info(e.getMessage());
  128.                         }
  129.                     }
  130.                 }else {
  131.                     continue;
  132.                 }
  133.             }
  134.         } catch (IllegalAccessException e) {
  135.             e.printStackTrace();
  136.         }
  137.     }
  139.     public  static boolean isList(Field field){
  140.         boolean flag = false;
  141.         String simpleName = field.getType().getSimpleName();
  142.         if ("List".equals(simpleName) || "ArrayList".equals(simpleName)){
  143.             flag = true;
  144.         }
  145.         return flag;
  146.     }
  148.     /**
  149.      * 判断是否是Map或者HashMap
  150.      * @param field
  151.      * @return
  152.      */
  153.     public static   boolean isMap(Field field){
  154.         boolean flag = false;
  155.         String simpleName = field.getType().getSimpleName();
  156.         if ("Map".equals(simpleName) || "HashMap".equals(simpleName)){
  157.             flag = true;
  158.         }
  159.         return flag;
  160.     }
  162.     public static String countMethod(){
  163.         StringBuffer a= new StringBuffer("11");
  164.         try {
  165.             try {
  166.                 a = a.append("22");
  167.                 int m=1/0;
  168.             } catch (Exception e) {
  169.                 System.err.println("内层catch执行");
  170.                 throw e;
  172.             }
  173. //            return a.toString();
  174.         } catch (Exception e) {
  175. //            return a.toString();
  176.             System.err.println("外层catch执行");
  177.             throw e;
  178.         } finally {
  179.             a = a.append("33");
  180.             System.err.println("finally==a==" + a);
  181.         }
  182.         return a.toString();
  183.     }
  185.     @Autowired
  186.     MyService service;
  188. //    @Transactional
  189.     @RequestMapping("/lock")
  190.     public  void tranactionalTest(){
  191.         BizLock lock = new BizLock();
  192.         BizLock bizLock = new BizLock();
  193.         bizLock.setBizId("11223344");
  194.         bizLock.setBizNo("aabbccdd");
  195.         bizLock.setBizType("MTNNO");
  196.         long nowTime = System.currentTimeMillis();
  197.         bizLock.setCreateTime(new Timestamp(nowTime));
  198.         bizLock.setPassTime(new Timestamp(nowTime));
  199.         int count = service.addLock(bizLock);
  201.         if (count==1){
  202.             System.err.println("加锁成功" + count);
  203.         }else {
  204.             System.err.println("加锁失败" + count);
  205.         }
  206. //        int aa = 1/0;
  207. //        try {
  208. //            System.err.println("Thread名字"+ Thread.currentThread().getName() + ",开始休眠8888888");
  209. //            Thread.sleep(50000L);
  210. //        } catch (InterruptedException e) {
  211. //
  212. //        }
  214.         int num=12;
  216.         System.err.println("endendendend");
  217. //        return count;
  218.     }
  221.     @RequestMapping("/lock2")
  222.     public  void tranactionalTes2t(){
  223.         BizLock lock = new BizLock();
  224.         BizLock bizLock = new BizLock();
  225.         bizLock.setBizId("11223344");
  226.         bizLock.setBizNo("aabbccdd");
  227.         bizLock.setBizType("MTNNO");
  228.         long nowTime = System.currentTimeMillis();
  229.         bizLock.setCreateTime(new Timestamp(nowTime));
  230.         bizLock.setPassTime(new Timestamp(nowTime));
  231.         int count = service.addLock(bizLock);
  233.         if (count==1){
  234.             System.err.println("加锁成功" + count);
  235.         }else {
  236.             System.err.println("加锁失败" + count);
  237.         }
  238. //
  241.         System.err.println("endendendend");
  242.     }
  245. }

发表评论

表情：
评论列表 （有 0 条评论，586人围观）

还没有评论，来说两句吧...

相关阅读