Ⅰ java XML解析詳解
(I)Java通過DOM解析XML
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").getNodeValue();
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.getNodeValue();
String name1=node.getFirstChild().getNodeValue();
...
if(node.getNodeName().equals("price")){
String price=node.getFirstChild().getNodeValue();
...
Java通過SAX解析XML
Simple API for XML（簡稱SAX）是個循序存取XML的解析器API。
一個實現SAX的解析器（也就是「SAX Parser」）以一個串流解析器的型式作用，擁有事件驅動API。由使用者定義回調函數，解析時，若發生事件的話會被調用。SAX事件包括：
XML 文字 節點
XML 元素 節點
XML 處理指令
XML 注釋
Java代碼
<person>
<user>
<username>謝成志</username>
<password>6626310xie</password>
<sex>男</sex>
<birthday>1988/11/28</birthday>
<headpic>
<pictitle>ermao</pictitle>
<picurl>images/head1.jpg</picurl>
</headpic>
</user>
</person>
此為下面即將解析度簡單xml結構，並將其封裝成一個User對象。
////////////////////////////////////////////////////////////////////////////////////
Java代碼
<span style="font-family: courier new,courier; font-size: small;">package com.xcz.xml;
import java.io.File;
import java.io.IOException;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.SAXException;
import com.xcz.util.SaxUtil;
public class Sax4XML {
public static void main(String[] args) {
try {
//1.獲取factory
SAXParserFactory factory = SAXParserFactory.newInstance();
//2.獲取parser
SAXParser parser = factory.newSAXParser();
//3.獲取解析時的監聽器對象
SaxUtil su = new SaxUtil();
//4.開始解析
parser.parse(new File("src/user-params.xml"), su);
System.out.println(su.getUser());
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
</span>
////////////////////////////////////////////////////////////////////////////////////
Java代碼
<span style="font-family: courier new,courier; font-size: small;">package com.xcz.util;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import com.xcz.po.HeadPic;
import com.xcz.po.User;
/**
* 定義xml解析時的監聽類
*
* 實現方式有很多，可以實現介面：ContentHandler，DTDHandler， EntityResolver 和 ErrorHandler
* 但我們常用的繼承：DefaultHandler
*/
public class SaxUtil extends DefaultHandler {
private User user;
private HeadPic headPic;
private String content;
private SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
@Override
public void characters(char[] ch, int start, int length)
throws SAXException {
content = new String(ch, start, length);
}
//當解析到文本開始時觸發
@Override
public void startDocument() throws SAXException {
super.startDocument();
}
//當解析到文本結束時觸發
@Override
public void endDocument() throws SAXException {
super.endDocument();
}
//當解析到元素開始時觸發
@Override
public void startElement(String uri, String localName, String name,
Attributes attributes) throws SAXException
{
if("user".equals(name))
{
user = new User();
}
if("headpic".equals(name))
{
headPic = new HeadPic();
}
}
//當解析到元素結束時觸發
@Override
public void endElement(String uri, String localName, String name)
throws SAXException
{
if("username".equals(name))
{
user.setUsername(content);
}
if("password".equals(name))
{
user.setPassword(content);
}
if("sex".equals(name))
{
user.setSex(content);
}
if("birthday".equals(name))
{
try {
user.setBirthday(sdf.parse(content));
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if("pictitle".equals(name))
{
headPic.setPicTitle(content);
}
if("picurl".equals(name))
{
headPic.setPicUrl(content);
user.setHeadPic(headPic);
}
}
public User getUser(){
return user;
}
}</span>
[優點]
(1).節約內存開銷
SAX解析器在某些方面優於DOM風格解析器，因為SAX解析器的內存使用量一般遠低於DOM解析器使用量。DOM解析器在任何處理開始之前，必須將xml以整棵樹放在內存，所以DOM解析器的內存使用量完全根據輸入資料的大小。相對來說，SAX解析器的內存內容，是只基於XML檔案的最大深度（XML樹的最大深度）和單一XML項目上XML屬性儲存的最大資料。
(2)解析速度快
因為SAX事件驅動的本質，處理文件通常會比DOM風格的解析器快。
[缺點]
SAX事件驅動的模型對於XML解析很有用，但它確實有某些缺點。
某些種類的XML驗證需要存取整份文件。例如，一個DTD IDREF屬性需要文件內有項目使用指定字串當成DTD ID屬性。要在SAX解析器內驗證，必須追蹤每個之前遇過的ID和IDREF屬性，檢查是否有任何相符。更甚者，一個IDREF找不到對應的ID，使用者只會在整份文件都解析完後才發現，若這種連結對於建立有效輸出是重要的，那用在處理整份文件的時間只是浪費。
Ⅱ java中dom4j解析xml文件怎麼獲取節點屬性
dom4j中，使用Element.attributes方法可以獲取到節點的屬性，而使用elements則可以獲取相應的子節點
比如：
Element root = doc.getRootElement();
List attrList = root.attributes();
for (int i = 0; i < attrList.size(); i++) {
//屬性的取得
Attribute item = (Attribute)attrList.get(i);
System.out.println(item.getName() + "=" + item.getValue());
}
List childList = root.elements();
for (int i = 0; i < childList.size(); i++) {
//子節點的操作
Element it = (Element) childList.get(i);
//對子節點進行其它操作...
}
Ⅲ 目前在Java中幾種常用的XML解析器的比較
目前常用的XML的解析器主要有:SAX,DOM,Xerces
1、SAX處理的優點非常類似於流媒體的優點。分析能夠立即開始，而不是等待所有的數據被處理。而且，由於應用程序只是在讀取數據時檢查數據，因此不需要將數據存儲在內存中。這對於大型文檔來說是個巨大的優點。事實上，應用程序甚至不必解析整個文檔；它可以在某個條件得到滿足時停止解析。一般來說，SAX還比它的替代者DOM快許多。另一方面，由於應用程序沒有以任何方式存儲數據，使用SAX來更改數據或在數據流中往後移是不可能的。
2、DOM以及廣義的基於樹的處理具有幾個優點。首先，由於樹在內存中是持久的，因此可以修改它以便應用程序能對數據和結構作出更改。它還可以在任何時候在樹中上下導航，而不是像SAX那樣是一次性的處理。DOM使用起來也要簡單得多。另一方面，在內存中構造這樣的樹涉及大量的開銷。大型文件完全佔用系統內存容量的情況並不鮮見。此外，創建一棵DOM樹可能是一個緩慢的過程。
3、選擇DOM還是選擇SAX，這取決於下面幾個因素:
應用程序的目的：如果打算對數據作出更改並將它輸出為XML，那麼在大多數情況下，DOM是適當的選擇。並不是說使用SAX就不能更改數據，但是該過程要復雜得多，因為您必須對數據的一份拷貝而不是對數據本身作出更改。
數據容量：對於大型文件，SAX是更好的選擇。數據將如何使用：如果只有數據中的少量部分會被使用，那麼使用SAX來將該部分數據提取到應用程序中可能更好。另一方面，如果您知道自己以後會回頭引用已處理過的大量信息，那麼SAX也許不是恰當的選擇。
對速度的需要：SAX實現通常要比DOM實現更快。
SAX和DOM不是相互排斥的，記住這點很重要。您可以使用DOM來創建SAX事件流，也可以使用SAX來創建DOM樹。事實上，用於創建DOM樹的大多數解析器實際上都使用SAX來完成這個任務！
4、SAX,DOM是兩種對XML文檔進行分析的方法（沒有具體的實現，只有介面），所以不是解釋器，如果光有他們，你是完成不了對xml文檔的處理的。SAX的包是org.xml.sax，DOM的包是org.w3c.dom，包的名稱很重要，它有助於你理解他們之間的關系。
5、jaxp是api，他封裝了sax/dom兩種介面。並在sax/dom的基礎之上，作了一套比較簡單的api以供開發人員使用。jaxp的包是javax.xml.parsers，可以看看jaxp的源文件，它的文件中包含了對sax或者dom的引用（import）jaxp也不是具體的實現，他只是一套api。如果你僅僅有jaxp那是無法工作的，（其實jaxp只是完成對sax、dom的包裝，生成了DocumentBuilderFactory/DocumentBuilder和SAXParserFactorySAXParser。也就是設計模式中的工廠模式，他的好處就是具體的對象（解釋器）建立由子類完成）
6、xerces解釋器（號稱地球上最快的xml解釋器）在xerces中對jaxp中定義的進行了繼承（extends）對應ryImpl這就是為什麼你的classpath中只要有xerces.jar（其中包含了saxdomjaxp）和xercesImpl.jar就可以的原因了.
Ⅳ 在java中解析xml有哪幾種方法
(1)DOM解析
DOM是html和xml的應用程序介面(API)，以層次結構（類似於樹型）來組織節點和信息片段，映射XML文檔的結構，允許獲取
和操作文檔的任意部分，是W3C的官方標准
【優點】
①允許應用程序對數據和結構做出更改。
②訪問是雙向的，可以在任何時候在樹中上下導航，獲取和操作任意部分的數據。
【缺點】
①通常需要載入整個XML文檔來構造層次結構，消耗資源大。
【解析詳解】
①構建Document對象：
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = bdf.newDocumentBuilder();
InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(xml文件);
Document doc = bd.parse(is);
②遍歷DOM對象
Document： XML文檔對象，由解析器獲取
NodeList： 節點數組
Node： 節點(包括element、#text)
Element： 元素，可用於獲取屬性參數
(2)SAX(Simple API for XML)解析
流模型中的"推"模型分析方式。通過事件驅動，每發現一個節點就引發一個事件，事件推給事件處理器，通過回調方法
完成解析工作，解析XML文檔的邏輯需要應用程序完成
【優勢】
①不需要等待所有數據都被處理，分析就能立即開始。
②只在讀取數據時檢查數據，不需要保存在內存中。
③可以在某個條件得到滿足時停止解析，不必解析整個文檔。
④效率和性能較高，能解析大於系統內存的文檔。
【缺點】
①需要應用程序自己負責TAG的處理邏輯（例如維護父/子關系等），文檔越復雜程序就越復雜。
②單向導航，無法定位文檔層次，很難同時訪問同一文檔的不同部分數據，不支持XPath。
【原理】
簡單的說就是對文檔進行順序掃描，當掃描到文檔(document)開始與結束、元素(element)開始與結束時通知事件
處理函數(回調函數)，進行相應處理，直到文檔結束
【事件處理器類型】
①訪問XML DTD：DTDHandler
②低級訪問解析錯誤：ErrorHandler
③訪問文檔內容：ContextHandler
【DefaultHandler類】
SAX事件處理程序的默認基類，實現了DTDHandler、ErrorHandler、ContextHandler和EntityResolver介面，通常
做法是，繼承該基類，重寫需要的方法，如startDocument()
【創建SAX解析器】
SAXParserFactory saxf = SAXParserFactory.newInstance();
SAXParser sax = saxf.newSAXParser();
註：關於遍歷
①深度優先遍歷(Depthi-First Traserval)
②廣度優先遍歷(Width-First Traserval)
(3)JDOM(Java-based Document Object Model)
Java特定的文檔對象模型。自身不包含解析器，使用SAX
【優點】
①使用具體類而不是介面，簡化了DOM的API。
②大量使用了Java集合類，方便了Java開發人員。
【缺點】
①沒有較好的靈活性。
②性能較差。
(4)DOM4J(Document Object Model for Java)
簡單易用，採用Java集合框架，並完全支持DOM、SAX和JAXP
【優點】
①大量使用了Java集合類，方便Java開發人員，同時提供一些提高性能的替代方法。
②支持XPath。
③有很好的性能。
【缺點】
①大量使用了介面，API較為復雜。
(5)StAX(Streaming API for XML)
流模型中的拉模型分析方式。提供基於指針和基於迭代器兩種方式的支持,JDK1.6新特性
【和推式解析相比的優點】
①在拉式解析中，事件是由解析應用產生的，因此拉式解析中向客戶端提供的是解析規則，而不是解析器。
②同推式解析相比，拉式解析的代碼更簡單，而且不用那麼多庫。
③拉式解析客戶端能夠一次讀取多個XML文件。
④拉式解析允許你過濾XML文件和跳過解析事件。
【簡介】
StAX API的實現是使用了Java Web服務開發（JWSDP）1.6，並結合了Sun Java流式XML分析器(SJSXP)-它位於
javax.xml.stream包中。XMLStreamReader介面用於分析一個XML文檔，而XMLStreamWriter介面用於生成一個
XML文檔。XMLEventReader負責使用一個對象事件迭代子分析XML事件-這與XMLStreamReader所使用的游標機制
形成對照。
Ⅳ java解析xml文件的用到哪些包
利用以下工具都可以實現對xml 文件的解析 ，dom4j, jdom, SAX,DOM
如果是在java程序中解析xml文件，主要使用dom4j和jdom，dom4j用的比較多，諸多MVC框架及orm框架都是使用dom4j來解析xml文件的。
dom 方式則和語言無關的xml文件操作的國際標准。
Ⅵ Java解析XML
jdom 解析
public static ArrayList<HashMap<String, String>> parseXML(String xml){
ArrayList<HashMap<String, String>> results = new ArrayList<HashMap<String, String>> ();
StringReader read = new StringReader(xml);
InputSource source = new InputSource(read);
SAXBuilder sb = new SAXBuilder();
HashMap<String, String> result =null;
try {
Document doc = sb.build(source);
Element root = doc.getRootElement();
List<Element> firstNode = root.getChildren();;
for(int firstLevelElement = 0;firstLevelElement<firstNode.size();firstLevelElement++){
List<Element> secondNode = firstNode.get(firstLevelElement).getChildren();
System.out.println(secondNode.size());
for(int secondLevelElement = 0;secondLevelElement<secondNode.size();secondLevelElement++){
List<Element> thirdNode = secondNode.get(secondLevelElement).getChildren();
result = new HashMap<String, String>();
for(int thirdLevelElement = 0;thirdLevelElement<thirdNode.size();thirdLevelElement++){
result.put(thirdNode.get(thirdLevelElement).getName(), thirdNode.get(thirdLevelElement).getText());
}
if(result.size()>0){
results.add(result);
}
}
}
} catch (JDOMException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return results;
}
Ⅶ java dom4j解析一個xml文件怎麼解析
步驟:
1. 引入jar文件(dom4j.jar)
2. 創建指向XML文檔的輸入流.
InputStream is = new FileInputStream("文件地址");
3. 創建一個XML讀取工具對象
SAXReader sr = new SAXReader();
4. 通過讀取工具, 讀取xml文檔的輸入流. 並得到文檔對象
Document doc = sr.read(is);
5. 通過文檔對象, 獲取XML文檔的根節點對象
Element root = doc.getRootElement();
Ⅷ 在Java中如何讀取XML字元串的元素值
java讀取xml節點元素，主要使用java提供的解析xml的工具類SAXParserFactory，如下代碼：
package xml.xmlreader;import java.io.File;import java.net.URL;import java.util.Properties;import javax.xml.parsers.SAXParser;import javax.xml.parsers.SAXParserFactory;public class CFGParser {//解析xml文件的工具類 private Properties props; public Properties getProps() { return props; } public void setProps(Properties props) { this.props = props; } public void parse(String filename) throws Exception { CFGHandler handler = new CFGHandler(); SAXParserFactory factory = SAXParserFactory.newInstance(); factory.setNamespaceAware(false); factory.setValidating(false); SAXParser parser = factory.newSAXParser(); URL confURL = super.getClass().getClassLoader().getResource(filename); if (confURL == null) { System.out.println("Can't find configration file."); return; } try { parser.parse(confURL.toString(), handler); this.props = handler.getProps(); } finally { factory = null; parser = null; handler = null; } } public void parseFile(String filename) throws Exception { CFGHandler handler = new CFGHandler(); SAXParserFactory factory = SAXParserFactory.newInstance(); factory.setNamespaceAware(false); factory.setValidating(false); SAXParser parser = factory.newSAXParser(); File f = new File(filename); if ((f == null) || (!f.exists())) return; try { parser.parse(f, handler); this.props = handler.getProps(); } finally { factory = null; parser = null; handler = null; } }}package xml.xmlreader;import java.util.Properties;import org.xml.sax.Attributes;import org.xml.sax.SAXException;import org.xml.sax.helpers.DefaultHandler; public class CFGHandler extends DefaultHandler{ private Properties props; private String currentSet; private String currentName; private StringBuffer currentValue = new StringBuffer(); public CFGHandler() { this.props = new Properties(); } public Properties getProps() { return this.props; } public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { this.currentValue.delete(0, this.currentValue.length()); this.currentName = qName; } public void characters(char[] ch, int start, int length) throws SAXException { this.currentValue.append(ch, start, length); } public void endElement(String uri, String localName, String qName) throws SAXException { this.props.put(qName.toLowerCase(), this.currentValue.toString().trim()); }}xml文件 <?xml version="1.0" encoding="UTF-8"?><xml-body> <refresh_userlist desc="用戶列表刷新間隔時間(秒)">6</refresh_userlist> <refresh_message desc="短消息刷新間隔時間(秒)">10</refresh_message> <morningbegin desc="上午上班時間">23:00</morningbegin> <morningend desc="上午下班時間">12:00</morningend> <afternoonbegin desc="下午上班時間">18:00</afternoonbegin></xml-body>jsp獲取各個節點的值：<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%><html> <jsp:useBean id="cfgp" scope="page" class="xml.xmlreader.CFGParser"></jsp:useBean> <body> <% cfgp.parse("kaoqin.xml"); Properties pro = cfgp.getProps(); String stTime = pro.getProperty("morningbegin"); String edTime = pro.getProperty("morningend"); String afternoonbegin = pro.getProperty("afternoonbegin"); out.println(stTime+"\n"+edTime+"\n"+afternoonbegin); System.out.println(stTime+"\n"+edTime+"\n"+afternoonbegin); %> </body></html>
Ⅸ java如何讀取xml節點元素值
java讀取xml節點元素，主要使用java提供的解析xml的工具類SAXParserFactory，如下代碼：
packagexml.xmlreader;
importjava.io.File;
importjava.net.URL;
importjava.util.Properties;
importjavax.xml.parsers.SAXParser;
importjavax.xml.parsers.SAXParserFactory;
publicclassCFGParser{//解析xml文件的工具類
privatePropertiesprops;
publicPropertiesgetProps(){
returnprops;
}
publicvoidsetProps(Propertiesprops){
this.props=props;
}
publicvoidparse(Stringfilename)throwsException
{
CFGHandlerhandler=newCFGHandler();
SAXParserFactoryfactory=SAXParserFactory.newInstance();
factory.setNamespaceAware(false);
factory.setValidating(false);
SAXParserparser=factory.newSAXParser();
URLconfURL=super.getClass().getClassLoader().getResource(filename);
if(confURL==null){
System.out.println("Can'tfindconfigrationfile.");
return;
}
try
{
parser.parse(confURL.toString(),handler);
this.props=handler.getProps();
}
finally{
factory=null;
parser=null;
handler=null;
}
}
publicvoidparseFile(Stringfilename)
throwsException
{
CFGHandlerhandler=newCFGHandler();
SAXParserFactoryfactory=SAXParserFactory.newInstance();
factory.setNamespaceAware(false);
factory.setValidating(false);
SAXParserparser=factory.newSAXParser();
Filef=newFile(filename);
if((f==null)||(!f.exists()))
return;
try
{
parser.parse(f,handler);
this.props=handler.getProps();
}
finally{
factory=null;
parser=null;
handler=null;
}
}
}
packagexml.xmlreader;
importjava.util.Properties;
importorg.xml.sax.Attributes;
importorg.xml.sax.SAXException;
importorg.xml.sax.helpers.DefaultHandler;
{
privatePropertiesprops;
privateStringcurrentSet;
privateStringcurrentName;
=newStringBuffer();
publicCFGHandler()
{
this.props=newProperties();
}
publicPropertiesgetProps(){
returnthis.props;
}
publicvoidstartElement(Stringuri,StringlocalName,StringqName,Attributesattributes)
throwsSAXException
{
this.currentValue.delete(0,this.currentValue.length());
this.currentName=qName;
}
publicvoidcharacters(char[]ch,intstart,intlength)throwsSAXException
{
this.currentValue.append(ch,start,length);
}
publicvoidendElement(Stringuri,StringlocalName,StringqName)
throwsSAXException
{
this.props.put(qName.toLowerCase(),this.currentValue.toString().trim());
}
}
xml文件
<?xmlversion="1.0"encoding="UTF-8"?>
<xml-body>
<refresh_userlistdesc="用戶列表刷新間隔時間(秒)">6</refresh_userlist>
<refresh_messagedesc="短消息刷新間隔時間(秒)">10</refresh_message>
<morningbegindesc="上午上班時間">23:00</morningbegin>
<morningenddesc="上午下班時間">12:00</morningend>
<afternoonbegindesc="下午上班時間">18:00</afternoonbegin>
</xml-body>
jsp獲取各個節點的值：
<%@pagelanguage="java"import="java.util.*"pageEncoding="UTF-8"%>
<html>
<jsp:useBeanid="cfgp"scope="page"class="xml.xmlreader.CFGParser"></jsp:useBean>
<body>
<%
cfgp.parse("kaoqin.xml");
Propertiespro=cfgp.getProps();
StringstTime=pro.getProperty("morningbegin");
StringedTime=pro.getProperty("morningend");
Stringafternoonbegin=pro.getProperty("afternoonbegin");
out.println(stTime+" "+edTime+" "+afternoonbegin);
System.out.println(stTime+" "+edTime+" "+afternoonbegin);
%>
</body>
</html>
Ⅹ java 怎麼解析xml數據包數據 將xml各節點下的數據取出來
xml解析方法可以說有4種工具；
jdom，dom，sax，一般比較好懂的就是jdom，你網路jdom就有很多，網路文庫也可以