XML學習記錄1-複習SAX，DOM和JAXB

　　對xml文檔的解析常見的有JDK中的sax,dom,jaxb,stax和JAVA類庫JDOM和DOM4J，下面先說說前三個。

　　Java中解析XML的工具不少，像JDOM,DOM4J等，但Java標準庫提供的兩種解析XML文檔解析器是：DOM(Document Object Module)解析器 和 SAX(Simple API for XML)解析器。DOM解析器會讀入整個XML文檔並轉換成樹結構；SAX解析器會在讀入XML文檔時生成相應的事件；故也常叫基於文檔對象模型的XML解析和基於事件驅動的XML解析；那它們有什麼區別呢? 

   DOM解析器會讀入整個文檔，構建一個駐留在內存中的樹型結構，咱們就可使用 DOM 接口來操做這個文檔樹，其優勢是整個文檔樹在內存中，便於操做，支持刪除、修改、從新排列等多種功能；缺點是需將整個文檔讀入內存中，在文檔大時會消耗大量內存； 

   SAX解釋器在XML文檔讀入時可以當即開始，而不是等待全部的數據加載完後處理，解析器經過發現元素開始、元素結束、文本開始、文檔結束等來發送事件，經過種基於回調機制的方法來處理數據；其優勢是解析速度快，不用事先調入整個文檔，佔用資源少；其缺點是必須實現事件處理程序，不能修改文檔，不能隨機訪問。

　　JAXB（Java Architecture for XML Binding) 是一個業界的標準，是一項能夠根據XML Schema產生Java類的技術。該過程當中，JAXB也提供了將XML實例文檔反向生成Java對象樹的方法，並能將Java對象樹的內容從新寫到XML實例文檔。從另外一方面來說，JAXB提供了快速而簡便的方法將XML模式綁定到Java表示，從而使得Java開發者在Java應用程序中能方便地結合XML數據和處理函數。

1. 　DOM(Document Object Model)

　　1.解析器工廠類：DocumentBuilderFactory

　　建立的方法：DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

　　2.解析器：DocumentBuilder

　　建立方法：經過解析器工廠類來得到 DocumentBuilder db = dbf.newDocumentBuilder();

　　3.文檔樹模型Document

　　建立方法：a.經過xml文檔 Document doc = db.parse("bean.xml");  b.將須要解析的xml文檔轉化爲輸入流 InputStream is = new FileInputStream("bean.xml");

 　　Document doc = db.parse(is);

　　Document對象表明了一個XML文檔的模型樹，全部的其餘Node都以必定的順序包含在Document對象以內，排列成一個樹狀結構，之後對XML文檔的全部操做都與解析器無關，

　　直接在這個Document對象上進行操做便可；

 　　包含的方法：

 

 

　　4.節點列表類NodeList

　　NodeList表明了一個包含一個或者多個Node的列表，根據操做能夠將其簡化的看作爲數組

　　5.節點類Node

　　Node對象是DOM中最基本的對象，表明了文檔樹中的抽象節點。但在實際使用中不多會直接使用Node對象，而是使用Node對象的子對象Element,Attr,Text等

　　6.元素類Element

　　是Node類最主要的子對象，在元素中能夠包含屬性，於是Element中有存取其屬性的方法

 

　　Node.getNamespaceURI() 返回和給定節點關聯的名稱空間字符串，若是該元素或屬性沒有關聯的名稱空間則返回 null。

　　7.屬性類Attr

　　表明某個元素的屬性，雖然Attr繼承自Node接口，但由於Attr是包含在Element中的，但並不能將其看作是Element的子對象，由於Attr並非DOM樹的一部分

　　實例：

　　DomDemo.java

package dom;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.xml.sax.EntityResolver;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

public class DomDemo {

    public static void main(String[] args) throws Exception {
        String url = System.getProperty("user.dir");
        File xmlFile = new File(url + "/src/dom/beans.xml");
        
        if(!xmlFile.exists())
        {
            System.out.println("file not exist, return.");
            return;
        }
        
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        // 支持命名空間
        dbf.setNamespaceAware(true);
        // 開啓校驗
        dbf.setValidating(true);
        // 忽略註釋
        dbf.setIgnoringComments(true); 
        //若是使用xsd，一船須要設置schemaLanguage的schema版本.  
        dbf.setAttribute("http://java.sun.com/xml/jaxp/properties/schemaLanguage", "http://www.w3.org/2001/XMLSchema");
        
        try
        {
            DocumentBuilder db = dbf.newDocumentBuilder();
            // 校驗出錯處理
            db.setErrorHandler(new ErrorHandler() {
                
                @Override
                public void warning(SAXParseException exception) throws SAXException {
                    System.out.println("warning: " + exception.getMessage());
                    
                }
                
                @Override
                public void fatalError(SAXParseException exception) throws SAXException {
                    System.out.println("fatalError: " + exception.getMessage());
                }
                
                @Override
                public void error(SAXParseException exception) throws SAXException {
                    System.out.println("error: " + exception.getMessage());
                }
            });
            
            // dtd 或者 schema 文件驗證xml
            // 校驗xsd
            db.setEntityResolver(new EntityResolver() {
                
                @Override
                public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {
                    String url = System.getProperty("user.dir");
                    InputSource inputSource = new InputSource(new FileInputStream(new File(url + "/bin/dom/spring-beans-3.2.xsd")));
                    inputSource.setSystemId(systemId);
                    inputSource.setPublicId(publicId);
                    return inputSource;
                }
            });
            
            Document document = db.parse(xmlFile);
            Element root = document.getDocumentElement();
            System.out.println("根元素： " + root.getNodeName());
            
　　　　　　　// 示例用法
            /*NodeList childNodes = root.getChildNodes();
            
            for(int i = 0; i <childNodes.getLength(); i++)
            {
                Node node = childNodes.item(i);
                if("web-app".equals(node.getNodeName()))
                {
                    System.out.println("\r\n找到一篇文章，所屬分類： " + node.getAttributes()
                            .getNamedItem("category").getNodeValue() + ". ");
                    NodeList nodeDetail = node.getChildNodes();
                    for(int j = 0; j < nodeDetail.getLength(); j++)
                    {
                        Node detail = nodeDetail.item(j);
                        if("title".equals(detail.getNodeName()))
                        {
                            System.out.println("標題：" + detail.getTextContent());
                        }
                        else if("author".equals(detail.getNodeName()))
                        {
                            System.out.println("做者：" + detail.getTextContent());
                        }
                        else if("email".equals(detail.getNodeName()))
                        {
                            System.out.println("電子郵箱：" + detail.getTextContent());
                        }
                        else if("date".equals(detail.getNodeName()))
                        {
                            System.out.println("發表日期：" + detail.getTextContent());
                        }
                    }
                }
            }*/
            
        }
        catch(Exception exception)
        {
            exception.printStackTrace();
        }
        
    }
    
    /**
     * DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
     * DocumentBuilder db = dbf.newDocumentBuilder();
     * Document document = db.parse(xmlFile);
     * Element root = document.getDocumentElement();
     * NodeList childNodes = root.getChildNodes();
     * Node node = childNodes.item(i);
     * node.getAttributes();
     * node.getAttributes().getNamedItem("category");
     * detail.getNodeName();
     * detail.getNodeValue();
     * detail.getTextContent();
     * 
     */
}

　　beans.xml

 

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans    
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  

    <!-- 定義使用C3P0鏈接池的數據源 -->  
    <bean d="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">  
        <!-- 指定鏈接數據庫的JDBC驅動 -->  
        <property name="driverClass">  
            <value>com.mysql.jdbc.Driver</value>  
        </property>  
        <!-- 鏈接數據庫所用的URL -->  
        <property name="jdbcUrl">  
            <value>jdbc:mysql://localhost:3306/eportal?useUnicode=true&amp;characterEncoding=utf-8</value>  
        </property>  
        <!-- 鏈接數據庫的用戶名 -->  
        <property name="user">  
            <value>root</value>  
        </property>  
        <!-- 鏈接數據庫的密碼 -->  
        <property name="password">  
            <value>root</value>  
        </property>  
        <!-- 設置數據庫鏈接池的最大鏈接數 -->  
        <property name="maxPoolSize">  
            <value>20</value>  
        </property>  
        <!-- 設置數據庫鏈接池的最小鏈接數 -->  
        <property name="minPoolSize">  
            <value>2</value>  
        </property>  
        <!-- 設置數據庫鏈接池的初始化鏈接數 -->  
        <property name="initialPoolSize">  
            <value>2</value>  
        </property>  
        <!-- 設置數據庫鏈接池的鏈接的最大空閒時間，單位爲秒 -->  
        <property name="maxIdleTime">  
            <value>20</value>  
        </property>  
    </bean>  
    
    <!-- 定義Hibernate的SessionFactory -->  
    <bean id="sessionFactory"  
        class="org.springframework.orm.  
hibernate3.LocalSessionFactoryBean">  
        <!-- 依賴注入上面定義的數據源dataSource -->  
        <property name="dataSource" ref="dataSource" />  
        <!-- 註冊Hibernate的ORM映射文件 -->  
        <property name="mappingResources">  
            <list>  
                <value>com/eportal/ORM/News.hbm.xml</value>  
                <value>com/eportal/ORM/Category.hbm.xml</value>  
                <value>com/eportal/ORM/Memberlevel.hbm.xml</value>  
                <value>com/eportal/ORM/Cart.hbm.xml</value>  
                <value>com/eportal/ORM/Traffic.hbm.xml</value>  
                <value>com/eportal/ORM/Newsrule.hbm.xml</value>  
                <value>com/eportal/ORM/Merchandise.hbm.xml</value>  
                <value>com/eportal/ORM/Admin.hbm.xml</value>  
                <value>com/eportal/ORM/Orders.hbm.xml</value>  
                <value>com/eportal/ORM/Cartselectedmer.hbm.xml</value>  
                <value>com/eportal/ORM/Newscolumns.hbm.xml</value>  
                <value>com/eportal/ORM/Member.hbm.xml</value>  
            </list>  
        </property>  
        <!-- 設置Hibernate的相關屬性 -->  
        <property name="hibernateProperties">  
            <props>  
                <!-- 設置Hibernate的數據庫方言 -->  
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
                <!-- 設置Hibernate是否在控制檯輸出SQL語句，開發調試階段一般設爲true -->  
                <prop key="show_sql">true</prop>  
                <!-- 設置Hibernate一個提交批次中的最大SQL語句數 -->  
                <prop key="hibernate.jdbc.batch_size">50</prop>  
                <prop key="show_sql">50</prop>  
            </props>  
        </property>  
    </bean>  
    <!--定義Hibernate的事務管理器HibernateTransactionManager -->  
    <bean id="transactionManager"  
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
        <!-- 依賴注入上面定義的sessionFactory -->  
        <property name="sessionFactory" ref="sessionFactory" />  
    </bean>  
    <!--定義Spring的事務攔截器TransactionInterceptor -->  
    <bean id="transactionInterceptor"  
        class="org.springframework.transaction.interceptor.TransactionInterceptor">  
        <!-- 依賴注入上面定義的事務管理器transactionManager -->  
        <property name="transactionManager" ref="transactionManager" />  
        <!-- 定義須要進行事務攔截的方法及所採用的事務控制類型 -->  
        <property name="transactionAttributes">  
            <props>  
                <!-- 以browse、list、load、get及is開頭的全部方法採用只讀型事務控制類型 -->  
                <prop key="browse*">PROPAGATION_REQUIRED,readOnly</prop>  
                <prop key="list*">PROPAGATION_REQUIRED,readOnly</prop>  
                <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>  
                <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>  
                <prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>  
                <!-- 全部方法均進行事務控制，若是當前沒有事務，則新建一個事務 -->  
                <prop key="*">PROPAGATION_REQUIRED</prop>  
            </props>  
        </property>  
    </bean>  
    <!-- 定義BeanNameAutoProxyCreatorf進行Spring的事務處理 -->  
    <bean  
        class="org.springframework.aop.framework.autoproxy.    
BeanNameAutoProxyCreator">  
        <!-- 針對指定的bean自動生成業務代理 -->  
        <property name="beanNames">  
            <list>  
                <value>adminService</value>  
                <value>columnsService</value>  
                <value>newsService</value>  
                <value>crawlService</value>  
                <value>memberLevelService</value>  
                <value>memberService</value>  
                <value>categoryService</value>  
                <value>merService</value>  
                <value>cartService</value>  
                <value>ordersService</value>  
                <value>trafficService</value>  
            </list>  
        </property>  
        <!-- 這個屬性爲true時，表示被代理的是目標類自己而不是目標類的接口 -->  
        <property name="proxyTargetClass">  
            <value>true</value>  
        </property>  
        <!-- 依賴注入上面定義的事務攔截器transactionInterceptor -->  
        <property name="interceptorNames">  
            <list>  
                <value>transactionInterceptor</value>  
            </list>  
        </property>  
    </bean>  
    <!-- 裝配通用數據庫訪問類BaseDAOImpl -->  
    <bean id="dao" class="com.eportal.DAO.BaseDAOImpl">  
        <property name="sessionFactory" ref="sessionFactory" />  
    </bean>  
    <!-- 部署系統用戶管理業務邏輯組件AdminServiceImpl -->  
    <bean id="adminService" class="com.eportal.service.AdminServiceImpl">  
        <property name="dao" ref="dao" />  
    </bean>  
    <!-- 部署新聞欄目管理業務邏輯組件ColumnsServiceImpl -->  
    <bean id="columnsService" class="com.eportal.service.ColumnsServiceImpl">  
        <property name="dao" ref="dao" />  
    </bean>  
      
    <!-- 部署訂單管理業務邏輯組件OrderServiceImpl -->  
    <bean id="ordersService" class="com.eportal.service.OrderServiceImpl">  
        <property name="dao" ref="dao" />  
    </bean>  
    <!-- 部署流量統計業務邏輯組件TrafficServiceImpl -->  
    <bean id="trafficService" class="com.eportal.service.TrafficServiceImpl">  
        <property name="dao" ref="dao" />  
    </bean>  
    <!-- 部署Struts 2負責系統用戶管理的控制器AdminAction -->  
    <bean id="adminAction" class="com.eportal.struts.action.  
AdminAction"  
        scope="prototype">  
        <property name="service" ref="adminService" />  
    </bean>  
    <!-- 部署Struts 2負責新聞欄目管理的控制器ColumnsAction -->  
    <bean id="columnsAction" class="com.eportal.struts.action.  
ColumnsAction"  
        scope="prototype">  
        <property name="service" ref="columnsService" />  
    </bean>  
    <!-- 部署Struts 2負責新聞管理的控制器NewsAction -->  
    <bean id="newsAction" class="com.eportal.struts.action.  
NewsAction"  
        scope="prototype">  
        <property name="service" ref="newsService" />  
        <property name="columnsService" ref="columnsService" />  
    </bean>  
    <!-- 部署Struts 2負責新聞採集規則管理的控制器CrawlAction -->  
    <bean id="crawlAction" class="com.eportal.struts.action.  
CrawlAction"  
        scope="prototype">  
        <property name="service" ref="crawlService" />  
        <property name="columnsService" ref="columnsService" />  
    </bean>  
      
</beans> 

　　spring-beans-3.2.xsd（只顯示一部分）

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- 註釋掉了property -->
<xsd:schema xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.springframework.org/schema/beans">

    <xsd:import namespace="http://www.w3.org/XML/1998/namespace"/>

    <xsd:annotation>
        <xsd:documentation><![CDATA[
    Spring XML Beans Schema, version 3.2
    Authors: Juergen Hoeller, Rob Harrop, Mark Fisher, Chris Beams

    This defines a simple and consistent way of creating a namespace
    of JavaBeans objects, managed by a Spring BeanFactory, read by
    XmlBeanDefinitionReader (with DefaultBeanDefinitionDocumentReader).

    This document type is used by most Spring functionality, including
    web application contexts, which are based on bean factories.

    Each "bean" element in this document defines a JavaBean.
    Typically the bean class is specified, along with JavaBean properties
    and/or constructor arguments.

    A bean instance can be a "singleton" (shared instance) or a "prototype"
    (independent instance). Further scopes can be provided by extended
    bean factories, for example in a web environment.

    References among beans are supported, that is, setting a JavaBean property
    or a constructor argument to refer to another bean in the same factory
    (or an ancestor factory).

    As alternative to bean references, "inner bean definitions" can be used.
    Singleton flags of such inner bean definitions are effectively ignored:
    inner beans are typically anonymous prototypes.

    There is also support for lists, sets, maps, and java.util.Properties
    as bean property types or constructor argument types.
        ]]></xsd:documentation>
    </xsd:annotation>

    <!-- base types -->
    <xsd:complexType name="identifiedType" abstract="true">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    The unique identifier for a bean. The scope of the identifier
    is the enclosing bean factory.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:attribute name="id" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    The unique identifier for a bean. A bean id may not be used more than once
    within the same <beans> element.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
    </xsd:complexType>

    <!-- Top-level <beans> tag -->
    <xsd:element name="beans">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    Container for <bean> and other elements, typically the root element in the document.
    Allows the definition of default values for all nested bean definitions. May itself
    be nested for the purpose of defining a subset of beans with certain default values or
    to be registered only when certain profile(s) are active. Any such nested <beans> element
    must be declared as the last element in the document.
            ]]></xsd:documentation>
        </xsd:annotation>
　　。。。。。。
　　。。。。。。
　　。。。。。。
　　。。。。。。
</xsd:schema>

　　包含了對xml文件的驗證和錯誤處理。驗證使用EntityResolver，錯誤處理使用ErrorHandler，和基本使用示例

　　下面說一下DOM方式生成XML：抄了一段別人的代碼：

package util;

import java.io.File;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
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.Document;
import org.w3c.dom.Element;

public class FileUtil {

    public void createXMLByDOM(File dest) {
        // 建立DocumentBuilderFactory
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        try {

            // 建立DocumentBuilder
            DocumentBuilder builder = factory.newDocumentBuilder();

            // 建立Document
            Document document = builder.newDocument();

            // 設置XML聲明中standalone爲yes，即沒有dtd和schema做爲該XML的說明文檔，且不顯示該屬性
            // document.setXmlStandalone(true);

            // 建立根節點
            Element bookstore = document.createElement("bookstore");

            // 建立子節點，並設置屬性
            Element book = document.createElement("book");
            book.setAttribute("id", "1");

            // 爲book添加子節點
            Element name = document.createElement("name");
            name.setTextContent("安徒生童話");
            book.appendChild(name);
            Element author = document.createElement("author");
            author.setTextContent("安徒生");
            book.appendChild(author);
            Element price = document.createElement("price");
            price.setTextContent("49");
            book.appendChild(price);

            // 爲根節點添加子節點
            bookstore.appendChild(book);

            // 將根節點添加到Document下
            document.appendChild(bookstore);

            /*
             * 下面開始實現： 生成XML文件
             */

            // 建立TransformerFactory對象
            TransformerFactory tff = TransformerFactory.newInstance();

            // 建立Transformer對象
            Transformer tf = tff.newTransformer();

            // 設置輸出數據時換行
            tf.setOutputProperty(OutputKeys.INDENT, "yes");

            // 使用Transformer的transform()方法將DOM樹轉換成XML
            tf.transform(new DOMSource(document), new StreamResult(dest));

        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (TransformerConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (TransformerException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

　　詳見下面的文章：Java——DOM方式生成XML

　　2. SAX (Simple API for XML)

　　SAX是基於事件的方法，它很相似於標籤庫的處理機制，在文檔開始、結束，標籤開始、結束以及錯誤發生等等地方調用相應的接口實現方法，不是所有文 檔都讀入內存。 SAX具備優異的性能和利用更少的存儲空間特色。SAX 的設計只考慮了功能的強大性，卻沒有考慮程序員使用起來是否方便。

　　必須擴展ContentHandler（或者DefaultHandler ）。

　　實例：

package sax;

import java.io.File;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

public class SaxDemo {
    public static void main(String[] args) throws Exception {
        String url = System.getProperty("user.dir");
        File xmlFile = new File(url + "/src/sax/article.xml");
        if(!xmlFile.exists())
        {
            System.out.println("file not found, return");
            return;
        }
        
        SAXParserFactory spf = SAXParserFactory.newInstance();
        // Specifies that the parser produced by this code will provide support for XML namespaces
        spf.setNamespaceAware(true);
        spf.setValidating(true);
        // http://blog.csdn.net/scmrpu/article/details/50423701
        spf.setFeature("http://xml.org/sax/features/validation", true);
        
        try
        {
            SAXParser sp = spf.newSAXParser();
            sp.parse(xmlFile, new MySaxHandler());
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    
    /**
     * SAXParserFactory spf = SAXParserFactory.newInstance();
     * SAXParser sp = spf.newSAXParser();
     * sp.parse(xmlFile, new MySaxHandler());
     * MySaxHandler
     * startElement
     * endElement
     * endDocument
     * startDocument
     * characters
     */
}

　　article.xml

<?xml version="1.0" encoding="UTF-8"?>
<a:articles xmlns:a="www.example.namespace/article">
<a:article category="java">
    <a:title>Java基本語法</a:title>
    <a:author>janet</a:author>
    <a:email>janetvsfei@yahoo.com.cn</a:email>
    <a:date>20080801</a:date>
</a:article>
<a:article category="xml">
    <a:title>XML概述</a:title>
    <a:author>janet</a:author>
    <a:email>janetvsfei@yahoo.com.cn</a:email>
    <a:date>20080801</a:date>
</a:article>
</a:articles>

　　MySaxHandler.java

package sax;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class MySaxHandler extends DefaultHandler {
    
    private String content;
    @Override
    public void startDocument() throws SAXException 
    {
    }
    
    @Override
    public void endDocument() throws SAXException 
    {
    }
    
    @Override
    /*
     *spf.setNamespaceAware(true): then uri and localName are not null; otherwise
     *they are null.
     */
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException 
    {
        if("a:article".equals(qName))
        {
            System.out.println("\r\n找到一篇文章，所屬分類： " + attributes.getValue("category") + ". ");
        }
    }
    
    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException 
    {
        if("a:title".equals(qName))
        {
            System.out.println("標題：" + content);
        }
        else if("a:author".equals(qName))
        {
            System.out.println("做者：" + content);
        }
        else if("a:email".equals(qName))
        {
            System.out.println("電子郵箱：" + content);
        }
        else if("a:date".equals(qName))
        {
            System.out.println("發表日期：" + content);
        }
    }
    
    @Override
    public void characters(char[] ch, int start, int length) throws SAXException 
    {
        content = new String(ch, start, length);
    }
}

　　下面是SAX生成XML，抄了別人一段代碼：

package util;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl;

import domain.Book;

public class XMLUtil {

    private List<Book> bookList;

    //生成XML文件
    public void createXMLBySAX(List<Book> books, File dest) {
        // 建立SAXTransformerFactory對象
        SAXTransformerFactory factory = (SAXTransformerFactory) SAXTransformerFactory.newInstance();
        try {
            // 經過SAXTransformerFactory對象建立TransformerHandler對象
            TransformerHandler handler = factory.newTransformerHandler();
            // 經過Handler建立Transformer對象
            Transformer transformer = handler.getTransformer();
            // 設置Transformer的屬性
            transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            // 建立Result對象，並將目的XML文件與其關聯
            Result result = new StreamResult(dest);
            // 將handler與result關聯起來
            handler.setResult(result);

            try {
                // 開啓文檔
                handler.startDocument();
                // 新建節點
                handler.startElement("", "", "bookstore", null);
                AttributesImpl atts = new AttributesImpl();
                for (Book book : books) {
                    atts.clear();
                    atts.addAttribute("", "", "id", "", String.valueOf(book.getId()));
                    handler.startElement("", "", "book", atts);
                    handler.startElement("", "", "name", null);
                    handler.characters(book.getName().toCharArray(), 0, book.getName().length());
                    handler.endElement("", "", "name");
                    handler.startElement("", "", "author", null);
                    handler.characters(book.getAuthor().toCharArray(), 0, book.getAuthor().length());
                    handler.endElement("", "", "author");
                    handler.startElement("", "", "price", null);
                    handler.characters(Float.toString(book.getPrice()).toCharArray(), 0,
                            Float.toString(book.getPrice()).length());
                    handler.endElement("", "", "price");
                    handler.endElement("", "", "book");
                }
                // 關閉節點
                handler.endElement("", "", "bookstore");
                // 關閉文檔
                handler.endDocument();
            } catch (SAXException e) {
                e.printStackTrace();
            }

        } catch (TransformerConfigurationException e) {
            e.printStackTrace();
        }
    }

    //解析XML文件
    public List<Book> parseXMLBySAX(File file) {
        SAXParser parser = getParser();
        MyHandler handler = new MyHandler();
        try {
            parser.parse(file, handler);
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        bookList = handler.getBookList();

        return bookList;
    }

    public SAXParser getParser() {
        SAXParserFactory factory = SAXParserFactory.newInstance();
        SAXParser parser = null;
        try {
            parser = factory.newSAXParser();
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        }
        return parser;
    }

    public List<Book> getBookList() {
        return bookList;
    }

    public void setBookList(List<Book> bookList) {
        this.bookList = bookList;
    }

}

　　詳見下面的文章：Java——SAX方式生成XML

　　3. JAXB（Java Architecture for XML Binding)

　　JAXB（Java Architecture for XML Binding) 是一個業界的標準，是一項能夠根據XML Schema產生Java類的技術。該過程當中，JAXB也提供了將XML實例文檔反向生成Java對象樹的方法，並能將Java對象樹的內容從新寫到XML實例文檔。從另外一方面來說，JAXB提供了快速而簡便的方法將XML模式綁定到Java表示，從而使得Java開發者在Java應用程序中能方便地結合XML數據和處理函數。

　　實例：

　　基本的java bean的處理

package jaxb;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.StringWriter;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

public class JAXBDemo {
    public static void main(String[] args) {
        String url = System.getProperty("user.dir");
        File xmlFile = new File(url + "/src/jaxb/article.xml");
        if(xmlFile.exists())
        {
            xmlFile.delete();
        }
        
        JAXBContext jaxbContext;
        BufferedWriter bw = null;
        
        try
        {
            jaxbContext = JAXBContext.newInstance(Article.class);
            // marshal
            Marshaller m = jaxbContext.createMarshaller();
            m.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");// 設置編碼
            m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);// 格式化輸出
            
            Article article = new Article();
            article.setAuthor("Janet");
            article.setDate("20080801");
            article.setEmail("janetvsfei@yhoo.com.cn");
            article.setTitle("XML");
            
            StringWriter sw = new StringWriter();
            xmlFile.createNewFile();
            
            // 生成xml
            m.marshal(article, sw);
            
            bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(xmlFile)));
            bw.write(sw.toString().replace(" standalone=\"yes\"", ""));// 去掉standalone屬性
            if(null != bw)
            {
                bw.close();
            }
            
            // unmarshal
            Unmarshaller u = jaxbContext.createUnmarshaller();
            
            // 從xml生成java對象
            Article article2 = (Article) u.unmarshal(xmlFile);
            System.out.println(article2);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    
    /**
     * JAXBContext jaxbContext = JAXBContext.newInstance(Article.class);
     * Marshaller m = jaxbContext.createMarshaller();
     * m.marshal(article, sw);
     * 
     * Unmarshaller u = jaxbContext.createUnmarshaller();
     * Article article2 = (Article) u.unmarshal(xmlFile);
     */
}

　article.xml

<?xml version="1.0" encoding="UTF-8"?>
<article>
    <author>Janet</author>
    <date>20080801</date>
    <email>janetvsfei@yahoo.com.cn</email>
    <title>XML</title>
</article>

　　列表的處理

package jaxb;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Unmarshaller;
import javax.xml.bind.annotation.XmlRootElement;

// root name
@XmlRootElement(name="articles")
public class ArticleData {
    // named root's first level children list name
    private List<Article> article = new ArrayList<Article>();
    
    public List<Article> getArticle() {
        return article;
    }
    public void setArticle(List<Article> article) {
        this.article = article;
    }
    public static void main(String[] args) {
        String url = System.getProperty("user.dir");
        File xmlFile = new File(url + "/src/jaxb/article2.xml");
        JAXBContext jaxbContext;
        try
        {
            jaxbContext = JAXBContext.newInstance(ArticleData.class);
            Unmarshaller u = jaxbContext.createUnmarshaller();
            ArticleData articleData = (ArticleData) u.unmarshal(xmlFile);
            
            System.out.println(articleData.getArticle().get(0));
            System.out.println(articleData.getArticle().get(1));
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }

}

　　article2.xml

<?xml version="1.0" encoding="UTF-8"?>
<articles>
<article category="java">
    <title>Java基本語法</title>
    <author>janet</author>
    <email>janetvsfei@yahoo.com.cn</email>
    <date>20080801</date>
</article>
<article category="xml">
    <title>XML概述</title>
    <author>janet</author>
    <email>janetvsfei@yahoo.com.cn</email>
    <date>20080801</date>
</article>
</articles>

　　Article.java

package jaxb;

import javax.xml.bind.annotation.XmlRootElement;
// 使用註解
@XmlRootElement
public class Article {
    private String title;
    private String author;
    private String email;
    private String date;
    
    @Override
    public String toString() {
        return "Article [title=" + title + ", author=" + author + ", email=" + email + ", date=" + date + "]";
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public String getDate() {
        return date;
    }
    public void setDate(String date) {
        this.date = date;
    }
}

　　詳細內容能夠看下面的文章：JAXB應用實例

　　除了抄別人的代碼，剩下的都是本身學習過程的代碼，對dom，說了解析xml，設置錯誤處理器和校驗，還說了生成xml（抄別人的代碼）；對sax，說了生成（抄別人的代碼）與解析xml；對JAXB，說了生成與解析XML，還說了字段爲列表的狀況，其它內容能夠看我提供的文章，有關於jaxb更高級一些的內容，如適配器，工具類，更多註解，數據修改，對集合與對象字段的處理，本身學習的很淺顯，看別人的文章才能看出問題，只當是作個大體的瞭解，做爲入門的參考吧。