XML文件可扩展标记语言：Extensible Markup Language,
解析和写入xml文件常用的四种方法，DOM SAX JDOM DOM4j方法
其中DOM和SAX方法时java官方提供的解析方法，JDOM和DOM4j为第三方开发商提供的java开发库，需要自己添加库，下面一一介绍解析xml文件的方法
一、DOM
1，解析xml步骤：
a，创建DocumentBuilderFactory类的对象，工厂类需要调用其静态方法newInstance()来得到对象。
b,通过DocumentBuilderFactory对象创建DocumentBuilder对象，调用newDocumentbuilder（）方法。
c,通过DocumentBuilder对象调用parse（“xmlw文件地址”）方法加载xml文件。得到Document对象
d,document对象代表整个xml文件，通过其类方法来获取xml文件中的节点。
通过DOM 解析xml文件的代码如下：
package xxlong.test;
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.Node;
import org.xml.sax.SAXException;
import org.w3c.dom.NodeList;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Element;
public class DomTest {
/**
* DOM解析xml文件的步骤：
* 1，创建DocumentBuilderFactory对象
* 2，创建一个DocumentBuilder对象
* 3，通过DocumentBuilder对象的parser方法加载books.xml文件到当前项目下
* 4，获取所有book节点的集合getElementByTagName(String name)
* 5,遍历节点的属性
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//通过DocumentBuilderFactory的newInstance()方法创建DocumentBuilderFactory对象
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
try {
//创建DocumentBuilder对象
DocumentBuilder db = dbf.newDocumentBuilder();
//通过parse方法加载文件
Document d = db.parse("book.xml");
//获取所有book节点
NodeList nl = d.getElementsByTagName("book");
System.out.println("节点个数： " + nl.getLength());
for(int i = 0; i<nl.getLength(); i++) {
Node book = nl.item(i);
NamedNodeMap attrs = book.getAttributes();
for(int j = 0; j<attrs.getLength(); j++) {
Node attr = attrs.item(j);
System.out.print("第" + (i+1) + "本书\n" + attr.getNodeName());
System.out.println("--属性值：" + attr.getNodeValue());
}
NodeList bookChiled = book.getChildNodes();
System.out.println("第" + (i+1) + "本书共有" + bookChiled.getLength() + "个子节点");
for(int k = 0; k<bookChiled.getLength(); k++) {
if(bookChiled.item(k).getNodeType() == Node.ELEMENT_NODE) {
System.out.println(bookChiled.item(k).getNodeName());
// System.out.println(bookChiled.item(k).getFirstChild().getNodeValue());
System.out.println(bookChiled.item(k).getTextContent());
}
}
// //知道节点的属性名时可以使用这种方法
// Element book = (Element) nl.item(i);
// System.out.println(book.getAttribute("id"));
}
} catch (ParserConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
2，通过DOM方法生成xml文件
使用DOM方法生成xml文件的步骤：
1，生成DocumentBuilderFactory dbf，使用静态类方法newInstance（）方法
2，生成DocumentBuilder db
3，生成Document document = db.newDocument();Document对象代表要生成的xml文件
4，创建根节点：Element rootElement = document.createElement("bookStore");
5，添加根节点document.appendChild(rootElement);
6，为根节点创建子节点及设置节点值：Element book = document.createElement("book"); book.setAttribute(String name, String value)给子节点添加属性值
添加叶子节点值：name.setTextContent("冰与火之歌");
添加到根节点上：rootElement.appendChild(book);
7，创建transformerFactory工厂类对象，使用类静态方法newInstance（）；方法得到工厂类对象。
8，通过transformerFactory工厂类对象创建Transformer对象，newTransformer（）；
9，使用Transformer对象将document对象转换成xml文件，可以通过其设置向xml文件的格式。如编码格式，是否换行等
代码如下：
package xxlong.test;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.UserDataHandler;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.stream.StreamResult;
import java.io.File;
public class DOMUtil {
/**
* 使用DOM生成xml文件
* 1，生成DocumentBuilderFactory dbf，使用newInstance（）方法
* 2，生成DocumentBuilder db
* 3，生成Document document
* 4，创建根节点：Element rootElement = document.createElement("bookStore");
* 5，添加根节点document.appendChild(rootElement);
* 6，为根节点创建子节点及设置节点值：Element book = document.createElement("book");
* 添加节点值：name.setTextContent("冰与火之歌");
* 添加到根节点上：rootElement.appendChild(book);
*
*/
public void createXML() {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
try {
DocumentBuilder db = dbf.newDocumentBuilder();
Document document = db.newDocument();
document.setXmlStandalone(true);
document.setXmlVersion("1.0");
Element rootElement = document.createElement("bookStore");
Element book = document.createElement("book");
Element name = document.createElement("name");
Element price = document.createElement("price");
Element year = document.createElement("year");
Element language = document.createElement("language");
name.setTextContent("冰与火之歌");
price.setTextContent("230");
year.setTextContent("2008");
language.setTextContent("English");
book.appendChild(name);
book.appendChild(price);
book.appendChild(year);
book.appendChild(language);
book.setAttribute("id", "1");
rootElement.appendChild(book);
document.appendChild(rootElement);
TransformerFactory tff = TransformerFactory.newInstance();
Transformer tf = tff.newTransformer();
tf.setOutputProperty(OutputKeys.ENCODING, "gbk");
tf.setOutputProperty(OutputKeys.INDENT, "yes");
tf.transform(new DOMSource(document), new StreamResult(new File("book.xml")));
} catch (ParserConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (TransformerConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (TransformerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
SAX方法解析xml文件
使用SAX解析xml文件
1，创建SAXParserFactory对象，使用SAXParserFactory的newinstance()方法，
包路径为：javax.xml.parsers.SAXParserFactory;
2,创建SAXParser对象，使用spf.newSAXParser()方法，
包路径：javax.xml.parsers.SAXParser;
3,使用sp.parse(String uri, DefaultHandler dh)方法加载.xml文件，需要创建一个DefaultHandler
对象，创建一个类，继承DefaultHandler类，创建子类的对象；包路径：org.xml.sax.helpers.DefaultHandler;
创建DefaultHandler对象需要覆写其中的方法
1，public void startDocument() throws SAXException；解析文件开始
2，public void endDocument() throws SAXException；解析文件结束
3，public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException；解析xml文件节点
4，public void endElement(String uri, String localName, String qName) throws SAXException ；结束节点解析
5，public void characters(char[] ch, int start, int length) throws SAXException；解析节点值
方法调用顺序
startDocument
startElement-->characters-->endElement-->循环
endDocument
DefaultHandler 类代码如下：
package xxlong.test;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import java.util.ArrayList;
public class defaultHandler extends DefaultHandler{
/**
* 解析顺序
* startDocument
* startElement-->characters-->endElement-->循环
* endDocument
*
*
*/
Book book;
int countIndex = 0;
String value;
private ArrayList<Book> bookList = new ArrayList<Book>();
/**
* 解析xml元素
*
*/
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
// TODO Auto-generated method stub
//调用父类
super.startElement(uri, localName, qName, attributes);
if(qName.equals("book")) {
book = new Book();
countIndex++;
System.out.println("============开始遍历第" + countIndex + "本部的内容===============");
//已知属性名
//System.out.println(attributes.getValue("id"));
//不知道book元素下有多少个属性和名称，
for(int i = 0; i<attributes.getLength(); i++) {
if(attributes.getQName(i).equals("id")) {
book.setId(attributes.getQName(i));
}
System.out.println(attributes.getQName(i));//获取属性名
System.out.println(attributes.getValue(i));//获取属性值
}
}
if(!qName.equals("bookstore")) {
System.out.print(qName + ":");
}
}
public ArrayList<Book> getBookList() {
return bookList;
}
@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
// TODO Auto-generated method stub
super.endElement(uri, localName, qName);
if(qName.equals("name")) {
book.setName(value);
}
if(qName.equals("author")) {
book.setAuthor(value);
}
if(qName.equals("year")) {
book.setYear(value);
}
if(qName.equals("language")) {
book.setLanguage(value);
}
if(qName.equals("price")) {
book.setPrice(value);
}
if(qName.equals("book")) {
bookList.add(book);
book = null;
System.out.println("============结束遍历第" + countIndex + "本部的内容===============");
}
}
/**
* 标志解析文件开始
*/
@Override
public void startDocument() throws SAXException {
// TODO Auto-generated method stub
super.startDocument();
System.out.println("解析文件开始");
}
/**
* 标志解析文件结束
*/
@Override
public void endDocument() throws SAXException {
// TODO Auto-generated method stub
super.endDocument();
System.out.println("解析文件开始");
}
/**
* 解析节点
* value是节点的值
*
*/
@Override
public void characters(char[] ch, int start, int length) throws SAXException {
// TODO Auto-generated method stub
super.characters(ch, start, length);
value = new String(ch, start, length);
if(!value.trim().equals("")) {
System.out.println(value);
}
}
}
解析方法：
public ArrayList<Book> parseXML() {
ArrayList<Book> bookList = null;
SAXParserFactory spf = SAXParserFactory.newInstance();
try {
SAXParser sp = spf.newSAXParser();
defaultHandler dh = new defaultHandler();
sp.parse("book.xml", dh);
bookList = dh.getBookList();
for (Book book : bookList) {
System.out.println(book.getName());
System.out.println(book.getAuthor());
System.out.println(book.getLanguage());
System.out.println(book.getPrice());
System.out.println(book.getYear());
System.out.println(book.getId());
}
} catch (ParserConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return bookList;
}
2，创建xml文件
1.创建一个TransformerFactory对象
2.通过SAXTransformerFactory对象创建一个TransformerHandler对象，通过handler对象创建xml文件
3.通过handler对象创建一个Transformer
4.通过Transformer对象对xml文件格式设置
5.创建result对象
6.handler 对象调用setResult方法加载result对象，一定要在startDocument方法之前。否者会抛出异常
7.使用handler打开document
8.创建属性AttributesImplement attr = new AttributesImpl();
9.创建节点并添加属性；
10.添加子节点并添加属性，和添加根节点及属性的方法相同
生成xml文件的方法代码如下：
public void createXML() {
ArrayList<Book> bookList = parseXML();
//生成XML
//1.创建一个TransformerFactory对象
SAXTransformerFactory stff = (SAXTransformerFactory)SAXTransformerFactory.newInstance();
try {
//2.通过SAXTransformerFactory对象创建一个TransformerHandler
TransformerHandler handler = stff.newTransformerHandler();
//3.通过handler对象创建一个Transformer
Transformer tf = handler.getTransformer();
//4.通过Transformer对象对xml文件格式设置
tf.setOutputProperty(OutputKeys.INDENT, "yes");
File file = new File("book1.xml");
if(!file.exists()) {
file.createNewFile();
}
//5.创建result对象
Result result = new StreamResult(file);
handler.setResult(result);//setResult方法一定要在startDocument方法之前。否者会抛出异常
//打开document
handler.startDocument();
//创建属性
AttributesImpl attr = new AttributesImpl();
//开始生成节点
handler.startElement("", "", "bookStore", attr);
//给子节点添加属性
attr.clear();
attr.addAttribute("", "", "id", "", "1");
//添加子节点
handler.startElement("", "", "book", attr);
attr.clear();
handler.startElement("", "", "name", attr);
handler.characters("冰与火之歌".toCharArray(), 0, "冰与火之歌".length());
handler.endElement("", "", "name");
//结束节点
handler.endElement("", "", "book");
handler.endElement("", "", "bookStore");
//结束document
handler.endDocument();
} catch (TransformerConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
三、DOM4j方法
1，解析xml文件
a,创建SAXReader对象，通过SAXReader的read方法加载xml文件
b,加载xml文件获得document对象，代表xml文件
c,获取document对象的根节点
d,获取根节点的子节点迭代器，获取子节点的属性及子节点的子节点迭代器，并获取叶子节点的值
代码如下：
public void parseXML() {
ArrayList<Book> bookList = new ArrayList<Book>();
SAXReader saxReader = new SAXReader();
try {
Document document = saxReader.read(new File("book.xml"));
Element root = document.getRootElement();
Iterator<Element> it = root.elementIterator();
while(it.hasNext()) {
Book bookstore = new Book();
Element book = it.next();
List<Attribute> attrs = book.attributes();
for (Attribute attribute : attrs) {
if(attribute.getName().equals("id")) {
bookstore.setId(attribute.getValue());
}
System.out.println("属性名：" + attribute.getName() + "属性值："
+ attribute.getValue());
Iterator<Element> itt = book.elementIterator();
while(itt.hasNext()) {
Element attr = itt.next();
if(attr.getName().equals("author")) {
bookstore.setAuthor(attr.getStringValue());
}
if(attr.getName().equals("name")) {
bookstore.setName(attr.getStringValue());
}
if(attr.getName().equals("year")) {
bookstore.setYear(attr.getStringValue());
}
if(attr.getName().equals("price")) {
bookstore.setPrice(attr.getStringValue());
}
if(attr.getName().equals("Language")) {
bookstore.setLanguage(attr.getStringValue());
}
System.out.println("属性名" + attr.getName()
+ "属性值：" + attr.getStringValue());
}
bookList.add(bookstore);
System.out.println("作者：" + bookstore.getAuthor());
bookstore = null;
}
}
} catch (DocumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
2，生成xml文件
1.创建document对象，代表整个xml，使用DocumentHelper类的静态方法createDocument（）方法
2.生成根节点
3.添加属性值
4.添加子节点
5.为子节点添加内容
6.设置xml文件格式，创建OutputFormat format = OutputFormat.createPrettyPrint();方法
7.设置编码格式，通过format对象可以设置xml文件的属性
8，创建XMLWriter对象，通过writer对象将document对象转换成xml文件；
XMLWriter writer = new XMLWriter(new FileOutputStream(new File("rss.xml")),format);
9，writer.write（document）方法将document写入xml文件；
代码如下：
public void createXML(){
//1.创建document对象，代表整个xml
Document document = DocumentHelper.createDocument();
//2.生成根节点
Element rss = document.addElement("rss");
//3.添加属性值
rss.addAttribute("version", "2.0");
//4.添加子节点
Element channel = rss.addElement("channel");
//5.为子节点添加内容
channel.addText("国内最新新闻");
//6.设置xml文件格式
OutputFormat format = OutputFormat.createPrettyPrint();
//7.设置编码格式
format.setEncoding("GBK");
try {
XMLWriter writer = new XMLWriter(new FileOutputStream(new File("rss.xml")),format);
//处理转义字符，默认为true，开启转义
writer.setEscapeText(false);
writer.write(document);
writer.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
JDOM方法
参考代码如下：
package xxlong.test;
import org.jdom2.Attribute;
import org.jdom2.CDATA;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import javax.xml.transform.OutputKeys;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class JDOMTest {
/**
* 使用JDOM解析xml文件的步骤 * 1，创建SAXBuilder对象saxBuilder
* 2，通过saxBuilder的build方法得到Document对象document
* 3，获取根节点document.getRootElement()
* 4，获取根节点的所有子节点：rootElemet.getChildren()
* 5，获取子节点的所有属性,：element.getAttributes()
* 6，获取属性名和属性值
* 7，遍历所有子节点的子节点，获取属性名和属性值
* @param args
*/
public void parseXML() {
SAXBuilder saxBuilder = new SAXBuilder();
InputStream in;
ArrayList<Book> bookL= new ArrayList();
try {
in = new FileInputStream("book.xml");
Document document = saxBuilder.build(in);
Element rootElemet = document.getRootElement();
List<Element> bookList = rootElemet.getChildren();
for (Element element : bookList) {
Book bookstore = new Book();
System.out.println("开始解析第" + (bookList.indexOf(element)+1) + "本书");
List<Attribute> attrs = element.getAttributes();
for (Attribute attribute : attrs) {
if(attribute.getName().equals("id")) {
bookstore.setId(attribute.getValue());
}
System.out.println("属性名："+ attribute.getName() + "属性值:"
+ attribute.getValue());
List<Element> elem = element.getChildren();
for (Element element2 : elem) {
if(element2.getName().equals("author")) {
bookstore.setAuthor(element2.getValue());
}
if(element2.getName().equals("name")) {
bookstore.setName(element2.getValue());
}
if(element2.getName().equals("year")) {
bookstore.setYear(element2.getValue());
}
if(element2.getName().equals("price")) {
bookstore.setPrice(element2.getValue());
}
if(element2.getName().equals("language")) {
bookstore.setLanguage(element2.getValue());
}
System.out.println("属性名：" + element2.getName()
+ "属性值： " + element2.getValue());
}
}
bookL.add(bookstore);
System.out.println("作者：" + bookstore.getAuthor());
bookstore = null;
System.out.println("结束解析第" + (bookList.indexOf(element)+1) + "本书");
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (JDOMException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void createXML() {
Element rss = new Element("rss");
rss.setAttribute("version", "2.0");
Document document = new Document(rss);
Element channel = new Element("channel");
CDATA cdata = new CDATA("<hahhahha>");
channel.addContent(cdata);
rss.addContent(channel);
File file = new File("rss.xml");
//也可以生成
// if(!file.exists()) {
// try {
// file.createNewFile();
// } catch (IOException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// }
//
Format format = Format.getPrettyFormat();
format.setEncoding("gbk");
format.setIndent("");
XMLOutputter outputter = new XMLOutputter(format);
try {
outputter.output(document, new FileOutputStream(file));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) {
JDOMTest test = new JDOMTest();
test.createXML();
}
}
扫一扫
230
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
