「java怎么解析xml」java怎么解析xml循环节点

博主：adminadmin 2023-03-19 02:00:09 428

今天给各位分享java怎么解析xml的知识，其中也会对java怎么解析xml循环节点进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

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;ibooks.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

password6626310xie/password

sex男/sex

birthday1988/11/28/birthday

headpic

pictitleermao/pictitle

picurlimages/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怎么解析xml文件？

String xml="xmlToUserName![CDATA[toUser]]/ToUserName"

+"FromUserName![CDATA[fromUser]]/FromUserName"

+"CreateTime12345678/CreateTime"

+"MsgType![CDATA[text]]/MsgType"

+"Content![CDATA[你好]]/Content/xml";

try {

//加载xml字符串

org.dom4j.Document document=org.dom4j.DocumentHelper.parseText(xml);

//获取根节点

org.dom4j.Element root=document.getRootElement();

//获取值  ==toUser

String toUserName=root.elementText("ToUserName");

System.out.println(toUserName);

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

在java在如何解析XML文件

在java环境下读取xml文件的方法主要有4种：DOM、SAX、JDOM、JAXB

1. DOM(Document Object Model)

此方法主要由W3C提供，它将xml文件全部读入内存中，然后将各个元素组成一棵数据树，以便快速的访问各个节点 。 因此非常消耗系统性能 ，对比较大的文档不适宜采用DOM方法来解析。 DOM API 直接沿袭了 XML 规范。每个结点都可以扩展的基于 Node 的接口，就多态性的观点来讲，它是优秀的，但是在 Java 语言中的应用不方便，并且可读性不强。

实例：

import javax.xml.parsers.*;

//XML解析器接口

import org.w3c.dom.*;

//XML的DOM实现

import org.apache.crimson.tree.XmlDocument;

//写XML文件要用到

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

//允许名字空间

factory.setNamespaceAware(true);

//允许验证

factory.setValidating(true);

//获得DocumentBuilder的一个实例

try {

DocumentBuilder builder = factory.newDocumentBuilder();

} catch (ParserConfigurationException pce) {

System.err.println(pce);

// 出异常时输出异常信息，然后退出，下同

System.exit(1);

}

//解析文档，并获得一个Document实例。

try {

Document doc = builder.parse(fileURI);

} catch (DOMException dom) {

System.err.println(dom.getMessage());

System.exit(1);

} catch (IOException ioe) {

System.err.println(ioe);

System.exit(1);

}

//获得根节点StuInfo

Element elmtStuInfo = doc.getDocumentElement();

//得到所有student节点

NodeList nlStudent = elmtStuInfo.getElementsByTagNameNS(

strNamespace, "student");

for (……){

//当前student节点元素

Element elmtStudent = (Element)nlStudent.item(i);

NodeList nlCurrent = elmtStudent.getElementsByTagNameNS(

strNamespace, "name");

}

java的xml的解析方式有什么，他们的解析流程是怎么样的，有什么区别

答：4种。（或者说是两种，因为JDOM和DOM4J是DOM的两个特殊情况）

1.SAX解析

解析方式是事件驱动机制！

SAX解析器，逐行读取XML文件解析，每当解析到一个标签的开始/结束/内容/属性时，触发事件。

可以在这些事件发生时，编写程序进行相应的处理。

优点：

分析能够立即开始，而不是等待所有的数据被处理。

逐行加载，节省内存，有助于解析大于系统内存的文档。

有时不必解析整个文档，它可以在某个条件得到满足时停止解析。

缺点：

1.单向解析，无法定位文档层次，无法同时访问同一个文档的不同部分数据（因为逐行解析，当解析第n行时，第n-1行）已经被释放了，无法再对其进行操作）。

2. 无法得知事件发生时元素的层次, 只能自己维护节点的父/子关系。

3. 只读解析方式, 无法修改XML文档的内容。

2. DOM解析

是用与平台和语言无关的方式表示XML文档的官方W3C标准，分析该结构通常需要加载整个 文档和内存中建立文档树模型。程序员可以通过操作文档树, 来完成数据的获取 修改 删除等。

优点:

文档在内存中加载, 允许对数据和结构做出更改。访问是双向的，可以在任何时候在树中双向解析数据。

缺点:

文档全部加载在内存中 , 消耗资源大。

3. JDOM解析

目的是成为Java特定文档模型，它简化与XML的交互并且比使用DOM实现更快。由于是第一 个Java特定模型，JDOM一直得到大力推广和促进。

JDOM文档声明其目的是“使用20%（或更少）的精力解决80%（或更多）Java/XML问题” （根据学习曲线假定为20%）

优点:

使用具体类而不是接口，简化了DOM的API。

大量使用了Java集合类，方便了Java开发人员。

缺点:

没有较好的灵活性。

性能不是那么优异。

4. DOM4J解析

它是JDOM的一种智能分支。它合并了许多超出基本XML文档表示的功能，包括集成的XPath 支持、XML Schema支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项， DOM4J是一个非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一 个开放源代码的软件。如今你可以看到越来越多的Java软件都在使用DOM4J来读写XML。

目前许多开源项目中大量采用DOM4J , 例如:Hibernate。

在java中解析xml有哪几种方法

1、JDOM生成和解析XML

为减少DOM、SAX的编码量,出现了JDOM

优点:20-80原则,极大减少了代码量。

使用场合:要实现的功能简单,如解析、创建等,但在底层,JDOM还是使用SAX(最常用)、DOM、Xanan文档。

2、SAX生成和解析XML文档

为解决DOM的问题,出现了SAX,SAX 事件驱动。当解析器发现元素开始、元素结束、文本、文档的开始或结束等时发送事件,程序员编写响应这些事件的代码,保存数据。

优点:不用事先调入整个文档,占用资源少。SAX解析器代码比DOM解析器代码小,适于Applet下载。

缺点:不是持久的,事件过后若没保存数据,那么数据就丢了。无状态性,从事件中只能得到文本,但不知该文本属于哪个元素。

使用场合:Applet。只需XML文档的少量内容,很少回头访问,机器内存少。

3、DOM生成和解析XML文档

为XML文档的已解析版本定义了一组接口。解析器读入整个文档,然后构建一个驻留内存的树结构,然后代码就可以使用 DOM 接口来操作这个树结构。

优点:整个文档树在内存中,便于操作,支持删除、修改、重新排列等多种功能。

缺点:将整个文档调入内存(包括无用的节点),浪费时间和空间。

使用场合:一旦解析了文档还需多次访问这些数据,硬件资源充足(内存、CPU)。

4、DOM4J生成和解析XML文档

DOM4J

是一个非常非常优秀的Java XML

API,具有性能优异、功能强大和极端易用使用的特点,同时它也是一个开放源代码的软件。如今你可以看到越来越多的 Java 软件都在使用 DOM4J

来读写 XML,特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J。

java解析xml有几种方法

DOM（Document Object Model）解析

优点

允许应用程序对数据和结构做出更改

访问是双向的，可以在任何时候在树中上、下导航获取、操作任意部分的数据

缺点

解析XML文档的需要加载整个文档来构造层次结构，消耗内存资源大。

应用范围

遍历能力强，常应用于XML文档需要频繁改变的服务中。

解析步骤

创建一个 DocumentBuilderFactory 对象

创建一个 DocumentBuilder 对象

通过 DocumentBuilder 的 parse() 方法加载 XML 到当前工程目录下

通过 getElementsByTagName() 方法获取所有 XML 所有节点的集合

遍历所有节点

通过 item() 方法获取某个节点的属性

通过 getNodeName() 和 getNodeValue() 方法获取属性名和属性值

通过 getChildNodes() 方法获取子节点，并遍历所有子节点

通过 getNodeName() 和 getTextContent() 方法获取子节点名称和子节点值

package Paint;

import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.xml.sax.SAXException;

public class DOMTest {

public static void main(String[] args) {

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

try {

DocumentBuilder db = dbf.newDocumentBuilder();

Document document = db.parse("./src/Paint/hello.xml");

NodeList bookList = document.getElementsByTagName("book"); //节点集

int bookCnt = bookList.getLength();

System.err.println("一共获取到" + bookCnt +"本书");

for(int i=0; i Node book = bookList.item(i);

NamedNodeMap attrs = book.getAttributes();

for(int j=0; j Node attr = attrs.item(j);

System.err.println(attr.getNodeName()+"---"+attr.getNodeValue());//id

}

NodeList childNodes = book.getChildNodes();

for(int k=0; k if(childNodes.item(k).getNodeType() == Node.ELEMENT_NODE){

System.out.println(childNodes.item(k).getNodeName()+"---" + childNodes.item(k).getTextContent());

}

}

}

} catch (ParserConfigurationException e) {

e.printStackTrace();

} catch (SAXException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}

SAX（Simple API for XML）解析

优点

不需要等待所有的数据被处理，解析就可以开始

只在读取数据时检查数据，不需要保存在内存中

可以在某一个条件满足时停止解析，不必要解析整个文档

效率和性能较高，能解析大于系统内存的文档

缺点

解析逻辑复杂，需要应用层自己负责逻辑处理，文档越复杂程序越复杂

单向导航，无法定位文档层次，很难同时同时访问同一文档的不同部分数据，不支持 XPath

解析步骤

获取一个 SAXParserFactory 的实例

通过 factory() 获取 SAXParser 实例

创建一个 handler() 对象

通过 parser 的 parse() 方法来解析 XML

SAXTest.java

package Paint;

import java.io.IOException;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.SAXException;

public class SAXTest {

public static void main(String[] args) {

// 获取实例

SAXParserFactory factory = SAXParserFactory.newInstance();

try {

SAXParser parser = factory.newSAXParser();

SAXParserHandler handler = new SAXParserHandler();

parser.parse("./src/Paint/hello.xml", handler);

System.err.println("共有"+ handler.getBookList().size()+ "本书");

for(Book book : handler.getBookList()){

System.out.println(book.getName());

System.out.println("id=" + book.getId());

System.out.println(book.getAuthor());

System.out.println(book.getYear());

System.out.println(book.getPrice());

System.out.println(book.getLanguage());

}

} catch (ParserConfigurationException e) {

e.printStackTrace();

} catch (SAXException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}

SAXParserHandler.java

package Paint;

import java.util.ArrayList;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

public class SAXParserHandler extends DefaultHandler {

String value = null;

Book book = null;

private ArrayList bookList = new ArrayList();

public ArrayList getBookList() {

return bookList;

}

/*

* XML 解析开始

*/

public void startDocument() throws SAXException {

super.startDocument();

System.out.println("xml 解析开始");

}

/*

* XML 解析结束

*/

public void endDocument() throws SAXException {

super.endDocument();

System.out.println("xml 解析结束");

}

/*

* 解析 XML 元素开始

*/

public void startElement(String uri, String localName, String qName,

Attributes attributes) throws SAXException {

super.startElement(uri, localName, qName, attributes);

if(qName.equals("book")){

book = new Book();

for(int i=0; i System.out.println(attributes.getQName(i)+"---"+attributes.getValue(i));

if(attributes.getQName(i).equals("id")){

book.setId(attributes.getValue(i));

}

}

}else if(!qName.equals("bookstore")){

System.out.print("节点名："+ qName + "---");

}

}

/*

*解析 XML 元素结束

*/

public void endElement(String uri, String localName, String qName)

throws SAXException {

super.endElement(uri, localName, qName);

if(qName.equals("book")){

bookList.add(book);

book = null;

}

else if(qName.equals("name")){

book.setName(value);

}else if(qName.equals("year")){

book.setYear(value);

}else if(qName.equals("author")){

book.setAuthor(value);

}else if(qName.equals("price")){

book.setPrice(value);

}else if(qName.equals("language")){

book.setLanguage(value);

}

}

public void characters(char[] ch, int start, int length)

throws SAXException {

super.characters(ch, start, length);

// 获取节点值数组

value = new String(ch, start, length);

if(!value.trim().equals("")){

System.out.println("节点值："+value);

}

}

}

java怎么解析xml的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java怎么解析xml循环节点、java怎么解析xml的信息别忘了在本站进行查找喔。

标签：