Dom4j实现XML解析

1、maven依赖

<dependency>
		<groupId>dom4j</groupId>
		<artifactId>dom4j</artifactId>
		<version>1.6.1</version>
</dependency>

2、新建XML结点类，用来接收解析的xml结点数据

public class XmlNodeInfo {

	/** 节点名称 */
	private String nodeName;
	/** 节点命名空间前缀 */
	private String nodeNamespacePrefix;
	/** 节点值 */
	private String nodeValue;
	/** 父节点名称 */
	private String parentNodeName;
	/** 节点层级 */
	private String nodeLevel;

	/** 节点属性信息 */
	private Map<String, String> attrMap;
	
	/** 子节点集合 */
	private List<XmlNodeInfo> childrenList;

	public String getNodeName() {
		return nodeName;
	}

	public void setNodeName(String nodeName) {
		this.nodeName = nodeName;
	}

	public String getNodeValue() {
		return nodeValue;
	}

	public void setNodeValue(String nodeValue) {
		this.nodeValue = nodeValue;
	}

	public String getParentNodeName() {
		return parentNodeName;
	}

	public void setParentNodeName(String parentNodeName) {
		this.parentNodeName = parentNodeName;
	}

	public Map<String, String> getAttrMap() {
		return attrMap;
	}

	public void setAttrMap(Map<String, String> attrMap) {
		this.attrMap = attrMap;
	}

	public String getNodeLevel() {
		return nodeLevel;
	}

	public void setNodeLevel(String nodeLevel) {
		this.nodeLevel = nodeLevel;
	}

	public String getNodeNamespacePrefix() {
		return nodeNamespacePrefix;
	}

	public void setNodeNamespacePrefix(String nodeNamespacePrefix) {
		this.nodeNamespacePrefix = nodeNamespacePrefix;
	}

	public List<XmlNodeInfo> getChildrenList() {
		return childrenList;
	}

	public void setChildrenList(List<XmlNodeInfo> childrenList) {
		this.childrenList = childrenList;
	}

}

3、xml解析工具类的实现

        实现的思路，遍历xml每个层级的结点，对于每一层级的子节点，再通过递归去完成遍历，递归的边界点就是结点没有子结点为止。

        解析xml文件：

public static List<XmlNodeInfo> dom4jAnalysisXmlFile (String filePath) {
		List<XmlNodeInfo> xmlNodeInfoList = new ArrayList<XmlNodeInfo>();
		if (StringUtils.isEmpty(filePath)) {
			return xmlNodeInfoList;
		}
		
		// 创建SAXReader的对象reader
        SAXReader saxReader = new SAXReader();
		try {
			// 通过SAXReader对象的read方法加载xml文件,获取docuemnt对象。
			Document document = null;
			if (filePath.contains("\\") || filePath.contains("/")) {
				document = saxReader.read(filePath);
			} else {
				URL url = Resources.getResource(filePath);
				File file = new File(url.getPath());
				document = saxReader.read(file);
			}
			if (null == document) {
				return xmlNodeInfoList;
			}
	        // 通过document对象获取根节点
	        Element rootElement = document.getRootElement();
	        // 通过element对象的elementIterator方法获取迭代器
			Iterator rootElementIterator = rootElement.elementIterator();
			xmlNodeInfoList = getXmlChildrenNodeInfo(rootElementIterator, xmlNodeInfoList, null, 0);
		} catch (DocumentException e) {
	        e.printStackTrace();
	        LoggerUtil.error(XmlAnalysisUtils.class, "解析XML失败", e);
	    }
		return xmlNodeInfoList;
	}

          递归遍历方法：

private static List<XmlNodeInfo> getXmlChildrenNodeInfo(Iterator elementIterator, 
			List<XmlNodeInfo> xmlNodeInfoList, String parentNodeName, Integer nodeLevel) {
		// 一级节点
        Element element = null;
        // 一级节点属性信息集合
        List<Attribute> elementAttrs = null;
        // 子节点集合
        List<XmlNodeInfo> xmlChildrenNodeList = null;
        // 节点属性值信息
        Map<String, String> attrMap = null;
        // 子节点Iterator
        Iterator childrenElementIterator = null;
        // 节点信息
        XmlNodeInfo xmlNodeInfo = null;
        // 增加次数
        int addNum = 0;
        
        // 遍历迭代器，获取根节点中的信息
        while (elementIterator.hasNext()) {
        	if (addNum == 0) {
        		nodeLevel++;
        		addNum++;
        	}
        	
        	element = (Element) elementIterator.next();
            xmlNodeInfo = new XmlNodeInfo();
            xmlNodeInfo.setNodeNamespacePrefix(element.getNamespacePrefix());
            xmlNodeInfo.setNodeName(element.getName());
            if (StringUtils.isEmpty(element.getText().replaceAll("\\s*", ""))) {
            	xmlNodeInfo.setNodeValue(element.getText().replaceAll("\\s*", ""));
            } else {
            	xmlNodeInfo.setNodeValue(element.getText());
            }
            xmlNodeInfo.setParentNodeName(parentNodeName);
            xmlNodeInfo.setNodeLevel(String.valueOf(nodeLevel));
            
        	// 获取一级节点的属性名以及 属性值
            elementAttrs = element.attributes();
        	if (CollectionUtils.isNotEmpty(elementAttrs)) {
        		attrMap = new HashMap<String, String>();
            	for (Attribute attr : elementAttrs) {
            		if (StringUtils.isEmpty(attr.getNamespacePrefix())) {
            			attrMap.put(attr.getName(), attr.getValue());
            		} else {
            			attrMap.put(attr.getNamespacePrefix() + ":" + attr.getName(), attr.getValue());
            		}
            	}
            	xmlNodeInfo.setAttrMap(attrMap);
        	}
        	
        	// 获取子节点信息
            if (StringUtils.isNotEmpty(xmlNodeInfo.getNodeName())) {
            	// 遍历子节点
        		childrenElementIterator = element.elementIterator();
            	xmlChildrenNodeList = getXmlChildrenNodeInfo(childrenElementIterator, 
            			new ArrayList<XmlNodeInfo>(), element.getName(), nodeLevel);
            	if (CollectionUtils.isNotEmpty(xmlChildrenNodeList)) {
            		xmlNodeInfo.setChildrenList(xmlChildrenNodeList);
            	}
            }
        	
        	xmlNodeInfoList.add(xmlNodeInfo);
        }
		return xmlNodeInfoList;
	}