一 XML文件
XML ---可扩展标记语言
XML文件
1 存储数据:简单灵活
2 数据传输:平台无关
3 配置文件:可读性强
标签：<product>开始标签 </product>结束标签 标签都是成对出现
属性：包含在开始标签中的属性名=“属性值”
文本：包含在开始标签和结束标签之间的文本内容
二 解析XML文件
1 DOM
DOM：Document Object Model，即文档对象模型
DOM把XML文映射成一个倒挂的树
使用DOM解析XML文档的步骤：
1.1 创建解析器工厂对象
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
1.2 由解析器工厂对象创建解析器对象
DocumentBuilder db = dbf.newDocumentBuilder();
1.3 由解析器对象对指定XML文件进行解析，构建相应DOM树，创建Document对象
Document document = db.parse("E:\\products.xml");
1.4 以Document对象为起点对DOM树的节点进行增删改查操作。
节点Node：在树中标签，属性，文本都是节点
元素Element:元素就是标签节点
属性Attr:属性就是属性节点
文本Text:文本节点
//1 获取树中的根元素(products)
Element root = document.getDocumentElement();
//2 根元素的子元素
NodeList ps = root.getElementsByTagName("product");//获取当前元素的叫做product的所有子元素
//3 循环处理所有product子元素
for(int i=0;i<ps.getLength();i++)
{
//获取集合中的一个元素
Element p = (Element)ps.item(i);
//获取当前节点的所欲子节点
NodeList list = p.getChildNodes();
//循环处理product中的所有子节点
for(int j=0;j<list.getLength();j++)
{
//获取一个子节点
Node node = list.item(j);
//获取节点名和节点文本内容
if(!node.getNodeName().startsWith("#"))
System.out.println("节点名：" + node.getNodeName() + ",节点文本内容：" + node.getTextContent());
}
}
2 SAX
事件驱动机制：当某一个事件发生时，会自动调用事件处理器中处理这种事件的方法
SAX解析器不像DOM那样建立一个完整的文档树，而是在读取文档时激活一系列事件，事件处理器提供对这些事件进行处理的方法
1.1 创建解析器工厂对象
SAXParserFactory sFactory = SAXParserFactory.newInstance();
1.2 由解析器工厂对象创建解析器对象
SAXParser sp = sFactory.newSAXParser();
1.3 由解析器对象对指定XML文件进行解析
//3 解析(提供事件处理器)
MyHandler myHandler = new MyHandler();
sp.parse("E:\\products.xml",myHandler);
1.4 重写事件处理器中的方法对数据进行处理
事件处理类继承自DefaultHandler
然后重写事件处理中关注的事件对应的方法
//如果是一个标签的开始，就自动调用这个方法,qName是标签名
@Override
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
}
//如果是文本内容，就自动调用这个方法，而且字符数组ch中存储的就是这个文本内容
@Override
public void characters(char[] ch, int start, int length)
throws SAXException {
}
//如果是一个标签的结束，就自动调用这个方法,qName是标签名
@Override
public void endElement(String uri, String localName, String qName)
throws SAXException {
}
下边两种方式需要导入jar包
3 JDOM
1 解析器
SAXBuilder sBuilder = new SAXBuilder();
2 解析
Document document = sBuilder.build("E:\\products.xml");
3 从document中获取需要的数据
Element root = document.getRootElement();//获取根元素
getChild(String name)//获取叫做name的那一个子元素
getChildren()//获取所有的子元素
getChildren(String name)//获取所有叫做name的子元素
getChildText(String name)//直接获取叫做name的那一个子元素的文本内容
4 DOM4J
1 解析器
SAXReader sr = new SAXReader();
2 解析
Document document = sr.read("E:\\products.xml");
3 从document中获取需要的数据
Element root = document.getRootElement();//products
获取root下的product子元素构成的集合的迭代器
Iterator<Element> it = root.elementIterator("product");
Element element = it.next();
//获取element下的所有子元素组成的集合的迭代器
Iterator<Element> iterator = element.elementIterator();
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class TestDOM {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
(new DomXML()).parse();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class DomXML
{
//用DOM方式解析XML文件
public void parse() throws Exception
{
//1 解析器工厂
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
//2 解析器
DocumentBuilder db = dbf.newDocumentBuilder();
//3 解析
Document document = db.parse("E:\\products.xml");
//4 把倒挂的树中的有效数据拿出来
//1 获取树中的根元素(products)
Element root = document.getDocumentElement();
//2 根元素的子元素
NodeList ps = root.getElementsByTagName("product");//获取当前元素的叫做product的所有子元素
//3 循环处理所有product子元素
for(int i=0;i<ps.getLength();i++)
{
//获取集合中的一个元素
Element p = (Element)ps.item(i);
//获取当前节点的所欲子节点
NodeList list = p.getChildNodes();
//循环处理product中的所有子节点
for(int j=0;j<list.getLength();j++)
{
//获取一个子节点
Node node = list.item(j);
//获取节点名和节点文本内容
if(!node.getNodeName().startsWith("#"))
System.out.println("节点名：" + node.getNodeName() + ",节点文本内容：" + node.getTextContent());
}
}
}
}
import java.util.Iterator;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
public class TestDOM4J {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
DOM4JXML.parse();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class DOM4JXML
{
public static void parse() throws Exception
{
//1 解析器
SAXReader sr = new SAXReader();
//2 解析
Document document = sr.read("E:\\products.xml");
//3 从document中获取需要的数据
Element root = document.getRootElement();//products
//获取root下的子元素构成的集合的迭代器
Iterator<Element> it = root.elementIterator("product");
while(it.hasNext())
{
Element element = it.next();//product
Iterator<Element> iterator = element.elementIterator();
while(iterator.hasNext())
{
Element element2 = iterator.next();
System.out.println(element2.getName() + "," + element2.getText());
}
}
}
}import java.util.Iterator;
import java.util.List;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
public class TestJDOM {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
JDOMXML.parse();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class JDOMXML
{
public static void parse() throws Exception
{
//1 解析器
SAXBuilder sBuilder = new SAXBuilder();
//2 解析
Document document = sBuilder.build("E:\\products.xml");
//3 从document中获取需要的数据
Element root = document.getRootElement();//products
//root下的子元素
List list = root.getChildren("product");
Iterator<Element> it = list.iterator();
while(it.hasNext())
{
Element element = it.next();//product
/*
//product才的所有子元素
List lt = element.getChildren();
Iterator<Element> iterator = lt.iterator();
while(iterator.hasNext())
{
Element element2 = iterator.next();
System.out.println(element2.getName() + "," + element2.getText());
}*/
System.out.println("id = " + element.getChildText("productid"));
System.out.println("name = " + element.getChildText("product_name"));
System.out.println("price = " + element.getChildText("price"));
System.out.println("num = " + element.getChildText("num"));
System.out.println("time = " + element.getChildText("publish_time"));
}
}
}import java.util.ArrayList;
import java.util.Iterator;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class TestSAX {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
SAXXML.parse();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class SAXXML
{
public static void parse() throws Exception, SAXException
{
//1 解析器工厂
SAXParserFactory sFactory = SAXParserFactory.newInstance();
//2 解析器
SAXParser sp = sFactory.newSAXParser();
//3 解析(提供事件处理器)
MyHandler myHandler = new MyHandler();
sp.parse("E:\\products.xml",myHandler);
//获取解析出的所有产品并打印
ArrayList<Product> list = myHandler.getList();
Iterator<Product> iterator = list.iterator();
while(iterator.hasNext())
{
System.out.println(iterator.next());
}
}
}
//事件处理器类
class MyHandler extends DefaultHandler
{
private ArrayList<Product> list = new ArrayList<Product>();//存储解析出来的所有产品数据
private Product product;//存一个产品信息
private String tag;//存储标签名
public ArrayList<Product> getList() {
return list;
}
//如果是一个标签的开始，就自动调用这个方法,qName是标签名
@Override
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
// TODO Auto-generated method stub
//System.out.println(qName + "开始");
tag = qName;//保存标签名
if(tag.equals("product"))
product = new Product();//存储接下来要解析出的产品信息
}
//如果是文本内容，就自动调用这个方法，而且字符数组ch中存储的就是这个文本内容
@Override
public void characters(char[] ch, int start, int length)
throws SAXException {
// TODO Auto-generated method stub
//System.out.println("内容：" + new String(ch,start,length));
String data = new String(ch,start,length).trim();
if(!data.equals(""))
{
if(tag.equals("productid"))
product.setId(Integer.parseInt(data));
if(tag.equals("product_name"))
product.setName(data);
if(tag.equals("price"))
product.setPrice(Integer.parseInt(data));
if(tag.equals("num"))
product.setNum(Integer.parseInt(data));
if(tag.equals("publish_time"))
product.setTime(data);
}
}
//如果是一个标签的结束，就自动调用这个方法,qName是标签名
@Override
public void endElement(String uri, String localName, String qName)
throws SAXException {
// TODO Auto-generated method stub
//System.out.println(qName + "结束");
tag = qName;
if(tag.equals("product"))
list.add(product); //把解析出来的这个产品信息添加到集合
}
}
class Product
{
private int id;
private String name;
private int price;
private int num;
private String time;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getTime() {
return time;
}
public void setTime(String time) {
this.time = time;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return id + name + price + num + time;
}
}<?xml version="1.0" encoding="UTF-8"?>
<products>
<product>
<productid>1</productid>
<product_name>电脑500</product_name>
<price>5000</price>
<num>1000</num>
<publish_time>2012-01-01</publish_time>
</product>
<product>
<productid>2</productid>
<product_name>TCL智能家电</product_name>
<price>5000</price>
<num>1000</num>
<publish_time>2012-01-01</publish_time>
</product>
</products>
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
