Dom4j 操作XML文件

一、准备工作

1、添加POM依赖

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

2、测试POJO类

public class Student {
    private int id;
    private String name;
    private String sex;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Student(int id, String name, String sex) {
        super();
        this.id = id;
        this.name = name;
        this.sex = sex;
    }

    public Student() {
        super();
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", sex=" + sex + "]";
    }
}

3、测试XML文件

<?xml version="1.0" encoding="utf-8"?>


<students> 
  <student id="1"> 
    <name>张三</name>  
    <sex>男</sex> 
  </student>  
  <student id="2"> 
    <name>李四</name>  
    <sex>女</sex> 
  </student> 
</students>

二、增删改查

public class TestDOM4J {

    private static String xmlFile = "src/students.xml";

    public static void main(String[] args) throws Exception {
        // List<Student> list = getAllStudents();
        // System.out.println(list);
        // Student stu = getStudentById(3);
        // System.out.println(stu);

        // 测试添加

//        addStudent(addStu);
//        removeStudent(3);
        Student stu = getStudentById(1);//找到要修改的人
        System.out.println(stu);
        stu.setName("张三");
        stu.setSex("女");
        updateStudent(stu);

    }

    public static boolean updateStudent(Student student) {
        boolean isUpdateSuccess = false;
        try {
            SAXReader rd = new SAXReader();
            Document doc = rd.read(xmlFile);
            Element root = doc.getRootElement();
            List list = root.elements();
            Iterator it = list.iterator();
            while (it.hasNext()) {
                Element stuElement = (Element) it.next();
                if (Integer.parseInt(stuElement.attribute("id").getValue()) == student.getId()) {
                    stuElement.element("name").setText(student.getName());
                    stuElement.element("sex").setText(student.getSex());
                    isUpdateSuccess = true;
                    break;
                }
            }
            //保存
            Writer writer = new FileWriter(xmlFile);
            OutputFormat format = OutputFormat.createPrettyPrint();// 格式化;
            format.setEncoding("utf-8");
            XMLWriter xmlWriter = new XMLWriter(writer, format);
            xmlWriter.write(doc); // 将文档写入到流中;
            //关闭
            xmlWriter.close();
            writer.close();

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return isUpdateSuccess;
    }

    public static boolean removeStudent(int id) {
        boolean isSuccess = false;
        try {
            SAXReader rd = new SAXReader();
            Document doc = rd.read(xmlFile);
            Element root = doc.getRootElement();
            Element removeElement = null;
            //查询要删除的元素;
            List list = root.elements();
            Iterator it = list.iterator();
            while (it.hasNext()) {
                Element stuElement = (Element) it.next();
                if (Integer.parseInt(stuElement.attribute("id").getValue()) == id) {
                    removeElement = stuElement;
                    break;
                }
            }
            if (removeElement != null) {
                root.remove(removeElement);
                isSuccess = true;
            }
            // 重新保存;
            Writer writer = new FileWriter(xmlFile);
            OutputFormat format = OutputFormat.createPrettyPrint();// 格式化;
            format.setEncoding("utf-8");
            XMLWriter xmlWriter = new XMLWriter(writer, format);
            xmlWriter.write(doc); // 将文档写入到流中;
            //关闭
            xmlWriter.close();
            writer.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
        return isSuccess;
    }

    public static boolean addStudent(Student stu) {
        boolean isSuccess = false;
        try {
            // 1 需要一个读取xml文档的读取器;
            SAXReader rd = new SAXReader();
            // 2 能过读取器加载xml文档;
            Document doc = rd.read(xmlFile);
            // 3 解析document；
            // A 获取根元根;
            Element root = doc.getRootElement();
            // B 向根元素中添加子元素;
            Element newElement = root.addElement("student");
            newElement.addAttribute("id", (stu.getId() + "")); //添加属性
            newElement.addElement("name").setText(stu.getName());
            newElement.addElement("sex").setText(stu.getSex());

            // C 保存文档 ; -->流;
            Writer writer = new FileWriter(xmlFile);
            OutputFormat format = OutputFormat.createPrettyPrint();// 格式化;
            format.setEncoding("utf-8");
            XMLWriter xmlWriter = new XMLWriter(writer, format);
            xmlWriter.write(doc); // 将文档写入到流中;
            // D、关闭流
            xmlWriter.close();
            writer.close();
            isSuccess = true;
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return isSuccess;
    }

    public static Student getStudentById(int id) throws DocumentException {
        Student stu = null;
        // 1 需要一个读取xml文件的 读取器
        SAXReader rd = new SAXReader();
        // 2使用读取器加载xml文件
        Document doc = rd.read(xmlFile);
        // 3 解析document对象
        // A 获取根元素
        Element root = doc.getRootElement();
        // B 获取根下所有子元素;
        List list = root.elements();
        // C 迭代集合，查询是否存要找的元素;
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Element stuElement = (Element) it.next(); // 向下转型 ;
            if (stuElement.attribute("id").getValue().equals((id + ""))) {
                String name = stuElement.element("name").getText();
                String sex = stuElement.element("sex").getText();
                stu = new Student(id, name, sex);
                break;
            }
        }
        return stu;
    }

    public static List<Student> getAllStudents() throws DocumentException {
        // 1 需要有一个解析器 --> 对DOM4J来说，解析器为读取器;
        SAXReader rd = new SAXReader(); // 创建一个DOM4J的读取器（解析器）
        // 2 使用解析器 读取要解析xml文档 ;
        Document doc = rd.read(xmlFile);
        // 3 读取文档数据;
        // A 从根元素开始
        Element root = doc.getRootElement();
        // B 获取根下的所有子元素
        List list = root.elements("student"); // 获取根下所有子元素
        // C 从集合中取出数据
        Iterator it = list.iterator();
        List<Student> stuLists = new ArrayList<Student>();
        Student stu = null;
        while (it.hasNext()) {
            Element stuElement = (Element) it.next();
            int id = Integer.parseInt(stuElement.attribute("id").getValue());
            String name = stuElement.element("name").getTextTrim();
            String sex = stuElement.element("sex").getTextTrim();
            stu = new Student(id, name, sex);
            stuLists.add(stu);
        }
        return stuLists;
    }

}

三、Map 转 XML

public static Document map2xml(Map<String, Object> map) throws DocumentException, IOException {
        Iterator<Map.Entry<String, Object>> entries = map.entrySet().iterator();
        if (entries.hasNext()) { //获取第一个键创建根节点
            Map.Entry<String, Object> entry = entries.next();
            Document doc = DocumentHelper.createDocument();
            Element root = DocumentHelper.createElement(entry.getKey());
            doc.add(root);
            map2xml((Map) entry.getValue(), root);
            System.out.println(doc.asXML());
            //System.out.println(formatXml(doc));
            return doc;
        }
        return null;
    }

    /**
     * map转xml
     *
     * @param map
     * @param body xml元素
     * @return
     */
private static Element map2xml(Map<String, Object> map, Element body) {
        Iterator<Map.Entry<String, Object>> entries = map.entrySet().iterator();
        while (entries.hasNext()) {
            Map.Entry<String, Object> entry = entries.next();
            String key = entry.getKey();
            Object value = entry.getValue();
            if (key.startsWith("@")) {    //属性
                body.addAttribute(key.substring(1, key.length()), value.toString());
            } else if (key.equals("#text")) { //有属性时的文本
                body.setText(value.toString());
            } else {
                if (value instanceof java.util.List) {
                    List list = (List) value;
                    Object obj;
                    for (int i = 0; i < list.size(); i++) {
                        obj = list.get(i);
                        //list里是map或String，不会存在list里直接是list的，
                        if (obj instanceof java.util.Map) {
                            Element subElement = body.addElement(key);
                            map2xml((Map) list.get(i), subElement);
                        } else {
                            body.addElement(key).setText((String) list.get(i));
                        }
                    }
                } else if (value instanceof java.util.Map) {
                    Element subElement = body.addElement(key);
                    map2xml((Map) value, subElement);
                } else {
                    body.addElement(key).setText(value.toString());
                }
            }
            //System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
        }
        return body;
    }

四、XML 转 Map

public static Map xml2map(String xmlString) throws DocumentException {
        Document doc = DocumentHelper.parseText(xmlString);
        Element rootElement = doc.getRootElement();
        Map<String, Object> map = new HashMap<String, Object>();
        ele2map(map, rootElement);
        System.out.println(map);
        // 到此xml2map完成，下面的代码是将map转成了json用来观察我们的xml2map转换的是否ok  
        String string = JSONObject.fromObject(map).toString();
        System.out.println(string);
        return map;
    }

    /*** 
     * 核心方法，里面有递归调用 
     *
     * @param map
     * @param ele
     */
public static void ele2map(Map map, Element ele) {
        System.out.println(ele);
        // 获得当前节点的子节点  
        List<Element> elements = ele.elements();
        if (elements.size() == 0) {
            // 没有子节点说明当前节点是叶子节点，直接取值即可  
            map.put(ele.getName(), ele.getText());
        } else if (elements.size() == 1) {
            // 只有一个子节点说明不用考虑list的情况，直接继续递归即可  
            Map<String, Object> tempMap = new HashMap<String, Object>();
            ele2map(tempMap, elements.get(0));
            map.put(ele.getName(), tempMap);
        } else {
            // 多个子节点的话就得考虑list的情况了，比如多个子节点有节点名称相同的  
            // 构造一个map用来去重  
            Map<String, Object> tempMap = new HashMap<String, Object>();
            for (Element element : elements) {
                tempMap.put(element.getName(), null);
            }
            Set<String> keySet = tempMap.keySet();
            for (String string : keySet) {
                Namespace namespace = elements.get(0).getNamespace();
                List<Element> elements2 = ele.elements(new QName(string, namespace));
                // 如果同名的数目大于1则表示要构建list  
                if (elements2.size() > 1) {
                    List<Map> list = new ArrayList<Map>();
                    for (Element element : elements2) {
                        Map<String, Object> tempMap1 = new HashMap<String, Object>();
                        ele2map(tempMap1, element);
                        list.add(tempMap1);
                    }
                    map.put(string, list);
                } else {
                    // 同名的数量不大于1则直接递归去  
                    Map<String, Object> tempMap1 = new HashMap<String, Object>();
                    ele2map(tempMap1, elements2.get(0));
                    map.put(string, tempMap1);
                }
            }
        }
    }