Dom4j解析xml

1. 解析xml的方式有很多种

1. DOM方法    2. SAX方法    3.JDOM方法   4.DOM4J方法

2. 例举DOM4J解析（解析比较复杂，含有样式解析，有删除样式和保存样式，过滤xml中删除的样式）

3. 引入依赖

<dependency>
   <groupId>org.dom4j</groupId>
   <artifactId>dom4j</artifactId>
   <version>2.1.4</version>
</dependency>

 public Map<String, String> parseXml(byte[] data, String emrEditorType) {
        Map<String, String> map = new HashMap<>(16);
        try {
            //字节码转化成string
            String blnr = new String(data, "UTF-8")
                    .replaceAll("&#[a-zA-Z0-9]+;", "").replace(' ', ' ');
            blnr = blnr.replace(ConstantValues.HALF_SPACE, ConstantValues.SPACE);
            Document doc = new SAXReader().read(new ByteArrayInputStream(blnr.getBytes("UTF-8")));
            map = new LinkedHashMap<>();
            // 痕迹删除集合
            HashSet set = new HashSet();
            CommonUtils.parsingTrace(doc.getRootElement().elementIterator(), set, emrEditorType);
            //编辑器1解析
            if (ConstantValues.CONSTANT_0.equals(emrEditorType)) {
                CommonUtils.getTemplateMapByBackGroundTextWinning(doc.getRootElement().elementIterator(), map, set);
            } else {
            //编辑器2解析
                CommonUtils.getTemplateMapByBackGroundText(doc.getRootElement().elementIterator(), map, set);
            }
        } catch (Exception ex) {
            if (!map.containsKey(ConstantValues.BODY_TEXT)) {
                map.put(ConstantValues.BODY_TEXT, "");
            }
            logger.error("请求异常",ex);
            return new HashMap<>();
        }
        return map;
    }

//解析删除的集合
public static void parsingTrace(Iterator it, HashSet set, String emrEditorType) {
        while (it.hasNext()) {
            org.dom4j.Element nextRoot = (org.dom4j.Element) it.next();
            Iterator nextIt = nextRoot.elementIterator();
            //当前xml标签下，存嵌套了其他标签
            if (nextIt.hasNext()) {
                parsingTrace(nextIt, set, emrEditorType);
            } else { //当前xml标签下，只有值，未嵌套其他标签
                String text = nextRoot.getName();
                // 痕迹解析
                if (ConstantValues.CONSTANT_0.equals(emrEditorType)) {
                    if (ConstantValues.DELETER_INDEX.equals(text.trim()) && !ConstantValues.CONSTANT_NEGATIVE_1.equals(nextRoot.getText())) {
                        set.add(nextRoot.getParent().attribute("Index").getValue());
                    }
                } else {
                    if (ConstantValues.DELETER_INDEX.equals(text.trim()) && !ConstantValues.CONSTANT_0.equals(nextRoot.getText())) {
                        set.add(nextRoot.getParent().attribute("Index").getValue());
                    }
                }
            }
        }
    }

//解析编辑器1
public static void getTemplateMapByBackGroundText(Iterator it, Map<String, String> map, HashSet set) {
        try {
            //将BackgroundText的值与输入框的值放在map中
            while (it.hasNext()) {
                org.dom4j.Element nextRoot = (org.dom4j.Element) it.next();
                Iterator nextIt = nextRoot.elementIterator();
                //当前xml标签下，存嵌套了其他标签
                if (nextIt.hasNext()) {
                    getTemplateMapByBackGroundText(nextIt, map, set);
                } else { //当前xml标签下，只有值，未嵌套其他标签
                    String text = nextRoot.getName();

                    //获取有效节点  && nextRoot.getParent().element("XElements").element("Element") != null
                    if (ConstantValues.BACK_GROUND_TEXT.equals(text.trim())) {
                        //获取解析字段和解析值
                        StringBuilder elementValue = new StringBuilder();
                        parseTextAndValue(nextRoot, elementValue, map, set);
                        //复选框节点
                    } else if (ConstantValues.CHECKED.equals(text.trim())) {
                        String s = nextRoot.getText();
                        if ("true".equals(s)) {
                            List nodes = nextRoot.getParent().getParent().elements("Element");
                            String key = ((Element) (((Element) nodes.get(0)).elements("Text")).get(0)).getText();
                            if (key.endsWith("：")) {
                                key = key.substring(0, key.indexOf("："));
                            }
                            String value = ((Element) nextRoot.getParent().elements("Caption").get(0)).getText();
                            if (map.containsKey(key)) {
                                map.put(key, map.get(key) + value);
                            } else {
                                map.put(key, value);
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            log.info(e);
        }
    }

// 解析编辑器2
public static void getTemplateMapByBackGroundText(Iterator it, Map<String, String> map, HashSet set) {
        try {
            //将BackgroundText的值与输入框的值放在map中
            while (it.hasNext()) {
                org.dom4j.Element nextRoot = (org.dom4j.Element) it.next();
                Iterator nextIt = nextRoot.elementIterator();
                //当前xml标签下，存嵌套了其他标签
                if (nextIt.hasNext()) {
                    getTemplateMapByBackGroundText(nextIt, map, set);
                } else { //当前xml标签下，只有值，未嵌套其他标签
                    String text = nextRoot.getName();
                    StringBuilder elementValue = new StringBuilder();
                    //获取有效节点
                    Element root = nextRoot.getParent().element("XElements");
                    if (ConstantValues.BACK_GROUND_TEXT.equals(text.trim()) && root != null && root.element("Element") != null) {
                        //获取解析字段和解析值
                        parseTextAndValue(nextRoot, elementValue, map, set);
                    }
                }
            }
        } catch (Exception e) {
            log.info(e);
        }
    }

// 解析字段和值 排除已删除的痕迹
private static void parseTextAndValue(Element nextRoot, StringBuilder elementValue, Map<String, String> map, HashSet set) {
        List nodes = nextRoot.getParent().element("XElements").elements("Element");
        for (Iterator iterator = nodes.iterator(); iterator.hasNext(); ) {
            Element elm = (Element) iterator.next();
            if (elm.element("Text") != null && !set.contains(ObjectUtil.isEmpty(elm.attribute("StyleIndex")) ? "" : elm.attribute("StyleIndex").getValue())) {
                elementValue = elementValue.append(elm.elementIterator().hasNext() ? elm.element("Text").getText() : "");
            }
        }
        map.put(nextRoot.getText(), elementValue.toString().trim());
}