1. <?xml version="1.0" encoding="UTF-8"?>
    2. <Users>
    3.     <user>
    4.         <id>1</id>
    5.         <name>张氏</name>
    6.         <user>
    7.             <id>11</id>
    8.             <name>张一</name>
    9.             <user>
    10.                 <id>111</id>
    11.                 <name>张一的儿子</name>
    12.             </user>
    13.         </user>
    14.         <user>
    15.             <id>2</id>
    16.             <name>张二</name>
    17.             <user>
    18.                 <id>22</id>
    19.                 <name>张二的儿子</name>
    20.             </user>
    21.         </user>
    22.     </user>
    23. </Users>
    1. import org.dom4j.Document;
    2. import org.dom4j.DocumentException;
    3. import org.dom4j.Element;
    4. import org.dom4j.io.OutputFormat;
    5. import org.dom4j.io.SAXReader;
    6. import org.dom4j.io.XMLWriter;
    7. import org.springframework.web.bind.annotation.GetMapping;
    8. import org.springframework.web.bind.annotation.RestController;
    10. import java.io.FileWriter;
    11. import java.io.IOException;
    12. import java.util.ArrayList;
    13. import java.util.LinkedHashMap;
    14. import java.util.List;
    16. @RestController
    17. public class XmlController {
    19.     // 文件路径
    20.     String path = "c1.xml";
    22.     // 获取Xml数据结构
    23.     @GetMapping("getXml")
    24.     public Object getXml() {
    25.         ArrayList<Object> arrayList = new ArrayList<>();
    26.         // 读取xml文件
    27.         Document document = getDocument(path);
    28.         // 获取根节点(此处为Users)
    29.         Element root = document.getRootElement();
    30.         // 获取根节点下的全部子节点(此处为user)
    31.         List<Element> elements = root.elements();
    32.         // 遍历跟节点下的子节点
    33.         for (Element element : elements) {
    34.             // 获取当前节点名字
    35.             String name = element.getName();
    37.             // 节点名字是user就遍历节点下面的字节点
    38.             if (name.equals("user")) {
    39.                 LinkedHashMap<String, Object> map = printUser(element);
    40.                 arrayList.add(map);
    41.             }
    42.         }
    43.         return arrayList;
    44.     }
    46.     public static LinkedHashMap<String, Object> printUser(Element elements) {
    47.         // 存放节点
    48.         LinkedHashMap<String, Object> nodeMap = new LinkedHashMap<>();
    49.         ArrayList<Object> arrayList = new ArrayList<>();
    51.         List<Element> elementList = elements.elements();
    53.         for (Element element : elementList) {
    54.             String name = element.getName();
    55.             if (name.equals("user")) {
    56.                 // 节点名字是user遍历，得到子节点，存放到nodeMap中,结束本次循环
    57.                 LinkedHashMap<String, Object> map = printUser(element);
    58.                 arrayList.add(map);
    59.                 nodeMap.put("child", arrayList);
    60.                 continue;
    61.             }
    62.             String text = element.getText();
    63.             nodeMap.put(name, text);
    64.         }
    65.         return nodeMap;
    66.     }
    69.     /**
    70.      * 根据id删除整个节点，大致为 父节点.remove(字节点)，所有遍历时需要传递父节点
    71.      *
    72.      * @return
    73.      */
    74.     @GetMapping("delete")
    75.     public Object deleteNode() {
    76.         // 需要删除的节点id
    77.         String id = "111";
    78.         Boolean falg = true;
    79.         // 读取xml文件
    80.         Document document = getDocument(path);
    81.         // 获取根节点(此处为Users)
    82.         Element root = document.getRootElement();
    83.         // 获取根节点下的全部子节点(此处为user)
    84.         List<Element> elements = root.elements();
    85.         // 遍历跟节点下的子节点
    86.         for (Element element : elements) {
    87.             // 获取当前节点名字
    88.             String name = element.getName();
    90.             // 节点名字是user就遍历节点下面的字节点
    91.             if (name.equals("user")) {
    92.                 falg = deleteNode(root, element, id);
    93.                 // 写道源文件中
    94.                 writeToFile(document,path);
    95.             }
    96.         }
    97.         return falg ;
    98.     }
    100.     public Boolean deleteNode(Element root, Element elements, String id) {
    102.         boolean falg = true;
    103.         List<Element> elementList = elements.elements();
    105.         for (Element element : elementList) {
    106.             String key = element.getName();
    107.             String value = element.getText();
    109.             if (key.equals("id")) {
    110.                 if (value.equals(id)) {
    111.                     falg = root.remove(elements);
    112.                 }
    113.             }
    115.             if (key.equals("user")) {
    116.                 // 节点名字是user遍历，得到子节点，存放到nodeMap中,结束本次循环
    117.                 deleteNode(elements, element, id);
    118.                 continue;
    119.             }
    120.         }
    121.         return falg;
    122.     }
    124.     /**
    125.      * 根据id在某个节点下添加子节点（给张二添加女儿）
    126.      * 修改节点值，同理，不过有些情况需要删除节点，在添加节点，值
    127.      * @return
    128.      */
    129.     @GetMapping("add")
    130.     public void add(){
    131.         String id="2";
    132.         // 读取xml文件
    133.         Document document = getDocument(path);
    134.         // 获取根节点(此处为Users)
    135.         Element root = document.getRootElement();
    136.         // 获取根节点下的全部子节点(此处为user)
    137.         List<Element> elements = root.elements();
    138.         // 遍历跟节点下的子节点
    139.         for (Element element : elements) {
    140.             // 获取当前节点名字
    141.             String name = element.getName();
    143.             // 节点名字是user就遍历节点下面的字节点
    144.             if (name.equals("user")) {
    145.                 addNode(element,id);
    146.                 // 写道源文件中
    147.                 writeToFile(document,path);
    148.             }
    149.         }
    150.     }
    152.     private void addNode(Element elements,String id) {
    154.         List<Element> elementList = elements.elements();
    156.         for (Element element : elementList) {
    157.             String key = element.getName();
    158.             String value = element.getText();
    160.             if (key.equals("id")) {
    161.                 if (value.equals(id)) {
    162.                     // id相等，就for循环里面子节点的父节点，添加节点
    163.                     Element user = elements.addElement("user");
    164.                     Element id1 = user.addElement("id");
    165.                     // 添加一个没什么用的属性
    166.                     id1.addAttribute("说明","添加成功");
    167.                     id1.addText("222");
    168.                     Element name = user.addElement("name");
    169.                     name.addText("张二的女儿");
    170.                 }
    171.             }
    173.             if (key.equals("user")) {
    174.                 addNode(element,id);
    175.                 continue;
    176.             }
    177.         }
    178.     }
    180.     /**
    181.      * 获取Document对象
    182.      *
    183.      * @param path
    184.      * @return
    185.      * @throws DocumentException
    186.      */
    187.     public Document getDocument(String path) {
    188.         Document document = null;
    189.         try {
    190.             // 1.需要通过SAXReader流加载XML文件
    191.             SAXReader saxReader = new SAXReader();
    192.             // 2.获取Document文件
    193.             document = saxReader.read(path);
    194.         } catch (DocumentException e) {
    195.             System.out.println("读取失败");
    196.             e.printStackTrace();
    197.         }
    199.         return document;
    200.     }
    201.     // 写出到源文件
    202.     public static void writeToFile(Document document, String path)  {
    203.         try {
    204.             // 1.创建输出格式
    205.             OutputFormat prettyPrint = OutputFormat.createPrettyPrint();
    206.             // 2.创建流 XMLWite()
    207.             XMLWriter xmlWriter = new XMLWriter(new FileWriter(path), prettyPrint);
    209.             // 3.写出
    210.             xmlWriter.write(document);
    211.             // 4.刷出
    212.             xmlWriter.flush();
    213.             // 5.关闭
    214.             xmlWriter.close();
    215.         } catch (IOException e) {
    216.             e.printStackTrace();
    217.         }
    218.     }
    219. }