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

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

<!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

<?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.获取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.遍历节点对象的方法

/** 
   * 遍历根据节点对象下面的所有的节点对象 
   * @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.查询某个节点对象(简单列举一些案例)

/** 
 * 根据标签的名称查找所有该名称的节点对象 
 */ 
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.删除指定的节点对象

/** 
   * 删除某个节点对象 
   * 
   * @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.更新某个节点对象

/** 
 * 更新某个节点 
 * 
 * @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.在某个节点的下方添加新的节点

/** 
 * 在指定的节点下方添加新得某个节点 
 * 
 * @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解析_，希望对大家有所帮助