2009年6月10日随笔档案 - jerryhanwei

用Java解析XML文档，最常用的有两种方法：使用基于事件的XML简单API（Simple API for XML）称为SAX和基于树和节点的文档对象模型（Document Object Module）称为DOM。Sun公司提供了Java API for XML Parsing（JAXP）接口来使用SAX和DOM，通过JAXP，我们可以使用任何与JAXP兼容的XML解析器。

JAXP接口包含了三个包：

（1）        org.w3c.dom   W3C推荐的用于XML标准规划文档对象模型的接口。

（2）        org.xml.sax    用于对XML进行语法分析的事件驱动的XML简单API（SAX）

（3）        javax.xml.parsers解析器工厂工具，程序员获得并配置特殊的特殊语法分析器。

二、         前提

DOM编程不要其它的依赖包，因为JDK里自带的JDK里含有的上面提到的org.w3c.dom、org.xml.sax 和javax.xml.parsers包就可以满意条件了。

三、         使用DOM解析XML文档

我们现在来看看DOM是如何解析XML的吧！同样的，我将从一个简单的不能再简单的例子来说明DOM是如何解析XML文档的，先让我们看看XML是什么内容吧：

<?xml version="1.0" encoding="gb2312"?>

<books>

   <book email="zhoujunhui">

         <name>rjzjh</name>

         <price>jjjjjj</price>

   </book>

</books>

简单的不能再简单了。但是该有的都有了，根元素、属性、子节点。好了，能反应问题就行了，下面来看看解析这个XML文件的Java代码吧！

1 public class DomParse {

2      public DomParse(){

3             DocumentBuilderFactory domfac=DocumentBuilderFactory.newInstance();

4             try {

5                    DocumentBuilder dombuilder=domfac.newDocumentBuilder();

6                    InputStream is=new FileInputStream("bin/library.xml");

7                    Document doc=dombuilder.parse(is);

8

9                    Element root=doc.getDocumentElement();

10                   NodeList books=root.getChildNodes();

11                   if(books!=null){

12                          for(int i=0;i<books.getLength();i++){

13                                 Node book=books.item(i);

14                                 if(book.getNodeType()==Node.ELEMENT_NODE){

15                   String email=book.getAttributes().getNamedItem("email").getNodue();

16                                        System.out.println(email);

17                   for(Node node=book.getFirstChild();node!=null;node=node.getNextSibling()){

18                                               if(node.getNodeType()==Node.ELEMENT_NODE){

19                                                      if(node.getNodeName().equals("name")){

20                                                             String name=node.getNodue();

21                                                             String name1=node.getFirstChild().getNodue();

22                                                             System.out.println(name);

23                                                             System.out.println(name1);

24                                                      }

25                                                      if(node.getNodeName().equals("price")){

26                                                             String price=node.getFirstChild().getNodue();

27                                                             System.out.println(price);

28                                                      }

29                                               }

30                                        }

31                                 }

32                          }

33                   }

34            } catch (ParserConfigurationException e) {

35                   e.printStackTrace();

36            } catch (FileNotFoundException e) {

37                   e.printStackTrace();

38            } catch (SAXException e) {

39                   e.printStackTrace();

40            } catch (IOException e) {

41                   e.printStackTrace();

42            }

43     }

44     public static void main(String[] args) {

45            new DomParse();

46     }

47 }

四、         代码解释

先看看这个程序引用类：

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

//下面主要是org.xml.sax包的类

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.xml.sax.SAXException;

上面那么简单的代码一看就明白了，但是为了介绍个DOM编程的大概还是来看看这个程序吧：

（1）        得到DOM解析器的工厂实例

                    DocumentBuilderFactory domfac=DocumentBuilderFactory.newInstance();

       得到javax.xml.parsers.DocumentBuilderFactory;类的实例就是我们要的解析器工厂

（2）        从DOM工厂获得DOM解析器

                           DocumentBuilder dombuilder=domfac.newDocumentBuilder();

       通过javax.xml.parsers.DocumentBuilderFactory实例的静态方法newDocumentBuilder()得到DOM解析器

（3）        把要解析的XML文档转化为输入流，以便DOM解析器解析它

                 InputStream is=new FileInputStream("bin/library.xml");

InputStream是一个接口。

（4）        解析XML文档的输入流，得到一个Document

                     Document doc=dombuilder.parse(is);

由XML文档的输入流得到一个org.w3c.dom.Document对象，以后的处理都是对Document对象进行的

（5）        得到XML文档的根节点

                     Element root=doc.getDocumentElement();

在DOM中只有根节点是一个org.w3c.dom.Element对象。

（6）得到节点的子节点

                NodeList   books=root.getChildNodes();

              for(int i=0;i<books.getLength();i++){

                              Node book=books.item(i);

            }

这是用一个org.w3c.dom.NodeList接口来存放它所有子节点的，还有一种轮循子节点的方法，后面有介绍

（7）取得节点的属性值

                     String email=book.getAttributes().getNamedItem("email").getNodue();

                                          System.out.println(email);

注意，节点的属性也是它的子节点。它的节点类型也是Node.ELEMENT_NODE

（8）轮循子节点

                  for(Node node=book.getFirstChild();node!=null;node=node.getNextSibling()){

                                              if(node.getNodeType()==Node.ELEMENT_NODE){

                                                     if(node.getNodeName().equals("name")){
                                                            String name=node.getNodue();

                                                            String name1=node.getFirstChild().getNodue();

                                                            System.out.println(name);

                                                            System.out.println(name1);

                                                     }

                                                      if(node.getNodeName().equals("price")){

                                                            String price=node.getFirstChild().getNodue();

                                                            System.out.println(price);
                                                     }

                                               }

这段代码的打印输出为：

null

alterrjzjh

jjjjjj

从上面可以看出

                          String name=node.getNodue();    是一个空值。而

                          String name1=node.getFirstChild().getNodue();   才是真正的值，这是因为DOM把<name>rjzjh</name>也当作是两层结构的节点，其父节点为<name>节点本身，且它只有一个子节点（如果有属性的话就不止一个了！），子节点是它的值“rjzjh”，所以我们看到上面的结果。

还有，子节点的节点类型也是Node.ELEMENT_NODE型的，node.getNextSibling()方法是取下一个相邻的节点。

五、         DOM结点

DOM是一些节点的集合，由于文档中可能包含有不同类型的信息，所以定义了几种不同类型的节点。DOM中最常见的节点类型有：

（1）元素：

元素是XML的基本构件。元素的子节点可以是其它元素、文本节点或两者都有。元素节点还可以只含有属性这一唯一类型的节点。

（2）属性：

      属性节点包含关于元素节点的信息，但它不是元素的子节点

（3）文本：

      文本节点文本信息，或干脆是空白的文本。

（4）文档：

      文档节点是整个文档中所有其它节点的父节点

元素是一种很重要的类型节点，元素节点可以是其他节点的容器。

六、DOM解析XML文档的步骤：

主要几步见第四点的（1），（2），（3），（4）步骤

已投稿到：排行榜圈子

阅读(5)|评论(0)|收藏(0)|打印|举报

前一篇：Java数据库连接池
后一篇：java写的用DOM来解析、修改、删除XML

posted @ 2009-06-17 15:48 hanwei 阅读(300) | 评论 (0) | 编辑收藏

对xml增删改查 http://blog.sina.com.cn/s/blog_5a7cc3aa0100dvoy.html

java写的用DOM来解析、修改、删除XML(2009-06-03 10:31:26)

标签：杂谈

分类：xml

magicalXML.java

package com.magicalxml;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.*;
import org.xml.sax.SAXException;

public class magicalXML {
public static void main(String[] args) throws ParserConfigurationException {
   magicalXML u = new magicalXML();
    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    DocumentBuilder db = dbf.newDocumentBuilder();
   try {
    //读取源文件,如果不存在就创建一个新的给它
    File f = new File("E:""XML""test""magical123.xml");
    Document d = db.parse(f);
    TransformerFactory tfFac = TransformerFactory.newInstance();
    Transformer tf = tfFac.newTransformer();
    tf.setOutputProperty("encoding","GB2312");
    StreamResult result = new StreamResult(System.out);
    DOMSource source = new DOMSource(d);
    System.out.println("修改前的XML:");
    tf.transform(source, result);
    System.out.println();




    System.out.println("修改后的XML:");
    tf.setOutputProperty("encoding","GB2312");
    tf.transform(source, result);
    //保存修改后的xml文件
    tf.transform(source, new StreamResult(new File(
    "E:""XML""test""magical123.xml")));

   } catch (SAXException e) {
    e.printStackTrace();
   } catch (FileNotFoundException e) {
    //创建xml
    Document dl = db.newDocument();
    u.create(dl);
   } catch (TransformerConfigurationException e) {
    e.printStackTrace();
   } catch (TransformerException e) {
    e.printStackTrace();
   } catch (IOException e) {
    e.printStackTrace();
   }

}
//创建方法
public void create(Document d) {
   Element pub = d.createElement("publication");
   Element book = d.createElement("book");
   Element title = d.createElement("Title");
   Element author = d.createElement("Author");

   title.appendChild(d.createTextNode("java basic"));
   author.appendChild(d.createTextNode("john"));
   book.appendChild(title);
   book.appendChild(author);
   pub.appendChild(book);

   book = d.createElement("book");
   title = d.createElement("Title");
   author = d.createElement("Author");
   title.appendChild(d.createTextNode("magicalbook"));
   author.appendChild(d.createTextNode("枫叶"));

   book.appendChild(title);
   book.appendChild(author);
   pub.appendChild(book);
   //增加到根节点
   d.appendChild(pub);
   try {
    TransformerFactory tf = TransformerFactory.newInstance();
    Transformer f = tf.newTransformer();
    f.setOutputProperty("encoding","GB2312");
    System.out.println("正在创建新的xml...");
    f.transform(new DOMSource(d), new StreamResult(new File(
      "E:""XML""test""magical123.xml")));
    System.out.println("创建新的xml成功!新的xml如下:");
    f.transform(new DOMSource(d),new StreamResult(System.out));
   }
   catch (Exception e) {
    e.printStackTrace();
   }
}
//读取元素名称和文本值方法
public void read(Document d) {
   NodeList nl = d.getElementsByTagName("*"); // 取所有结点
   for (int i = 0; i < nl.getLength(); i++) {

    if (nl.item(i).getFirstChild().getNodeType() == Node.ELEMENT_NODE)
     System.out.println("元素名称:"+nl.item(i).getNodeName());
    else {
     System.out.println("元素名称:"+nl.item(i).getNodeName());
     System.out.println("文本值:"+nl.item(i).getTextContent());
    }
   }
}
//元素增加属性方法
public void add(Document d, String title, String attr, String value) {
   NodeList nl = d.getElementsByTagName("Title");
   Element el = d.getDocumentElement();
   Node n;
   Element author;
   String str;
   for(int i=0; i<nl.getLength(); i++) {
    n = nl.item(i);
    author = (Element)n.getNextSibling().getNextSibling();
    if(title.equals(n.getFirstChild().getNodue())) {
     System.out.println("为元素"+author.getNodeName()+"增加"+attr+"属性:"+value);
     author.setAttribute(attr, value);
    }
   }
}
//修改方法
public void update(Document doc, String title, String author) {
   NodeList nl = doc.getElementsByTagName("Title");
   String strNode;
   Element e;
//   Node n;
   System.out.println("有"+nl.getLength()+"个book节点");
   try {
    for(int i = 0; i < nl.getLength(); i++) {
     e = (Element) nl.item(i);
//     n = nl.item(i);
     strNode = e.getFirstChild().getNodue();
//     System.out.println(strNode);
//     strNode = n.getFirstChild().getNodue();
//     System.out.println(strNode);
     if (title.equals(strNode)) {
      Element Eauthor = (Element) e.getNextSibling().getNextSibling();
      System.out.println("修改前的Author:"+Eauthor.getFirstChild().getNodue());
      Eauthor.getFirstChild().setNodue(author);
      System.out.println("修改后的Author:"+Eauthor.getFirstChild().getNodue());
     }
    }
   } catch (Exception ee) {
    ee.printStackTrace();
   }
}
//删除方法
public void delete(Document doc,String title) {
   NodeList nl = doc.getElementsByTagName("Title");
   Element e = doc.getDocumentElement();
   Node n;
   String strNode;
   //System.out.println(""n有"+nl.getLength()+"个Title节点");
   try {
    for(int i=0; i<nl.getLength(); i++) {
     n = nl.item(i).getFirstChild();
     strNode = n.getNodue();
//     System.out.println(e.getNodeName());
//     System.out.println(e.getFirstChild().getNextSibling().getNodeName());
//     System.out.println(nl.item(i).getNodeName());
//     System.out.println(strNode);
     if(("java basic").equals(strNode)) {
      System.out.println(""n准备要删除的书名为"+title+"的作者是:"+nl.item(i).getNextSibling().getNextSibling().getFirstChild().getNodue());
      e.getFirstChild().getNextSibling().removeChild(nl.item(i).getNextSibling().getNextSibling());
      System.out.println("删除成功!");
     }
    }
   } catch (Exception ee) {
    ee.printStackTrace();
   }
}
}

magical123.xml

<?xml version="1.0" encoding="UTF-8" standalone="no"?><publication>
<book>
   <Title>java basic</Title>
   <Author>john</Author>
</book>
<book>
   <Title>magicalbook</Title>
   <Author>magicalboy</Author>
</book>
</publication>

已投稿到：排行榜圈子

阅读(27)|评论(0)|收藏(0)|打印|举报

前一篇：dom解析xml
后一篇：Java与XML联合编程之DOM篇收藏

posted @ 2009-06-17 14:10 hanwei 阅读(385) | 评论 (0) | 编辑收藏

ResultSetMetaData方法获得表结构

在使用JDBC连接数据库的时，我们会采用executeQuery(String sql)获得一个结果集。当数据库结构变化或者获得其他数据库表结果集的时候我们需要将ResultSet结果集根据不同的数据结构重新遍历。
如何才能建立一个与数据库结构无关的JDBC连接呢？我们可以通过使用ResultSetMetaData()方法获得表结构。然后使用Object[]数组遍历结果集。当我们要取得相应的结果时，我们可以使用Iterator迭代器。只要遍历迭代器就可以取出结果。
下面是我写的一个方法：

  1import java.math.BigDecimal;

2import java.sql.Connection;

3import java.sql.DriverManager;

4import java.sql.ResultSet;

5import java.sql.ResultSetMetaData;

6import java.sql.SQLException;

7import java.sql.Statement;

8import java.util.ArrayList;

9import java.util.Iterator;

10import java.util.List;

11

 12publicclass newJdbc {

13private String url ="jdbc:oracle:thin:@localhost: 310-301 :nitpro";

14

15private String dbUserName ="scott";

16

17private String dbUserPassword ="tiger";

18

19private Connection conn =null;

20

21private Statement stmt =null;

22

23private ResultSet rs =null;

24

25public newJdbc() {

26try {

27            Class.forName("oracle.jdbc.driver.OracleDriver");

28        } catch (ClassNotFoundException e) {

29            e.printStackTrace();

30        }

31    }

32

33public Connection getConnection() {

34try {

35            conn = DriverManager.getConnection(url, dbUserName, dbUserPassword);

36        } catch (SQLException e) {

37            e.printStackTrace();

38        }

39return conn;

40    }

41

42publicvoid close(ResultSet rs, Statement stmt, Connection conn) {

43if (rs !=null) {

44try {

45                rs.close();

46            } catch (SQLException e) {

47                e.printStackTrace();

48            }

49        }

50if (stmt !=null) {

51try {

52                stmt.close();

53            } catch (SQLException e) {

54                e.printStackTrace();

55            }

56        }

57if (conn !=null) {

58try {

59                conn.close();

60            } catch (SQLException e) {

61                e.printStackTrace();

62            }

63        }

64    }

65

66public List query(String sql) {

67        List list =new ArrayList();

68

69        conn =this.getConnection();

70try {

71            stmt = conn.createStatement();

72            rs = stmt.executeQuery(sql);

73//获取数据库表结构

74            ResultSetMetaData rsm = rs.getMetaData();

75//取得数据库的列数

76int col = rsm.getColumnCount();

77//生成col长度的Object数组

78            Object[] obj =new Object[col];

79//遍历结果集，将结果存入Object数组

80while (rs.next()) {

81for (int i =0; i < col; i++) {

82                    obj[i] = rs.getObject(i +1);

83                }

84                list.add(obj);

85            }

86        } catch (SQLException e) {

87            e.printStackTrace();

88        } finally {

89this.close(rs, stmt, conn);

90        }

91return list;

92    }

93

94publicvoid update(String sql) {

95try {

96            conn =this.getConnection();

97            stmt = conn.createStatement();

98            stmt.executeUpdate(sql);

99        } catch (SQLException e) {

100            e.printStackTrace();

101        }

102    }

103

104publicstaticvoid main(String args[]) {

105        newJdbc nj =new newJdbc();

106        String sql ="select * from users";

107        List list = nj.query(sql);

108//返回list的迭代器

109        Iterator it = list.iterator();

110//遍历迭代器，取出结果  1z0-147

111while (it.hasNext()) {

112            Object[] o = (Object[]) it.next();

113int id = ((BigDecimal) o[0]).intValue();

114            System.out.println(id);

115        }

116

117    }

118}

posted @ 2009-06-17 11:20 hanwei 阅读(746) | 评论 (0) | 编辑收藏

FTP oracle资料

121.15.144.113
oracle/oracle

posted @ 2009-06-15 14:37 hanwei 阅读(154) | 评论 (0) | 编辑收藏

eclipse jboss ejb开发指南手把手

http://www.blogjava.net/nokiaguy/archive/2009/06/archive/2009/06/archive/2009/06/archive/2009/nokiaguy/archive/2009/05/archive/2009/05/archive/2009/05/archive/2009/05/archive/2009/05/01/268517.html

http://www.blogjava.net/nokiaguy/archive/2009/06/14/282121.html

posted @ 2009-06-15 11:43 hanwei 阅读(198) | 评论 (0) | 编辑收藏

jerryhanwei

PowerDesigner应用外键

http://www.flickr.com/photos/bluek/1441625028/in/set-72157602165101465/

dom解析xml说明

对xml增删改查 http://blog.sina.com.cn/s/blog_5a7cc3aa0100dvoy.html

ResultSetMetaData方法获得表结构

FTP oracle资料

eclipse jboss ejb开发指南手把手

Axis2

正则表达式

框架设计

XSL中文手册

XSL-XSLT入门教程

日历

常用链接

留言簿(2)

随笔分类

随笔档案

文章分类

文章档案

http://blog.csdn.net/pathuang68/archive/2009/04/24/4108254.aspx

搜索

最新评论

阅读排行榜

评论排行榜