content: package com.genersoft.iot.vmp.gb28181.utils;
  
  import com.alibaba.fastjson2.JSONArray;
  import com.alibaba.fastjson2.JSONObject;
  import lombok.extern.slf4j.Slf4j;
  import org.apache.commons.lang3.math.NumberUtils;
  import org.dom4j.Attribute;
  import org.dom4j.Document;
  import org.dom4j.DocumentException;
  import org.dom4j.Element;
  import org.dom4j.io.SAXReader;
  import org.springframework.util.ObjectUtils;
  import org.springframework.util.ReflectionUtils;
  
  import javax.sip.RequestEvent;
  import javax.sip.message.Request;
  import java.io.ByteArrayInputStream;
  import java.io.StringReader;
  import java.lang.reflect.Field;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.ParameterizedType;
  import java.lang.reflect.Type;
  import java.util.*;
  
  /**
   * 基于dom4j的工具包
   */
  @Slf4j
  public class XmlUtil {
  
      /**
       * 解析XML为Document对象
       */
      public static Element parseXml(String xml) {
          Document document = null;
          //
          StringReader sr = new StringReader(xml);
          SAXReader saxReader = new SAXReader();
          try {
              document = saxReader.read(sr);
          } catch (DocumentException e) {
              log.error("解析失败", e);
          }
          return null == document ? null : document.getRootElement();
      }
  
      /**
       * 获取element对象的text的值
       *
       * @param em  节点的对象
       * @param tag 节点的tag
       * @return 节点
       */
      public static String getText(Element em, String tag) {
          if (null == em) {
              return null;
          }
          Element e = em.element(tag);
          //
          return null == e ? null : e.getText().trim();
      }
  
      /**
       * 获取element对象的text的值
       *
       * @param em  节点的对象
       * @param tag 节点的tag
       * @return 节点
       */
      public static Double getDouble(Element em, String tag) {
          if (null == em) {
              return null;
          }
          Element e = em.element(tag);
          if (null == e) {
              return null;
          }
          String text = e.getText().trim();
          if (ObjectUtils.isEmpty(text) || !NumberUtils.isParsable(text)) {
              return null;
          }
          return Double.parseDouble(text);
      }
  
      /**
       * 获取element对象的text的值
       *
       * @param em  节点的对象
       * @param tag 节点的tag
       * @return 节点
       */
      public static Integer getInteger(Element em, String tag) {
          if (null == em) {
              return null;
          }
          Element e = em.element(tag);
          if (null == e) {
              return null;
          }
          String text = e.getText().trim();
          if (ObjectUtils.isEmpty(text) || !NumberUtils.isParsable(text)) {
              return null;
          }
          return Integer.parseInt(text);
      }
  
      /**
       * 递归解析xml节点，适用于 多节点数据
       *
       * @param node     node
       * @param nodeName nodeName
       * @return List<Map<String, Object>>
       */
      public static List<Map<String, Object>> listNodes(Element node, String nodeName) {
          if (null == node) {
              return null;
          }
          // 初始化返回
          List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
          // 首先获取当前节点的所有属性节点
          List<Attribute> list = node.attributes();
  
          Map<String, Object> map = null;
          // 遍历属性节点
          for (Attribute attribute : list) {
              if (nodeName.equals(node.getName())) {
                  if (null == map) {
                      map = new HashMap<String, Object>();
                      listMap.add(map);
                  }
                  // 取到的节点属性放到map中
                  map.put(attribute.getName(), attribute.getValue());
              }
  
          }
          // 遍历当前节点下的所有节点 ，nodeName 要解析的节点名称
          // 使用递归
          Iterator<Element> iterator = node.elementIterator();
          while (iterator.hasNext()) {
              Element e = iterator.next();
              listMap.addAll(listNodes(e, nodeName));
          }
          return listMap;
      }
  
      /**
       * xml转json
       *
       * @param element
       * @param json
       */
      public static void node2Json(Element element, JSONObject json) {
          // 如果是属性
          for (Object o : element.attributes()) {
              Attribute attr = (Attribute) o;
              if (!ObjectUtils.isEmpty(attr.getValue())) {
                  json.put("@" + attr.getName(), attr.getValue());
              }
          }
          List<Element> chdEl = element.elements();
          if (chdEl.isEmpty() && !ObjectUtils.isEmpty(element.getText())) {// 如果没有子元素,只有一个值
              json.put(element.getName(), element.getText());
          }
  
          for (Element e : chdEl) {   // 有子元素
              if (!e.elements().isEmpty()) {  // 子元素也有子元素
                  JSONObject chdjson = new JSONObject();
                  node2Json(e, chdjson);
                  Object o = json.get(e.getName());
                  if (o != null) {
                      JSONArray jsona = null;
                      if (o instanceof JSONObject) {  // 如果此元素已存在,则转为jsonArray
                          JSONObject jsono = (JSONObject) o;
                          json.remove(e.getName());
                          jsona = new JSONArray();
                          jsona.add(jsono);
                          jsona.add(chdjson);
                      }
                      if (o instanceof JSONArray) {
                          jsona = (JSONArray) o;
                          jsona.add(chdjson);
                      }
                      json.put(e.getName(), jsona);
                  } else {
                      if (!chdjson.isEmpty()) {
                          json.put(e.getName(), chdjson);
                      }
                  }
              } else { // 子元素没有子元素
                  for (Object o : element.attributes()) {
                      Attribute attr = (Attribute) o;
                      if (!ObjectUtils.isEmpty(attr.getValue())) {
                          json.put("@" + attr.getName(), attr.getValue());
                      }
                  }
                  if (!e.getText().isEmpty()) {
                      json.put(e.getName(), e.getText());
                  }
              }
          }
      }
      public static  Element getRootElement(RequestEvent evt) throws DocumentException {
  
          return getRootElement(evt, "gb2312");
      }
  
      public static Element getRootElement(RequestEvent evt, String charset) throws DocumentException {
          Request request = evt.getRequest();
          return getRootElement(request.getRawContent(), charset);
      }
  
      public static Element getRootElement(byte[] content, String charset) throws DocumentException {
          if (charset == null) {
              charset = "gb2312";
          }
          SAXReader reader = new SAXReader();
          reader.setEncoding(charset);
          Document xml = reader.read(new ByteArrayInputStream(content));
          return xml.getRootElement();
      }
  
      private enum ChannelType{
          CivilCode, BusinessGroup,VirtualOrganization,Other
      }
  
  //    public static DeviceChannel channelContentHandler(Element itemDevice, Device device, String event){
  //        DeviceChannel deviceChannel = new DeviceChannel();
  //        deviceChannel.setDeviceId(device.getDeviceId());
  //        Element channdelIdElement = itemDevice.element("DeviceID");
  //        if (channdelIdElement == null) {
  //            logger.warn("解析Catalog消息时发现缺少 DeviceID");
  //            return null;
  //        }
  //        String channelId = channdelIdElement.getTextTrim();
  //        if (ObjectUtils.isEmpty(channelId)) {
  //            logger.warn("解析Catalog消息时发现缺少 DeviceID");
  //            return null;
  //        }
  //        deviceChannel.setDeviceId(channelId);
  //        if (event != null && !event.equals(CatalogEvent.ADD) && !event.equals(CatalogEvent.UPDATE)) {
  //            // 除了ADD和update情况下需要识别全部内容，
  //            return deviceChannel;
  //        }
  //        Element nameElement = itemDevice.element("Name");
  //        // 当通道名称为空时，设置通道名称为通道编码，避免级联时因通道名称为空导致上级接收通道失败
  //        if (nameElement != null && StringUtils.isNotBlank(nameElement.getText())) {
  //            deviceChannel.setName(nameElement.getText());
  //        } else {
  //            deviceChannel.setName(channelId);
  //        }
  //        if(channelId.length() <= 8) {
  //            deviceChannel.setHasAudio(false);
  //            CivilCodePo parentCode = CivilCodeUtil.INSTANCE.getParentCode(channelId);
  //            if (parentCode != null) {
  //                deviceChannel.setParentId(parentCode.getCode());
  //                deviceChannel.setCivilCode(parentCode.getCode());
  //            }else {
  //                logger.warn("[xml解析] 无法确定行政区划{}的上级行政区划", channelId);
  //            }
  //            deviceChannel.setStatus("ON");
  //            return deviceChannel;
  //        }else {
  //            if(channelId.length() != 20) {
  //                logger.warn("[xml解析] 失败，编号不符合国标28181定义： {}", channelId);
  //                return null;
  //            }
  //
  //            int code = Integer.parseInt(channelId.substring(10, 13));
  //            if (code == 136 || code == 137 || code == 138) {
  //                deviceChannel.setHasAudio(true);
  //            }else {
  //                deviceChannel.setHasAudio(false);
  //            }
  //            // 设备厂商
  //            String manufacturer = getText(itemDevice, "Manufacturer");
  //            // 设备型号
  //            String model = getText(itemDevice, "Model");
  //            // 设备归属
  //            String owner = getText(itemDevice, "Owner");
  //            // 行政区域
  //            String civilCode = getText(itemDevice, "CivilCode");
  //            // 虚拟组织所属的业务分组ID,业务分组根据特定的业务需求制定,一个业务分组包含一组特定的虚拟组织
  //            String businessGroupID = getText(itemDevice, "BusinessGroupID");
  //            // 父设备/区域/系统ID
  //            String parentID = getText(itemDevice, "ParentID");
  //            if (parentID != null && parentID.equalsIgnoreCase("null")) {
  //                parentID = null;
  //            }
  //            // 注册方式(必选)缺省为1;1:符合IETFRFC3261标准的认证注册模式;2:基于口令的双向认证注册模式;3:基于数字证书的双向认证注册模式
  //            String registerWay = getText(itemDevice, "RegisterWay");
  //            // 保密属性(必选)缺省为0;0:不涉密,1:涉密
  //            String secrecy = getText(itemDevice, "Secrecy");
  //            // 安装地址
  //            String address = getText(itemDevice, "Address");
  //
  //            switch (code){
  //                case 200:
  //                    // 系统目录
  //                    if (!ObjectUtils.isEmpty(manufacturer)) {
  //                        deviceChannel.setManufacture(manufacturer);
  //                    }
  //                    if (!ObjectUtils.isEmpty(model)) {
  //                        deviceChannel.setModel(model);
  //                    }
  //                    if (!ObjectUtils.isEmpty(owner)) {
  //                        deviceChannel.setOwner(owner);
  //                    }
  //                    if (!ObjectUtils.isEmpty(civilCode)) {
  //                        deviceChannel.setCivilCode(civilCode);
  //                        deviceChannel.setParentId(civilCode);
  //                    }else {
  //                        if (!ObjectUtils.isEmpty(parentID)) {
  //                            deviceChannel.setParentId(parentID);
  //                        }
  //                    }
  //                    if (!ObjectUtils.isEmpty(address)) {
  //                        deviceChannel.setAddress(address);
  //                    }
  //                    deviceChannel.setStatus(true);
  //                    if (!ObjectUtils.isEmpty(registerWay)) {
  //                        try {
  //                            deviceChannel.setRegisterWay(Integer.parseInt(registerWay));
  //                        }catch (NumberFormatException exception) {
  //                            logger.warn("[xml解析] 从通道数据获取registerWay失败： {}", registerWay);
  //                        }
  //                    }
  //                    if (!ObjectUtils.isEmpty(secrecy)) {
  //                        deviceChannel.setSecrecy(secrecy);
  //                    }
  //                    return deviceChannel;
  //                case 215:
  //                    // 业务分组
  //                    deviceChannel.setStatus(true);
  //                    if (!ObjectUtils.isEmpty(parentID)) {
  //                        if (!parentID.trim().equalsIgnoreCase(device.getDeviceId())) {
  //                            deviceChannel.setParentId(parentID);
  //                        }
  //                    }else {
  //                        logger.warn("[xml解析] 业务分组数据中缺少关键信息->ParentId");
  //                        if (!ObjectUtils.isEmpty(civilCode)) {
  //                            deviceChannel.setCivilCode(civilCode);
  //                        }
  //                    }
  //                    break;
  //                case 216:
  //                    // 虚拟组织
  //                    deviceChannel.setStatus(true);
  //                    if (!ObjectUtils.isEmpty(businessGroupID)) {
  //                        deviceChannel.setBusinessGroupId(businessGroupID);
  //                    }
  //
  //                    if (!ObjectUtils.isEmpty(parentID)) {
  //                        if (parentID.contains("/")) {
  //                            String[] parentIdArray = parentID.split("/");
  //                            parentID = parentIdArray[parentIdArray.length - 1];
  //                        }
  //                        deviceChannel.setParentId(parentID);
  //                    }else {
  //                        if (!ObjectUtils.isEmpty(businessGroupID)) {
  //                            deviceChannel.setParentId(businessGroupID);
  //                        }
  //                    }
  //                    break;
  //                default:
  //                    // 设备目录
  //                    if (!ObjectUtils.isEmpty(manufacturer)) {
  //                        deviceChannel.setManufacture(manufacturer);
  //                    }
  //                    if (!ObjectUtils.isEmpty(model)) {
  //                        deviceChannel.setModel(model);
  //                    }
  //                    if (!ObjectUtils.isEmpty(owner)) {
  //                        deviceChannel.setOwner(owner);
  //                    }
  //                    if (!ObjectUtils.isEmpty(civilCode)
  //                            && civilCode.length() <= 8
  //                            && NumberUtils.isParsable(civilCode)
  //                            && civilCode.length()%2 == 0
  //                    ) {
  //                        deviceChannel.setCivilCode(civilCode);
  //                    }
  //                    if (!ObjectUtils.isEmpty(businessGroupID)) {
  //                        deviceChannel.setBusinessGroupId(businessGroupID);
  //                    }
  //
  //                    // 警区
  //                    String block = getText(itemDevice, "Block");
  //                    if (!ObjectUtils.isEmpty(block)) {
  //                        deviceChannel.setBlock(block);
  //                    }
  //                    if (!ObjectUtils.isEmpty(address)) {
  //                        deviceChannel.setAddress(address);
  //                    }
  //
  //                    if (!ObjectUtils.isEmpty(secrecy)) {
  //                        deviceChannel.setSecrecy(secrecy);
  //                    }
  //
  //                    // 当为设备时,是否有子设备(必选)1有,0没有
  //                    String parental = getText(itemDevice, "Parental");
  //                    if (!ObjectUtils.isEmpty(parental)) {
  //                        try {
  //                            // 由于海康会错误的发送65535作为这里的取值,所以这里除非是0否则认为是1
  //                            if (!ObjectUtils.isEmpty(parental) && parental.length() == 1 && Integer.parseInt(parental) == 0) {
  //                                deviceChannel.setParental(0);
  //                            }else {
  //                                deviceChannel.setParental(1);
  //                            }
  //                        }catch (NumberFormatException e) {
  //                            logger.warn("[xml解析] 从通道数据获取 parental失败： {}", parental);
  //                        }
  //                    }
  //                    // 父设备/区域/系统ID
  //
  //                    if (!ObjectUtils.isEmpty(parentID) ) {
  //                        if (parentID.contains("/")) {
  //                            String[] parentIdArray = parentID.split("/");
  //                            deviceChannel.setParentId(parentIdArray[parentIdArray.length - 1]);
  //                        }else {
  //                            if (parentID.length()%2 == 0) {
  //                                deviceChannel.setParentId(parentID);
  //                            }else {
  //                                logger.warn("[xml解析] 不规范的parentID：{}, 已舍弃", parentID);
  //                            }
  //                        }
  //                    }else {
  //                        if (!ObjectUtils.isEmpty(businessGroupID)) {
  //                            deviceChannel.setParentId(businessGroupID);
  //                        }else {
  //                            if (!ObjectUtils.isEmpty(deviceChannel.getCivilCode())) {
  //                                deviceChannel.setParentId(deviceChannel.getCivilCode());
  //                            }
  //                        }
  //                    }
  //                    // 注册方式
  //                    if (!ObjectUtils.isEmpty(registerWay)) {
  //                        try {
  //                            int registerWayInt = Integer.parseInt(registerWay);
  //                            deviceChannel.setRegisterWay(registerWayInt);
  //                        }catch (NumberFormatException exception) {
  //                            logger.warn("[xml解析] 从通道数据获取registerWay失败： {}", registerWay);
  //                            deviceChannel.setRegisterWay(1);
  //                        }
  //                    }else {
  //                        deviceChannel.setRegisterWay(1);
  //                    }
  //
  //                    // 信令安全模式(可选)缺省为0; 0:不采用;2:S/MIME 签名方式;3:S/MIME加密签名同时采用方式;4:数字摘要方式
  //                    String safetyWay = getText(itemDevice, "SafetyWay");
  //                    if (!ObjectUtils.isEmpty(safetyWay)) {
  //                        try {
  //                            deviceChannel.setSafetyWay(Integer.parseInt(safetyWay));
  //                        }catch (NumberFormatException e) {
  //                            logger.warn("[xml解析] 从通道数据获取 safetyWay失败： {}", safetyWay);
  //                        }
  //                    }
  //
  //                    // 证书序列号(有证书的设备必选)
  //                    String certNum = getText(itemDevice, "CertNum");
  //                    if (!ObjectUtils.isEmpty(certNum)) {
  //                        deviceChannel.setCertNum(certNum);
  //                    }
  //
  //                    // 证书有效标识(有证书的设备必选)缺省为0;证书有效标识:0:无效 1:有效
  //                    String certifiable = getText(itemDevice, "Certifiable");
  //                    if (!ObjectUtils.isEmpty(certifiable)) {
  //                        try {
  //                            deviceChannel.setCertifiable(Integer.parseInt(certifiable));
  //                        }catch (NumberFormatException e) {
  //                            logger.warn("[xml解析] 从通道数据获取 Certifiable失败： {}", certifiable);
  //                        }
  //                    }
  //
  //                    // 无效原因码(有证书且证书无效的设备必选)
  //                    String errCode = getText(itemDevice, "ErrCode");
  //                    if (!ObjectUtils.isEmpty(errCode)) {
  //                        try {
  //                            deviceChannel.setErrCode(Integer.parseInt(errCode));
  //                        }catch (NumberFormatException e) {
  //                            logger.warn("[xml解析] 从通道数据获取 ErrCode失败： {}", errCode);
  //                        }
  //                    }
  //
  //                    // 证书终止有效期(有证书的设备必选)
  //                    String endTime = getText(itemDevice, "EndTime");
  //                    if (!ObjectUtils.isEmpty(endTime)) {
  //                        deviceChannel.setEndTime(endTime);
  //                    }
  //
  //
  //                    // 设备/区域/系统IP地址
  //                    String ipAddress = getText(itemDevice, "IPAddress");
  //                    if (!ObjectUtils.isEmpty(ipAddress)) {
  //                        deviceChannel.setIpAddress(ipAddress);
  //                    }
  //
  //                    // 设备/区域/系统端口
  //                    String port = getText(itemDevice, "Port");
  //                    if (!ObjectUtils.isEmpty(port)) {
  //                        try {
  //                            deviceChannel.setPort(Integer.parseInt(port));
  //                        }catch (NumberFormatException e) {
  //                            logger.warn("[xml解析] 从通道数据获取 Port失败： {}", port);
  //                        }
  //                    }
  //
  //                    // 设备口令
  //                    String password = getText(itemDevice, "Password");
  //                    if (!ObjectUtils.isEmpty(password)) {
  //                        deviceChannel.setPassword(password);
  //                    }
  //
  //
  //                    // 设备状态
  //                    String status = getText(itemDevice, "Status");
  //                    if (status != null) {
  //                        // ONLINE OFFLINE HIKVISION DS-7716N-E4 NVR的兼容性处理
  //                        if (status.equalsIgnoreCase("ON") || status.equalsIgnoreCase("On") || status.equalsIgnoreCase("ONLINE") || status.equalsIgnoreCase("OK")) {
  //                            deviceChannel.setStatus(true);
  //                        }
  //                        if (status.equalsIgnoreCase("OFF") || status.equalsIgnoreCase("Off") || status.equalsIgnoreCase("OFFLINE")) {
  //                            deviceChannel.setStatus(false);
  //                        }
  //                    }else {
  //                        deviceChannel.setStatus(true);
  //                    }
  ////                    logger.info("状态字符串： {}", status);
  ////                    logger.info("状态结果： {}", deviceChannel.isStatus());
  //                    // 经度
  //                    String longitude = getText(itemDevice, "Longitude");
  //                    if (NumericUtil.isDouble(longitude)) {
  //                        deviceChannel.setLongitude(Double.parseDouble(longitude));
  //                    } else {
  //                        deviceChannel.setLongitude(0.00);
  //                    }
  //
  //                    // 纬度
  //                    String latitude = getText(itemDevice, "Latitude");
  //                    if (NumericUtil.isDouble(latitude)) {
  //                        deviceChannel.setLatitude(Double.parseDouble(latitude));
  //                    } else {
  //                        deviceChannel.setLatitude(0.00);
  //                    }
  //
  //                    deviceChannel.setGpsTime(DateUtil.getNow());
  //
  //                    // -摄像机类型扩展,标识摄像机类型:1-球机;2-半球;3-固定枪机;4-遥控枪机。当目录项为摄像机时可选
  //                    String ptzType = getText(itemDevice, "PTZType");
  //                    if (ObjectUtils.isEmpty(ptzType)) {
  //                        //兼容INFO中的信息
  //                        Element info = itemDevice.element("Info");
  //                        String ptzTypeFromInfo = XmlUtil.getText(info, "PTZType");
  //                        if(!ObjectUtils.isEmpty(ptzTypeFromInfo)){
  //                            try {
  //                                deviceChannel.setPtzType(Integer.parseInt(ptzTypeFromInfo));
  //                            }catch (NumberFormatException e){
  //                                logger.warn("[xml解析] 从通道数据info中获取PTZType失败： {}", ptzTypeFromInfo);
  //                            }
  //                        }
  //                    } else {
  //                        try {
  //                            deviceChannel.setPtzType(Integer.parseInt(ptzType));
  //                        }catch (NumberFormatException e){
  //                            logger.warn("[xml解析] 从通道数据中获取PTZType失败： {}", ptzType);
  //                        }
  //                    }
  //
  //                    // TODO 摄像机位置类型扩展。
  //                    // 1-省际检查站、
  //                    // 2-党政机关、
  //                    // 3-车站码头、
  //                    // 4-中心广场、
  //                    // 5-体育场馆、
  //                    // 6-商业中心、
  //                    // 7-宗教场所、
  //                    // 8-校园周边、
  //                    // 9-治安复杂区域、
  //                    // 10-交通干线。
  //                    // String positionType = getText(itemDevice, "PositionType");
  //
  //                    // TODO 摄像机安装位置室外、室内属性。1-室外、2-室内。
  //                    // String roomType = getText(itemDevice, "RoomType");
  //                    // TODO 摄像机用途属性
  //                    // String useType = getText(itemDevice, "UseType");
  //                    // TODO 摄像机补光属性。1-无补光、2-红外补光、3-白光补光
  //                    // String supplyLightType = getText(itemDevice, "SupplyLightType");
  //                    // TODO 摄像机监视方位属性。1-东、2-西、3-南、4-北、5-东南、6-东北、7-西南、8-西北。
  //                    // String directionType = getText(itemDevice, "DirectionType");
  //                    // TODO 摄像机支持的分辨率,可有多个分辨率值,各个取值间以“/”分隔。分辨率取值参见附录 F中SDPf字段规定
  //                    // String resolution = getText(itemDevice, "Resolution");
  //
  //                    // TODO 下载倍速范围(可选),各可选参数以“/”分隔,如设备支持1,2,4倍速下载则应写为“1/2/4
  //                    // String downloadSpeed = getText(itemDevice, "DownloadSpeed");
  //                    // TODO 空域编码能力,取值0:不支持;1:1级增强(1个增强层);2:2级增强(2个增强层);3:3级增强(3个增强层)
  //                    // String svcSpaceSupportMode = getText(itemDevice, "SVCSpaceSupportMode");
  //                    // TODO 时域编码能力,取值0:不支持;1:1级增强;2:2级增强;3:3级增强
  //                    // String svcTimeSupportMode = getText(itemDevice, "SVCTimeSupportMode");
  //
  //
  //                    deviceChannel.setSecrecy(secrecy);
  //                    break;
  //            }
  //        }
  //
  //        return deviceChannel;
  //    }
  
      /**
       * 新增方法支持内部嵌套
       *
       * @param element xmlElement
       * @param clazz 结果类
       * @param <T> 泛型
       * @return 结果对象
       * @throws NoSuchMethodException
       * @throws InvocationTargetException
       * @throws InstantiationException
       * @throws IllegalAccessException
       */
      public static <T> T loadElement(Element element, Class<T> clazz) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
          Field[] fields = clazz.getDeclaredFields();
          T t = clazz.getDeclaredConstructor().newInstance();
          for (Field field : fields) {
              ReflectionUtils.makeAccessible(field);
              MessageElement annotation = field.getAnnotation(MessageElement.class);
              if (annotation == null) {
                  continue;
              }
              String value = annotation.value();
              String subVal = annotation.subVal();
              Element element1 = element.element(value);
              if (element1 == null) {
                  continue;
              }
              if ("".equals(subVal)) {
                  // 无下级数据
                  Object fieldVal = element1.isTextOnly() ? element1.getText() : loadElement(element1, field.getType());
                  Object o = simpleTypeDeal(field.getType(), fieldVal);
                  ReflectionUtils.setField(field, t,  o);
              } else {
                  // 存在下级数据
                  ArrayList<Object> list = new ArrayList<>();
                  Type genericType = field.getGenericType();
                  if (!(genericType instanceof ParameterizedType)) {
                      continue;
                  }
                  Class<?> aClass = (Class<?>) ((ParameterizedType) genericType).getActualTypeArguments()[0];
                  for (Element element2 : element1.elements(subVal)) {
                      list.add(loadElement(element2, aClass));
                  }
                  ReflectionUtils.setField(field, t, list);
              }
          }
          return t;
      }
  
      public static <T> T elementDecode(Element element, Class<T> clazz) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
          Field[] fields = clazz.getDeclaredFields();
          T t = clazz.getDeclaredConstructor().newInstance();
          for (Field field : fields) {
              ReflectionUtils.makeAccessible(field);
              MessageElementForCatalog annotation = field.getAnnotation(MessageElementForCatalog.class);
              if (annotation == null) {
                  continue;
              }
              String[] values = annotation.value();
              for (String value : values) {
                  boolean subVal = value.contains(".");
                  if (!subVal) {
                      Element element1 = element.element(value);
                      if (element1 == null) {
                          continue;
                      }
                      // 无下级数据
                      Object fieldVal = element1.isTextOnly() ? element1.getText() : loadElement(element1, field.getType());
                      Object o = simpleTypeDeal(field.getType(), fieldVal);
                      ReflectionUtils.setField(field, t,  o);
                      break;
                  } else {
                      String[] pathArray = value.split("\\.");
                      Element subElement = element;
                      for (String path : pathArray) {
                          subElement = subElement.element(path);
                          if (subElement == null) {
                              break;
                          }
                      }
                      if (subElement == null) {
                          continue;
                      }
                      Object fieldVal = subElement.isTextOnly() ? subElement.getText() : loadElement(subElement, field.getType());
                      Object o = simpleTypeDeal(field.getType(), fieldVal);
                      ReflectionUtils.setField(field, t,  o);
                  }
              }
  
          }
          return t;
      }
  
      /**
       * 简单类型处理
       *
       * @param tClass
       * @param val
       * @return
       */
      private static Object simpleTypeDeal(Class<?> tClass, Object val) {
          try {
              if (val == null || val.toString().equalsIgnoreCase("null")) {
                  return null;
              }
              if (tClass.equals(String.class)) {
                  return val.toString();
              }
              if (tClass.equals(Integer.class)) {
                  return Integer.valueOf(val.toString());
              }
              if (tClass.equals(Double.class)) {
                  return Double.valueOf(val.toString());
  
              }
              if (tClass.equals(Long.class)) {
                  return Long.valueOf(val.toString());
              }
              return val;
          }catch (Exception e) {
              return null;
          }
      }
  }