利用递归遍历获取Java复杂对象（对象的属性仍是对象//list/map）中指定属性的值（一）

冷不防 2022-04-17 03:16 1788阅读 0赞

本示例中又三个对象嵌套：

UserBO：复杂对象，其中一个属性是List或者Map

AddressBO：其中一个属性是SubAddressBO

SubAddressBO：包含目标属性addrId，且是string类型，查找addrId的值

任务：UserBO是一个复杂对象，该对象中肯定存在目标属性addrId（String类型,递归方法只能找string类型的属性，找其他类型自行修改代码），只是不知道addrId在哪个子属性中，如果UserBO存在多个addrId属性，那么只遍历出遇到的第一个addrId的值即可。

注意：（本例子在遍历复杂对象时，如果找到第一个目标属性，则退出，不在继续遍历，后面bolg有遍历复杂对象所有属性的文章）

1、本示例提供了两种方法来获取复杂对象中指定属性的值，一种是利用递归，另一种是直接把复杂对象转换成json串，再截取。

2、本示例对于复杂对象中不包含目标属性时，会返回空字符串。

3、目标属性可以存在于自定义类、list、map、数组中

4、**复杂对象可以是复杂嵌套的BO/List/Map,目标属性存在于BO中**

5、对于复杂对象是这种嵌套格式(**List>/List>/Map>)的没有做测试**

现在任务交代清楚了，开始贴代码

1、三个Bo类代码

  1. import java.io.Serializable;
  2. import java.util.List;
  3. import java.util.Map;
  5. public class UserBO implements Serializable {
  7.     private static final long serialVersionUID = 1L;
  9.     private String id;
  11.     private String userName;
  13.     private int age;
  15.     private AddressBO address;
  17.     private List<AddressBO> list;
  19.     private Map<String,AddressBO> map;
  20. //    private Date date;
  21. //
  22. //    public Date getDate() {
  23. //        return date;
  24. //    }
  25. //
  26. //    public void setDate(Date date) {
  27. //        this.date = date;
  28. //    }
  30.     private byte b;
  31.     private short s;
  32.     private boolean bool;
  33.     private double dble;
  34.     private Byte bb;
  35.     private Short ss;
  36.     private Integer integer;
  37.     private Long aLong;
  38.     private Double dd;
  39.     private Boolean aBoolean;
  40.     private AddressBO[] addressArr;
  42.     public UserBO() {
  43.     }
  45.     public UserBO(String id, String userName, int age, AddressBO address) {
  46.         super();
  47.         this.id = id;
  48.         this.userName = userName;
  49.         this.age = age;
  50.         this.address = address;
  51.     }
  53.     public String getId() {
  54.         return id;
  55.     }
  57.     public void setId(String id) {
  58.         this.id = id;
  59.     }
  61.     public String getUserName() {
  62.         return userName;
  63.     }
  65.     public void setUserName(String userName) {
  66.         this.userName = userName;
  67.     }
  69.     public int getAge() {
  70.         return age;
  71.     }
  73.     public void setAge(int age) {
  74.         this.age = age;
  75.     }
  77.     public AddressBO getAddress() {
  78.         return address;
  79.     }
  81.     public void setAddress(AddressBO address) {
  82.         this.address = address;
  83.     }
  85.     public List<AddressBO> getList() {
  86.         return list;
  87.     }
  89.     public void setList(List<AddressBO> list) {
  90.         this.list = list;
  91.     }
  93.     public Map<String, AddressBO> getMap() {
  94.         return map;
  95.     }
  97.     public void setMap(Map<String, AddressBO> map) {
  98.         this.map = map;
  99.     }
  101.     public byte getB() {
  102.         return b;
  103.     }
  105.     public void setB(byte b) {
  106.         this.b = b;
  107.     }
  109.     public short getS() {
  110.         return s;
  111.     }
  113.     public void setS(short s) {
  114.         this.s = s;
  115.     }
  117.     public boolean isBool() {
  118.         return bool;
  119.     }
  121.     public void setBool(boolean bool) {
  122.         this.bool = bool;
  123.     }
  125.     public double getDble() {
  126.         return dble;
  127.     }
  129.     public void setDble(double dble) {
  130.         this.dble = dble;
  131.     }
  133.     public Byte getBb() {
  134.         return bb;
  135.     }
  137.     public void setBb(Byte bb) {
  138.         this.bb = bb;
  139.     }
  141.     public Short getSs() {
  142.         return ss;
  143.     }
  145.     public void setSs(Short ss) {
  146.         this.ss = ss;
  147.     }
  149.     public Integer getInteger() {
  150.         return integer;
  151.     }
  153.     public void setInteger(Integer integer) {
  154.         this.integer = integer;
  155.     }
  157.     public Long getaLong() {
  158.         return aLong;
  159.     }
  161.     public void setaLong(Long aLong) {
  162.         this.aLong = aLong;
  163.     }
  165.     public Double getDd() {
  166.         return dd;
  167.     }
  169.     public void setDd(Double dd) {
  170.         this.dd = dd;
  171.     }
  173.     public Boolean getaBoolean() {
  174.         return aBoolean;
  175.     }
  177.     public void setaBoolean(Boolean aBoolean) {
  178.         this.aBoolean = aBoolean;
  179.     }
  181. //    @Override
  182. //    public String toString() {
  183. //        return "UserVo [id=" + id + ", userName=" + userName + ", age=" + age + ", address=[addrId=" + address.getAddrId() + ",addrName=" + address.getAddrName() + "] ]";
  184. //    }
  187.     public AddressBO[] getAddressArr() {
  188.         return addressArr;
  189.     }
  191.     public void setAddressArr(AddressBO[] addressArr) {
  192.         this.addressArr = addressArr;
  193.     }
  194. }
  196. import java.io.Serializable;
  198. public class AddressBO implements Serializable {
  200.     private static final long serialVersionUID = 1L;
  202. //    private String addrId;
  204.     private String addrName;
  206.     private SubAddressBO subAddressBO;
  208.     public AddressBO() {
  209.     }
  211. //    public AddressBO(String addrId, String addrName) {
  212. //        super();
  213. //        this.addrId = addrId;
  214. //        this.addrName = addrName;
  215. //    }
  216. //
  217. //    public String getAddrId() {
  218. //        return addrId;
  219. //    }
  220. //
  221. //    public void setAddrId(String addrId) {
  222. //        this.addrId = addrId;
  223. //    }
  225.     public String getAddrName() {
  226.         return addrName;
  227.     }
  229.     public void setAddrName(String addrName) {
  230.         this.addrName = addrName;
  231.     }
  233.     public SubAddressBO getSubAddressBO() {
  234.         return subAddressBO;
  235.     }
  237.     public void setSubAddressBO(SubAddressBO subAddressBO) {
  238.         this.subAddressBO = subAddressBO;
  239.     }
  240. }
  244. import java.io.Serializable;
  246. /**
  247.  * @author: lsl
  248.  * @date: 2018/11/12
  249.  */
  250. public class SubAddressBO implements Serializable {
  251.     private String addrId;
  252.     private int len;
  254.     public SubAddressBO() {
  255.     }
  257.     public SubAddressBO(String addrId, int len) {
  258.         this.addrId = addrId;
  259.         this.len = len;
  260.     }
  262.     public String getAddrId() {
  263.         return addrId;
  264.     }
  266.     public void setAddrId(String addrId) {
  267.         this.addrId = addrId;
  268.     }
  270.     public int getLen() {
  271.         return len;
  272.     }
  274.     public void setLen(int len) {
  275.         this.len = len;
  276.     }
  277. }

2、递归遍历获取复杂对象的指定属性的值

  1. import com.alibaba.fastjson.JSON;
  2. import org.apache.commons.lang3.StringUtils;
  4. import java.beans.PropertyDescriptor;
  5. import java.lang.reflect.Field;
  6. import java.lang.reflect.Method;
  7. import java.util.*;
  9. /**
  10.  * @author: lsl
  11.  * @date: 2018/11/9
  12.  */
  13. public class RecursionObject {
  15.     public static void main(String[] args){
  16.         //制造数据
  17.         SubAddressBO subAddressBO0 = new SubAddressBO("subaddress0",10);
  18.         SubAddressBO subAddressBO1 = new SubAddressBO("subaddress1",20);
  19.         SubAddressBO subAddressBO2 = new SubAddressBO("subaddress2",30);
  20.         SubAddressBO subAddressBO3 = new SubAddressBO("subaddress3",40);
  21.         SubAddressBO subAddressBO4 = new SubAddressBO("subaddress4",50);
  22.         AddressBO address0 = new AddressBO();
  23.         address0.setSubAddressBO(subAddressBO0);
  25.         AddressBO address1 = new AddressBO();
  26.         address1.setSubAddressBO(subAddressBO1);
  28.         AddressBO address2 = new AddressBO();
  29.         address2.setSubAddressBO(subAddressBO2);
  31.         AddressBO address3 = new AddressBO();
  32.         address3.setSubAddressBO(subAddressBO3);
  34.         AddressBO address4 = new AddressBO();
  35.         address4.setSubAddressBO(subAddressBO4);
  37.         UserBO userBO = new UserBO();
  39.         HashMap<String,AddressBO> map = new HashMap<>();
  40.         map.put("addr1",address1);
  41.         map.put("addr2",address2);
  43.         ArrayList<AddressBO> list = new ArrayList<>();
  44.         list.add(address3);
  45.         list.add(address4);
  47.         TestBO testBO = new TestBO();
  48.         testBO.setAaa("123");
  49.         testBO.setBbb("456");
  50.         userBO.setTestBO(testBO);
  51.         TestVO testVO = new TestVO();
  52.         testVO.setCcc("ccc11");
  53.         testVO.setDdd("ddd22");
  54.         userBO.setTestVO(testVO);
  56.         List<TestBO> listTestBo = new ArrayList<>();
  57.         listTestBo.add(testBO);
  58.         userBO.setListTestBo(listTestBo);
  60.         userBO.setId("u123");
  61.         userBO.setUserName("lsl");
  62.         userBO.setAge(22);
  63.         //测试目标属性存在于对象属性是自定义类中
  64.         userBO.setAddress(address0);
  65.         //测试目标属性存在于对象属性是list的元素中
  66.         userBO.setList(list);
  67.         //测试目标属性存在于对象属性是list的元素中
  68. //        userBO.setMap(map);
  69.         //测试目标属性存在于对象属性的数组中
  70. //        AddressBO[] arr = new AddressBO[]{address0,address1};
  71. //        userBO.setAddressArr(arr);
  73.         List<UserBO> userBOList = new ArrayList<>();
  74.         userBOList.add(userBO);
  76.         //利用方法一
  77.         Map<String,Object> resultMap = recursionLoopThroughObj(userBO,"addrId");
  78.         System.err.println("result:" + resultMap.get("proValue"));
  80.         //利用方法二
  81. //        String businessNoFromArg = getBusinessNoFromArg(userBO, "addrId");
  82. //        System.err.println("businessNoFromArg=" + businessNoFromArg);
  84.     }
  86.     /**
  87.      * 方法一：利用递归遍历
  88.      * 用途：从复杂对象中递归遍历，获取string类型的目标属性名的值
  89.      * 适用条件：该复杂对象中如果存在多个目标属性targetProName，遍历到第一个atargetProName则退出遍历
  90.      *           targetProName属性必须是string
  91.      *           targetProName可以存在自定义对象中、list、map、数组中
  92.      *           如果复杂对象不包含目标属性则返回空字符串
  93.      *           复杂对象可以是复杂嵌套的BO/List<BO>/Map<Object,BO>,目标属性存在于BO中
  94.      *           对于复杂对象是list或map嵌套的不做支持。比如List<List<BO></BO>> /List<Map<object,BO>> / Map<object,List<BO>>
  95.      * @param object 复杂对象
  96.      * @param targetProName  目标属性名
  97.      * @return
  98.      */
  99.     public static  Map<String,Object> recursionLoopThroughObj(Object object,String targetProName){
  100.         Map<String,Object> resultMap = new HashMap<>();
  101.         Class clazz = null;
  102.         String proValue = "";
  103.         boolean loopFlag = true;
  104.         resultMap.put("loopFlag",loopFlag);
  105.         resultMap.put("proValue",proValue);
  106.         try {
  107.             if (object==null || checkObjectIsSysType(object)){
  108.                 //如果object是null/基本数据类型/包装类/日期类型，则不需要在递归调用
  109.                 resultMap.put("loopFlag",false);
  110.                 resultMap.put("proValue","");
  111.                 return resultMap;
  112.             }
  113.             if (object instanceof Map){
  114.                 Map map = (Map)object;
  115.                 Map<String,Object> objMap = new HashMap<>();
  116.                 if (map!=null && map.size()>0){
  117.                     Iterator iterator = map.values().iterator();
  118.                     while (iterator.hasNext()){
  119.                         objMap = recursionLoopThroughObj(iterator.next(),targetProName);
  120.                         if (!(boolean)objMap.get("loopFlag")){
  121.                             return objMap;
  122.                         }
  123.                     }
  124.                 }
  125.             }
  127.             clazz = object.getClass();
  128.             Field[] fields = clazz.getDeclaredFields();
  129.             for (Field field : fields) {
  130.                 String proType = field.getGenericType().toString();
  131.                 String proName = field.getName();
  132.                 System.err.println("proName:" + proName + ",proType:" + proType );
  133.                 if ("class java.lang.String".equals(proType) && targetProName.equals(proName)){
  134.                     field.setAccessible(true);
  135.                     proValue = (String)field.get(object);
  136.                     resultMap.put("loopFlag",false);
  137.                     resultMap.put("proValue",proValue);
  138.                     return resultMap;
  139.                 }else if ("byte".equals(proType) || "short".equals(proType) || "int".equals(proType)|| "long".equals(proType)|| "double".equals(proType) || "float".equals(proType) || "boolean".equals(proType) ){
  140.                     //属性是基本类型跳过
  141.                     continue;
  142.                 }else if ("class java.lang.Byte".equals(proType) || "class java.lang.Short".equals(proType) || "class java.lang.Integer".equals(proType) || "class java.lang.Long".equals(proType) || "class java.lang.Double".equals(proType) || "class java.lang.Float".equals(proType) || "class java.lang.Boolean".equals(proType) || ("class java.lang.String".equals(proType) && !targetProName.equals(proName))){
  143.                     //属性是包装类跳过
  144.                     continue;
  145.                 }else if (proType.startsWith("java.util")){
  146.                     //属性是集合类型则遍历
  147.                     if (proType.startsWith("java.util.List")){
  148.                         //对List类型的属性遍历
  149.                         PropertyDescriptor descriptor = new PropertyDescriptor(field.getName(), clazz);
  150.                         Method method = descriptor.getReadMethod();
  151.                         List list = (List)method.invoke(object);
  152.                         Map<String,Object> objMap = new HashMap<>();
  153.                         if (list!=null && list.size()>0){
  154.                             int len = list.size();
  155.                             for (int i= 0;i<len;i++){
  156.                                 objMap = recursionLoopThroughObj(list.get(i),targetProName);
  157.                                 if (!(boolean)objMap.get("loopFlag")){
  158.                                     return objMap;
  159.                                 }
  160.                             }
  161.                         }
  163.                     }else if (proType.startsWith("java.util.Map")){
  164.                         //对Map类型的属性遍历
  165.                         PropertyDescriptor descriptor = new PropertyDescriptor(field.getName(), clazz);
  166.                         Method method = descriptor.getReadMethod();
  167.                         Map map = (Map)method.invoke(object);
  168.                         Map<String,Object> objMap = new HashMap<>();
  169.                         if (map!=null && map.size()>0){
  170.                             for (Object obj : map.values()){
  171.                                 objMap = recursionLoopThroughObj(obj,targetProName);
  172.                                 if (!(boolean)objMap.get("loopFlag")){
  173.                                     return objMap;
  174.                                 }
  175.                             }
  176.                         }
  178.                     }
  180.                 }else if(field.getType().isArray()){
  181.                     //属性是数组类型则遍历
  182.                     field.setAccessible(true);
  183.                     Object[] objArr = (Object[]) field.get(object);
  184.                     Map<String,Object> objMap = new HashMap<>();
  185.                     if (objArr!=null && objArr.length>0){
  186.                         for (Object arr : objArr){
  187.                             objMap = recursionLoopThroughObj(arr,targetProName);
  188.                             if (!(boolean)objMap.get("loopFlag")){
  189.                                 return objMap;
  190.                             }
  191.                         }
  192.                     }
  194.                 }else  {
  195.                     //class类型的遍历
  196.                     PropertyDescriptor descriptor = new PropertyDescriptor(field.getName(), clazz);
  197.                     Method method = descriptor.getReadMethod();
  198.                     Object obj = method.invoke(object);
  199.                     Map<String,Object> objMap = new HashMap<>();
  200.                     if (obj!= null){
  201.                         objMap = recursionLoopThroughObj(obj,targetProName);
  202.                         if (!(boolean)objMap.get("loopFlag")){
  203.                             return objMap;
  204.                         }
  205.                     }else {
  206.                         continue;
  207.                     }
  209.                 }
  210.             }
  211.         } catch (Exception e) {
  212.             System.err.println("err:" + e);
  213.         }
  214.         return resultMap;
  215.     }
  217.     /**
  218.      * 检查object是否为java的基本数据类型/包装类/java.util.Date/java.sql.Date
  219.      * @param object
  220.      * @return
  221.      */
  222.     public static boolean checkObjectIsSysType(Object object){
  223.         String objType = object.getClass().toString();
  224.         if ("byte".equals(objType) || "short".equals(objType) || "int".equals(objType)|| "long".equals(objType)|| "double".equals(objType) || "float".equals(objType) || "boolean".equals(objType)){
  225.             return true;
  226.         }else if ("class java.lang.Byte".equals(objType) || "class java.lang.Short".equals(objType) || "class java.lang.Integer".equals(objType) || "class java.lang.Long".equals(objType) || "class java.lang.Double".equals(objType) || "class java.lang.Float".equals(objType) || "class java.lang.Boolean".equals(objType) || "class java.lang.String".equals(objType)){
  227.             return true;
  228.         }else {
  229.             return  false;
  230.         }
  232.     }
  234.     /**
  235.      * 方法二：从复杂对象中获取string类型的目标属性targetProName的值
  236.      * 把对象转换成json字符串，然后截取第一次出现的targetProName的值
  237.      * 适用条件：同方法一
  238.      * @param object 复杂对象
  239.      * @param targetProName 目标属性
  240.      * @return
  241.      */
  242.     public static String getBusinessNoFromArg(Object object,String targetProName){
  243.         String jsonString = JSON.toJSONString(object);
  244.         System.err.println("jsonString=" + jsonString);
  245.         jsonString = StringUtils.substringAfter(jsonString,"\""+targetProName + "\":\"");
  246.         jsonString = StringUtils.substringBefore(jsonString,"\"");
  247.         return jsonString;
  248.     }
  249. }

3、addrId存在于map中运行结果图：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Roa2xzbA_size_16_color_FFFFFF_t_70

发表评论

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

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

相关阅读