java解析xmljar

Ⅰ java解析xml常用的几种方式、

1.DOM(Document Object Model) DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集...
2.SAX(Simple API for XML) SAX处理的优点非常类似于流媒体...
3.JDOM(Java-based Document Object Model)

Ⅱ 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文件

给个例子你

<?xmlversion="1.0"encoding="utf-8"?>
<Accounts>
<Accounttype="type1">
<code>100001</code>
<pass>123</pass>
<name>李四</name>
<money>1000000.00</money>
</Account>
<Accounttype="type2">
<code>100002</code>
<pass>123</pass>
<name>张三</name>
<money>1000.00</money>
</Account>
</Accounts>

java代码：

importjava.io.*;
/**
*xml文件解析
*@authoryoung
*
*/
importjavax.xml.parsers.DocumentBuilder;
importjavax.xml.parsers.DocumentBuilderFactory;
importorg.w3c.dom.Document;
importorg.w3c.dom.Element;
importorg.w3c.dom.Node;
importorg.w3c.dom.NodeList;

publicclassXmlExam{
	publicstaticvoidmain(Stringargs[]){
		Elementelement=null;
		//可以使用绝对路劲
		Filef=newFile("xml.xml");
		//documentBuilder为抽象不能直接实例化(将XML文件转换为DOM文件)
		DocumentBuilderdb=null;
		DocumentBuilderFactorydbf=null;
		try{
			//返回documentBuilderFactory对象
			dbf=DocumentBuilderFactory.newInstance();
			//返回db对象用documentBuilderFatory对象获得返回documentBuildr对象
			db=dbf.newDocumentBuilder();
			//得到一个DOM并返回给document对象
			Documentdt=db.parse(f);
			//得到一个elment根元素
			element=dt.getDocumentElement();
			//获得根节点
			System.out.println("根元素："+element.getNodeName());
			//获得根元素下的子节点
			NodeListchildNodes=element.getChildNodes();
			//遍历这些子节点
			for(inti=0;i<childNodes.getLength();i++){
				//获得每个对应位置i的结点
				Nodenode1=childNodes.item(i);
				if("Account".equals(node1.getNodeName())){
					//如果节点的名称为"Account"，则输出Account元素属性type
					System.out.println("
找到一篇账号.所属区域:"
							+node1.getAttributes().getNamedItem("type")
									.getNodeValue()+".");
					//获得<Accounts>下的节点
					NodeListnodeDetail=node1.getChildNodes();
					//遍历<Accounts>下的节点
					for(intj=0;j<nodeDetail.getLength();j++){
						//获得<Accounts>元素每一个节点
						Nodedetail=nodeDetail.item(j);
						if("code".equals(detail.getNodeName()))//输出code
							System.out
									.println("卡号:"+detail.getTextContent());
						elseif("pass".equals(detail.getNodeName()))//输出pass
							System.out
									.println("密码:"+detail.getTextContent());
						elseif("name".equals(detail.getNodeName()))//输出name
							System.out
									.println("姓名:"+detail.getTextContent());
						elseif("money".equals(detail.getNodeName()))//输出money
							System.out
									.println("余额:"+detail.getTextContent());
					}
				}
			}
		}catch(Exceptione){
			e.printStackTrace();
		}
	}
}

要导入的jar包

Ⅳ java解析xml文件的用到哪些包

利用以下工具都可以实现对xml 文件的解析 ，dom4j, jdom, SAX,DOM
如果是在java程序中解析xml文件，主要使用dom4j和jdom，dom4j用的比较多，诸多MVC框架及orm框架都是使用dom4j来解析xml文件的。
dom 方式则和语言无关的xml文件操作的国际标准。

Ⅳ Java如何读取XML文件 具体实现

xml的解析
1.解析式为了得到里面的内容，进行增,删，改查的操作

XML的解析方式
SAX(Simple API for XML)xml文档的一种简单的解析方式
DOM(Document Object Model)
DOM4J
SAX：基于事件的解析方式
DOM: 基于对象的解析方式
事件监听三要素
1.事件源
2.监听器
3.事件
SAX 基于事件的解析
优点: 简单 效率高
缺点:顺序执行,不能得到某个元素 不能逆向执行
不能进行增，与删的操作
SAX解析方式工作原理：
通过时间源xml文档创建SAXParseFactory
SAXParserFactory factory=SAXParserFactory.newInstance();
得到一个解析器
SAXParser parse=factory.newSAXParser();
对xml文件进行解析
得到解析的文件对象
File file=new File("employees.xml");
通过监听器进行解析
MyListener listener=new MyListener();
parse.parse(file,listener);
对于监听器有5个方法：监听器所在的类实现的接口有：
org.xml.sax.hepers.DefaultHandler
org.xml.sax
通过查看API文档中的DefaultHandler类中的下面5个方法
startDocument() 对于文档开始的解析
public void startDocument()throws SAXException{
System.out.println("文档开始解析啦!!!!");
}
startElement()元素开始的解析其中几个名词
url:命名空间的url
localName:命名空间的前缀
qName:元素
attributes:元素里的属性
public void startElement(String url,String localName,String qName,Attributes attributes)throws SAXException{
StringBuffer sb=new StringBuffer();
sb.append("<"+qName);
for(int i=0;i<attributes.getLength();i++){
String attName=attributes.getQName(i);获得元素属性名称其中的i为元素的第几个属性
String attValue=attributes.getValue(i);获得元素属性的值其中的i为元素的第几个属性的值
sb.append(attName+"="+attValue);
}
sb.append(">");
System.out.print(sb.toString());
}
character()获得元素的内容体
public void characters(char[]ch,int start,int length)throws SAXException{
System.out.print(new String(ch,start,length));
}
endElement()获得元素的结束事件
public void endElement(String url,String localName,String qName)throws SAXException{
System.out.print("</"+qName+">");
}
endDocument()获得文档的结束事件
public void endDocument(){
System.out.println("文档解析结束啦!!!!");
}
对于SAX解析只能逐行解析不能越行解析
DOM:基于对象的
优点:灵活,能进行增删的操作
缺点:读取速度慢，效率低 占用的内容多
对于DOM解析：不需要添加监听器，按级解析从根元素、一级子元素、二级子元素......
同SAX解析相同刚开始也是要得到一个解析器;
DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance() ;
因为构造方法不可用不可以new对象只能用newInstance()方法得到解析器对象
DocumentBuilder builder=factory.newDocumentBuilder() ;得到一个解析器
对于document可以有两种方法得到：
Document document= builder.parse(new File(文件路径));通过parse方法解析一个已有的xml文档
Document document=builder.newDocument();可以得到一个空的document对象
得到根节点
Element root=document.getDocumentElement();
如果不存在根节点即为一个空document对象的时候只能添加跟节点
Element root=document.createElement(根节点的名字)
得到根节点下面的所有一级子元素
NodeList list=root.getElementsByTagName(根节点的名字可以用root.getTagName或者root.getNodeName()得到根节点的名字)();
{
对与document可以添加一级子元素
不管document是否为空都可以添加
Element firstElements =root.creatElement(一级子元素的名字);
当然也可以为一级子元素添加属性
一级子元素的名字.setAttribute("属性名","属性值");
}
通过遍历list集合
for(int i=0;i<list.getLength();i++){
Element first_elements=(Element)list.item(i);
可以得到一级资源的属性的值当知道属性的时候
String attribute=first_elements.getAttribute("属性的名字");
得到一级子元素的名字
String first_elements_name=first_elements.getNodeName();
得到一级子元素下面所有的元素如id 第一个id元素当然也可有很多个id
通过item()来确定要取那个id
Element id_element=(Element)first_elements.getElementByName("id").item(0);
得到id的值
String id_value=id_element.getFirstChild().getTextContent();
通过这个遍历集合可以拿到所有子元素
}
DOM添加或删除元素：
DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance() ;
因为构造方法不可用不可以new对象只能用newInstance()方法得到解析器对象
DocumentBuilder builder=factory.newDocumentBuilder() ;得到一个解析器
对于document可以有两种方法得到：
Document document= builder.parse(new File(文件路径));通过parse方法解析一个已有的xml文档
Document document=builder.newDocument();可以得到一个空的document对象
得到根节点
Element root=document.getDocumentElement();
如果不存在根节点即为一个空document对象的时候只能添加跟节点
Element root=document.createElement(根节点的名字)
对与document可以添加一级子元素
不管document是否为空都可以添加
Element firstElements =root.creatElement(一级子元素的名字);
当然也可以为一级子元素添加属性
一级子元素的名字.setAttribute("属性名","属性值");
添加二级子元素
Element secondElements=firstElements.creatElement("二级子元素的名字");
挂载组装
一级子元素firstElements.append(secondElements);
根节点root.appendChild(firstElements);
将document对象树写入磁盘
TransformerFactory tf=TransformerFactory.newInstance();
Transformer former=tf.newTransformer();
DOMSource source=new DOMSource(document);
StreamResult result= new StreamResult(new File("10.xml"));结果集
former.transform(source,result);
完毕
DOM4j需要借助外部jar包
需要借助外部jar包就必须设置环境变量中的classpath把classpath设置成
dom4j jar包存在的路径（绝对路径）
例如:
set classpath=.;C:\Documents and Settings\Administrator\桌面\day3\dom4j.jar
import org.dom4j.io.*;
import java.io.*;
import java.util.*;
import org.dom4j.*;
public static void read_XML(String fileName){
try{
//得到一个解析器，相当于SAX,DOM里面的解析器工厂，与解析器
SAXReader reader=new SAXReader();
//得到一个对象树
Document document=reader.read(new File(fileName));
//得到一个根元素
Element root=document.getRootElement();
System.out.println(root.getName());
//得到所有的一级子元素
List firstElements=root.elements();
Iterator it=firstElements.iterator();
while(it.hasNext()){
//依次得到每一个一级子元素
Element firstElement=(Element)it.next();
System.out.println(firstElement.getName());
//得到所有的属性
List attributes=firstElement.attributes();
for(Object obj:attributes){
//依次得到每一个属性
Attribute att=(Attribute)obj;
System.out.println(att.getName()+"="+att.getValue());
}
//得到一级子元素下面的所有元素，及其附带值
List second_Elements=firstElement.elements();
Iterator second_Element=second_Elements.iterator();
while(second_Element.hasNext()){
Element sec_Element=(Element)second_Element.next();
System.out.println(sec_Element.getName()+":"+sec_Element.getText());

}
System.out.println("----------");
}
}catch(Exception e){

}
}
public static void write(String fileName){
try{
Document document = DocumentHelper.createDocument();
//创造一级子元素
Element books=document.addElement("books");
books.addComment("The book is J2EE");
Element book=books.addElement("book");
创建元素的属性
book.addAttribute("show","yes");
book.addAttribute("page","100");
创建二级子元素
Element book_name=book.addElement("bookName");
创建元素的内容体
book_name.setText("xml");
Element book_price=book.addElement("bookPrice");
book_price.setText("3000");
Element book_press=book.addElement("bookPress");
book_press.setText("etoak");
Element book_author=book.addElement("bookAuthor");
book_author.setText("Robin");
//挂载另一个一级子元素
book=books.addElement("book");
book.addAttribute("show","NO");
book.addAttribute("page","200");
book_name=book.addElement("bookName");
book_name.setText("葵花宝典");
book_price=book.addElement("bookPrice");
book_price.setText("无价之宝");
book_press.addElement("bookPress");
book_press.setText("华山派");
book_author=book.addElement("bookAuthor");
book_author.setText("林平之");
//创建xml文件输出的路径
OutputFormat format=OutputFormat.createPrettyPrint();
format.setEncoding("gbk");
XMLWriter xw=new XMLWriter(new FileOutputStream(fileName),
format);
//XMLWriter xx= new XMLWriter(System.out,OutputFormat.createPrettyPrint());
xw.write(document);
xw.flush();
xw.close();
}catch(Exception e){
对于DOM4j添加子元素，是一级一级的添加的而在DOM中是先创造
子元素然后再挂载的DOM4j在创建子元素的时候就确定好了顺序
对于文件的输出各有千秋各有特色其中SAX是需要添加监听器的
}
}
public static void update(String fileName){
try{
SAXReader reader= new SAXReader();
Document document = reader.read(new File(fileName));
Element root = document.getRootElement();
System.out.println(root.getName());
在根节点上添加一级子元素
Element student=root.addElement("student");
Element id=student.addElement("id");
id.setText("007");
OutputStream os= new FileOutputStream(fileName);
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter xw = new XMLWriter(os,format);
xw.write(document);
xw.flush();
xw.close();
}catch(Exception e){
和创建一个新的document对象类似只不过这个的根节点已经存在
直接可以在根节点上添加一级子元素；
}
}

Ⅵ JAVA中XML解析问题

你这是属于使用dom4j.jar，利用SAX的方式读取xml文件..
可以参照API, 你把property和element搞混了, 这里的sex是element.

1.读取xml文件, inStream的过程你用任何方式都可以.

2.利用sax的方式
SAXReader reader = new SAXReader();
Document doc = reader.read(inStream);

3.根据节点获取内容
String name = ((Element)doc.selectSingleNode("/home/name")).getText();
String sex = ((Element)doc.selectSingleNode("/home/sex")).getText();
...

还有,确保你的XML是符合规范的,不符合规范肯定通不过,最好用带有Validation的XML工具检查一下

Ⅶ 在java中解析xml文档的问题

我给你个例子吧。。。

import javax.xml.parsers.*;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
import java.io.*;
public class XMLUtil
{
//该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
public static Object getBean()
{
try
{
//创建文档对象
DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dFactory.newDocumentBuilder();
Document doc;
doc = builder.parse(new File("config.xml"));

//获取包含类名的文本节点
NodeList nl = doc.getElementsByTagName("className");
Node classNode=nl.item(0).getFirstChild();
String cName=classNode.getNodeValue();

//通过类名生成实例对象并将其返回
Class c=Class.forName(cName);
Object obj=c.newInstance();
return obj;
}
catch(Exception e)
{
e.printStackTrace();
return null;
}
}
}

下面是xml文件
<?xml version="1.0"?>
<config>
<className>HaierFactory</className>
</config>

什么包都不要导，就算在最低级的JCreator中直接编译就可以的。。。自己写个main函数调用一下。。

不懂追问，望采纳。如果要学习类似只是2有视频教程

Ⅷ 如有用Java解析 下面的xml流

引入dom4j.jar
SAXreader reader = new SAXReader();
Document doc = reader.read(InputStream is); // 这里将流传入
Element root = doc.getRootElement(); // root就是<RESPONSE>节点
Element head = root.element("HEAD");
Element body = root.element("BODY");

里面有很多方法可以获得子节点，以及获得属性等

Ⅸ java 解析xml文件内容

publicclassContext{
privateStringrequest;

privateStringresponse;
publicStringgetRequest(){
returnrequest;
}
publicvoidsetRequest(Stringrequest){
this.request=request;
}
publicStringgetResponse(){
returnresponse;
}
publicvoidsetResponse(Stringresponse){
this.response=response;
}
}

importjava.util.ArrayList;
importjava.util.List;
importorg.dom4j.Document;
importorg.dom4j.DocumentHelper;
importorg.dom4j.Element;
publicclassXmlInfoUtils{
publicstaticvoidparseXML(Stringxml)throwsException{
//将xml转换为document对象
Documentdocument=DocumentHelper.parseText(xml);
//获取根目录节点infos;
Elementroot=document.getRootElement();
//获取根节点下的所有直接子节点info
List<Element>infoNodes=root.elements();
//遍历所有info节点
for(Elementelement:infoNodes){
//获取info节点下的所有直接子节点request和response
List<Element>contextNodes=element.elements();
//遍历节点
for(Elementcontext:contextNodes){
//获取值
System.out.println(context.getName()+""+context.getText());
}
}
}
/**

*生成所需要的XML

*/

publicstaticStringcreateXML(List<Context>list)throwsException{

Documentdocument=DocumentHelper.createDocument();

Elementroot=document.addElement("infos");

for(Contextcontext:list){

Elemente=root.addElement("info");

e.addElement("request").setText(context.getRequest());

e.addElement("response").setText(context.getResponse());

}

returndocument.asXML();

}

/**测试代码*/

publicstaticvoidmain(String[]args)throwsException{

//准备数据

List<Context>list=newArrayList<Context>();

Contextcontext=newContext();

context.setRequest("sss");

context.setResponse("{aa:bb}");

list.add(context);

context=newContext();

context.setRequest("qqq");

context.setResponse("{aa:bb}");

list.add(context);

//创建XML

Stringxml=createXML(list);

//解析XML

parseXML(xml);

}

}

Ⅹ java解析xml文件需要导入哪些的包

推荐dom4j.jar
jdom.jar也可以考虑，其他的没有这两个好用。