使用jaxp进行dom解析_动力节点Java学院整理

时间：2022-08-26 18:14:39

1.javax.xml.parsers 包中的DocumentBuilderFactory用于创建DOM模式的解析器对象 ， DocumentBuilderFactory是一个抽象工厂类，它不能直接实例化，但该类提供了一个newInstance方法 ，这个方法会根据本地平台默认安装的解析器，自动创建一个工厂的对象并返回

2.调用 DocumentBuilderFactory.newInstance() 方法得到创建 DOM 解析器的工厂。

3.调用工厂对象的 newDocumentBuilder方法得到 DOM 解析器对象。

4.调用 DOM 解析器对象的 parse() 方法解析 XML 文档，得到代表整个文档的 Document 对象，进行可以利用DOM特性对整个XML文档进行操作了。

案例1.遍历xml文件中跟节点下面的所有子节点.

1.xml的约束文件Java.dtd

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<!ELEMENT classes (java班,net班,php班,ios班)>
<!ELEMENT java班 (teachers?,students?)>
<!ELEMENT net班 (teachers?,students?)>
<!ELEMENT php班 (teachers?,students?)>
<!ELEMENT ios班 (teachers?,students?)>
<!ELEMENT teachers (teacher*)>
<!ELEMENT teacher EMPTY>
<!ELEMENT students (student*)>
<!ELEMENT student (name,sex,age)>
<!ATTLIST java班 name CDATA #IMPLIED>
<!ATTLIST net班 name CDATA #IMPLIED>
<!ATTLIST php班 name CDATA #IMPLIED>
<!ATTLIST ios班 name CDATA #IMPLIED>
<!ATTLIST teacher name CDATA #IMPLIED>
<!ATTLIST teacher sex CDATA #IMPLIED>
<!ATTLIST teacher age CDATA #IMPLIED>
<!ELEMENT name (#PCDATA)>
<!ELEMENT sex (#PCDATA)>
<!ELEMENT age (#PCDATA)>
<!ATTLIST student id ID #IMPLIED>

2.xml文件内容如下java.xml

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE classes SYSTEM "bin//parsers//java.dtd">
<classes>
  <java班 name="CSDNJava01班">
    <teachers>
      <teacher name="军哥" sex="男" age="28" />
      <teacher name="刘丽华" sex="女" age="28" />
    </teachers>
    <students>
      <student id="x121">
        <name>王亮</name>
        <sex>女</sex>
        <age>28</age>
      </student>
    </students>
  </java班>
  <!-- 注释0 -->
  <net班 name="CSDNNet01班">xxx</net班>
  <php班 name="CSDNPhp01班"></php班>
  <ios班 name="CSDNIos01班"></ios班>
</classes>
<!-- 对java.xml文件进行CRUD的操作 -->
<!-- 节点
    nodeName      nodeValue    nodeType
element 标签名        null       1
Attr   属性名       属性值      2
text   #text        文本的值     3
 -->

3.遍历xml文件的操作

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//1.获取XML的根节点对象
@Test
  public void test() throws ParserConfigurationException, SAXException, IOException{
    //调用 DocumentBuilderFactory.newInstance() 方法得到创建 DOM 解析器的工厂
    DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
    //调用工厂对象的 newDocumentBuilder方法得到 DOM 解析器对象
    DocumentBuilder builder = builderFactory.newDocumentBuilder();
    //通过文件的方式获取Document对象
    /*File file = new File("src//parsers//java.xml");
    System.out.println(file+"----");
    Document document = builder.parse(file);*/
    //解析指定的文件
    InputStream is= this.getClass().getClassLoader()
               .getResourceAsStream("parsers//java.xml");
    Document document = builder.parse(is);
     
    //document.getDocumentElement()获取根节点的元素对象
    Element root = document.getDocumentElement();
    //遍历根节点下面的所有子节点
    listNodes(root);
  }

2.遍历节点对象的方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/**
   * 遍历根据节点对象下面的所有的节点对象
   * @param node
   */
  public void listNodes(Node node) {
    // 节点是什么类型的节点
    if (node.getNodeType() == Node.ELEMENT_NODE) {// 判断是否是元素节点
      Element element = (Element) node;
      //判断此元素节点是否有属性
      if(element.hasAttributes()){
        //获取属性节点的集合
        NamedNodeMap namenm =  element.getAttributes();//Node
        //遍历属性节点的集合
        for(int k=0;k<namenm.getLength();k++){
          //获取具体的某个属性节点
          Attr attr = (Attr) namenm.item(k);
          System.out.println("name:::"+attr.getNodeName()+" value::"
                   +attr.getNodeValue()+" type::"+attr.getNodeType());
        }
      }
      //获取元素节点的所有孩子节点
      NodeList listnode = element.getChildNodes();
      //遍历
      for (int j = 0; j < listnode.getLength(); j++) {
        //得到某个具体的节点对象
        Node nd = listnode.item(j);
        System.out.println("name::" + nd.getNodeName() + " value:::"
            + nd.getNodeValue() + " type:::" + nd.getNodeType());
        //重新调用遍历节点的操作的方法
        listNodes(nd);
      }
 
    }
  }

4.查询某个节点对象(简单列举一些案例)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/**
 * 根据标签的名称查找所有该名称的节点对象
 */
public void findNode(Document document) {
  //根据标签名称获取该名称的所有节点对象
  NodeList nodelist = document.getElementsByTagName("teacher");
  //遍历
  for (int i = 0; i < nodelist.getLength(); i++) {
    //得到具体的某个节点对象
    Node node = nodelist.item(i);
    System.out.println(node.getNodeName());
  }
}
 
/**
 * 根据属性的值 查询某个节点对象
 * 属性值是唯一（假设）
 * @param document
 * @param value
 * @return
 */
public Node findNodeByAttrValue(Document document, String value) {
  //根据标签名称获取该名称的节点对象集合
  NodeList nodelist = document.getElementsByTagName("teacher");
  //遍历
  for (int i = 0; i < nodelist.getLength(); i++) {
    //获取某个具体的元素节点对象
    Element node = (Element) nodelist.item(i);
    //根据属性名称获取该节点的属性节点对象
    Attr attr = node.getAttributeNode("name");
    //获取属性节点的值是否给指定的节点属性值相同
    if (attr.getNodeValue().equals(value)) {
      //返回此节点
      return node;
    }
  }
  return null;
}
 
/**
 * 根据id获取某个节点对象
 *
 * @param document
 * @param id
 * @return
 */
public Node findNodeById(Document document, String id) {
  return document.getElementById(id);
}

5.删除指定的节点对象

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
   * 删除某个节点对象
   *
   * @param document
   * @param id
   * @throws TransformerException
   */
  public void deleteNodeById(Document document, String id)
      throws TransformerException {
    //获取删除的节点对象
    Node node = document.getElementById(id);
    // 是通过父节点调用removeChild(node)把子节点给删除掉
    Node node1 = node.getParentNode().removeChild(node);
     
    //创建TransformerFactory对象
    TransformerFactory transformerFactory = TransformerFactory
        .newInstance();
    //Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出
    //Transformer对象通过TransformerFactory获得
    Transformer transformer = transformerFactory.newTransformer();
    // 把Document对象又重新写入到一个XML文件中。
    transformer.transform(new DOMSource(document), new StreamResult(
        new File("src//a.xml")));
  }

6.更新某个节点对象

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/**
 * 更新某个节点
 *
 * @param document
 * @param id
 * @throws TransformerException
 */
public void updateNodeById(Document document, String id)
    throws TransformerException {
  //根据id获取元素指定的元素节点对象
  Element node = document.getElementById(id);
  //获取元素节点的id属性节点对象
  Attr attr = node.getAttributeNode("id");
  //修改元素节点的属性值
  attr.setValue("x122");
 
  //获取该节点对象的所有孩子节点对象name、age、sex节点
  NodeList nodelist = node.getChildNodes();
    //遍历
  for (int i = 0; i < nodelist.getLength(); i++) {
    //得到具体的节点对象
    Node n = nodelist.item(i);
    //判断是否是元素节点对象
    if (n.getNodeType() == Node.ELEMENT_NODE) {
      //看是否是name节点
      if (n.getNodeName().equals("name")) {
        n.setTextContent("君君");//修改其值
      } else if (n.getNodeName().equals("age")) {//看看是否是age节点
        n.setTextContent("80");//修改其值
      } else if (n.getNodeName().equals("sex")) {//看看是否是sex节点
        n.setTextContent("男");//修改其值
      } else {
        System.out.println("不做处理");
      }
    }
  }
 
  //创建TransformerFactory对象
  TransformerFactory transformerFactory = TransformerFactory
      .newInstance();
  //Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出
  //Transformer对象通过TransformerFactory获得
  Transformer transformer = transformerFactory.newTransformer();
  //把Document对象又重新写入到一个XML文件中。
  transformer.transform(new DOMSource(document), new StreamResult(
      new File("src//b.xml")));
}

7.在某个节点的下方添加新的节点

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
/**
 * 在指定的节点下方添加新得某个节点
 *
 * @param document
 * @param id
 * @throws TransformerException
 */
public void addNodeById(Document document, String id)
    throws TransformerException {
  //获取要添加位置节点的兄弟节点对象
  Element node = document.getElementById(id);
  //获取其父节点对象
  Node parentNode = node.getParentNode();
  //创建元素节点
  Element nd = document.createElement("student");
  //设置元素节点的属性值
  nd.setAttribute("id", "x123");
  //创建name元素节点
  Node name = document.createElement("name");
  //设置name节点的文本值
  name.appendChild(document.createTextNode("陈红军"));
  //创建age元素节点
  Node age = document.createElement("age");
  //设置age节点的文本值
  age.appendChild(document.createTextNode("20"));
  //创建sex元素节点
  Node sex = document.createElement("sex");
  //设置sex节点的文本值
  sex.appendChild(document.createTextNode("男"));
  //在nd节点中添加3个子节点
  nd.appendChild(name);
  nd.appendChild(age);
  nd.appendChild(sex);
  //在父节点中添加nd节点
  parentNode.appendChild(nd);
  //创建TransformerFactory对象
  TransformerFactory transformerFactory = TransformerFactory
      .newInstance();
  //Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出
  //Transformer对象通过TransformerFactory获得
  Transformer transformer = transformerFactory.newTransformer();
  //把Document对象又重新写入到一个XML文件中。
  transformer.transform(new DOMSource(document), new StreamResult(
      new File("src//c.xml")));
}

通过以上方法的练习希望你对xml的DOM解析有个入门的了解.

总结

以上所述是小编给大家介绍的使用jaxp进行dom解析_，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持！

标签：

相关文章