XML解析

<!-- https://mvnrepository.com/artifact/dom4j/dom4j -->
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>

使用dom4j解析xml

通过反射，如果自己能够创建好Vo文件

 对应XML文件中的节点

public FaultReportVo readHdrXml(String url) throws Exception {
        //xml文件路径
        String inputUrl = url + ".HDR";
        SAXReader reader = new SAXReader();
        // 加载dom对象
        Document document = reader.read(new File(inputUrl));
        // 获取根节点
        Element rootElement = document.getRootElement();
        //节点对应的vo的包地址
        String rootPackageUrl = "cn.com.liandisys.gzlb.vo.hdr";
        return (FaultReportVo)ReadXmlUtil.reflectNewInstance(rootPackageUrl,rootElement);
    }



package cn.com.liandisys.gzlb.common.util;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.dom4j.Element;
/**
 * XML解析
 * @author MrLu
 *
 */
public class ReadXmlUtil {

    /**
     * 创建节点对象
     * @param packageUrl 节点对应的包地址   cn.com.liandisys.gzlb.vo.hdr
     * @param element 节点对象
     * @return
     * @throws Exception
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static Object reflectNewInstance(String packageUrl, Element element)
            throws Exception {
        Class<?> newClass = Class
                .forName(packageUrl+"." + element.getName() + "Vo");
        Object classSta = newClass.newInstance();
        Iterator iterator = element.elementIterator();
        while (iterator.hasNext()) {
            Element el = (Element) iterator.next();
            Object obj = null;
            if (el.elementIterator().hasNext()) {
                obj = reflectNewInstance(packageUrl, el);
            }
            // 获取所有字段
            Field[] fields = newClass.getDeclaredFields();
            for (Field field : fields) {
                if (field.getName().toUpperCase()
                        .contains(el.getName().toUpperCase())) {
                    // 判断是否是List<?>类型
                    if (field.getType().isAssignableFrom(List.class)) {
                        // 获取List中的类型
                        Type fc = field.getGenericType();
                        // 如果是当前的对象类型
                        if (fc instanceof ParameterizedType) {
                            if (!field.isAccessible()) {
                                field.setAccessible(true);
                            }
                            ParameterizedType pt = (ParameterizedType) fc;
                            // 获取list对象集合的实例类型
                            Class genericClazz = (Class) pt
                                    .getActualTypeArguments()[0];
                            // 转换为List<?>中的泛型对象
                            Method getMethod = newClass.getMethod("get"
                                    + getFirstUpper(field.getName()));
                            Method setMethod = newClass.getMethod("set"
                                    + getFirstUpper(field.getName()),
                                    List.class);
                            // 先获取List
                            List list = (List) getMethod.invoke(classSta);
                            if (list == null) {
                                list = new ArrayList<Object>();
                            }
                            list.add(genericClazz.cast(obj));
                            setMethod.invoke(classSta, list);
                        }
                    } else if (field.getType() == String.class) {
                        Method method = newClass.getDeclaredMethod("set"
                                + getFirstUpper(field.getName()), String.class);
                        method.invoke(classSta, el.getStringValue());
                    }
                }
            }
        }
        if (classSta != null) {
            return classSta;
        }
        return null;
    }

    // 首字母大写
    private static String getFirstUpper(String str) {
        return str.substring(0, 1).toUpperCase() + str.substring(1);
    }

}