JAVA生成XML

DOM方式：

package DomTest;

import java.io.File;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

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.xml.sax.SAXException;

public class DOMTest {

/***
* 生成XML
*/
public void creatXML(){
DocumentBuilder db=getDocumentBuilder();
Document document=db.newDocument();

document.setXmlStandalone(true);//设置XML的standalone属性
//创建根节点
Element bookstore= document.createElement("bookStore");
//添加子节点book
Element book=document.createElement("book");
//添加子节点name
Element name=document.createElement("name");
book.appendChild(name);
//添加子节点内容
name.setTextContent("人猿泰山");

book.setAttribute("id", "1");
//将book子节点添加到bookstore中
bookstore.appendChild(book);
//将bookstore节点（已包含book）添加到dom数中
document.appendChild(bookstore);

//
TransformerFactory tff=TransformerFactory.newInstance();
try {
Transformer tf=tff.newTransformer();

//让DOM树输出过程中正常换行
tf.setOutputProperty(OutputKeys.INDENT, "yes");
tf.transform(new DOMSource(document), new StreamResult(new File("books1.xml")));
} catch (TransformerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public static DocumentBuilder getDocumentBuilder(){
// 创建一个DocumentBuilderFactory对象
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
// 创建DocumentBuilder对象
DocumentBuilder db=null;
try {
db = dbf.newDocumentBuilder();
} catch (ParserConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

return db;
}

public static void main(String[] args) {

// 创建一个DocumentBuilder的对象
try {

// 通过DocumentBuilder对象的parse方法加载books.xml文件
// 到当前项目下
Document document = getDocumentBuilder().parse("books.xml");
// 获取所有book节点的集合
NodeList bookList = document.getElementsByTagName("book");
//通过nodeList的getLength（）方法获取bookLIst的长度
System.out.println("一共有："+bookList.getLength()+"本书");
//便利各个book节点
for (int i = 0; i < bookList.getLength(); i++) {
System.out.println("++++++++++++开始遍历第"+(i+1)+"本书+++++++++++");
//方式一，不知道有多少节点，通过循环来遍历所有节点。

//通过 item(i)获取一个book节点，nodeList
Node book=bookList.item(i);
//获取book的属性的集合
NamedNodeMap attrs=book.getAttributes();
System.out.println("第"+(i+1)+"本书共有"+attrs.getLength()+"个属性");
//便利book的属性
for (int j = 0; j < attrs.getLength(); j++) {
//通过item（）方法获取book节点的某一个属性
Node attr=attrs.item(j);
//获取属性名
System.out.println("属性名："+attr.getNodeName());
//获取属性值
System.out.println("属性值："+attr.getNodeValue());
}

//              //方式二，知道有且只有一个节点。并且知道属性的名称为“id”
//              //强制类型转换将book节点类型转换为Element类型
//              Element book =(Element) bookList.item(i);
//
//              //通过getAttribute（“id”）方法获取到属性的值
//              String attrValue=book.getAttribute("id");
//              System.out.println("id的属性的属性值为"+attrValue);

//解析book节点的子节点,需要用到方式一中创建的book对象
//获取子节点的集合
NodeList childNodes=book.getChildNodes();

//遍历childNodes获取每个子节点的节点名和节点值
System.out.println("第"+(i+1)+"本书共有"+childNodes.getLength()+"个子节点");
//循环遍历
for (int j = 0; j < childNodes.getLength(); j++) {
//区分text类型的node和element类型的node
if(childNodes.item(j).getNodeType()==Node.ELEMENT_NODE){
//输出了element类型节点的节点名
System.out.println("第"+(j+1)+"个节点名："+childNodes.item(j).getNodeName());
//输出element类型节点的节点值
//需先获取当前节点的首个子节点，否则获取的是《name》标签的值NULL

//方式一：如果<name>节点下有多个子节点，此方法只输出确定的某个子节点的值
//同样要注意，<name>节点的第一个子节点的值是第一子节点的类型的值，还是NULL
System.out.println("节点值为："+childNodes.item(j).getFirstChild()
.getNodeValue());
//方式二：如果<name>节点下有多个子节点，此方法输出所有子节点的text
System.out.println(childNodes.item(j).getTextContent());
}

}

System.out.println("++++++++++++结束遍历第"+(i+1)+"本书++++++++++++");
}

} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}

DOMTest test=new DOMTest();
test.creatXML();
}
}

SAX方式：

使用SAX解析时创建的SAXParserHandler.java

package test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;

import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl;

import test2.SAXParserHandler;
import test3.Book;

public class SAXTest {

public ArrayList<Book> parseXML(){
// 通过SAXParseFactory的静态newInstance（）
//方法获取SAXParseFactory实例factory
SAXParserFactory factory=SAXParserFactory.newInstance();
SAXParserHandler handler=null;
//通过SAXParserFactory实例的newSAXParser（）
//方法返回SAXParse实例parser
try {
SAXParser parser= factory.newSAXParser();
//创建SAXParserHandler对象
handler=new SAXParserHandler();
parser.parse("books.xml", handler);
System.out.println("书的数量："+handler.getBookList().size());
for(Book book: handler.getBookList()){
System.out.println(book.getId());
System.out.println(book.getName());
System.out.println(book.getAuthor());
System.out.println(book.getPrice());
System.out.println(book.getYear());
System.out.println("-------------");
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ParserConfigurationException | SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

return handler.getBookList();
}

public void createXML(){
ArrayList<Book> bookList=parseXML();
//生成XML
//1、创建一个TransformFacroty对象
SAXTransformerFactory tff=(SAXTransformerFactory)
SAXTransformerFactory.newInstance();
try {
//2、通过SAXTransformerFactory对象创建一个TransformerHandler对象
TransformerHandler handler=tff.newTransformerHandler();
//3、通过handler对象创建一个Transformer对象
Transformer tr=handler.getTransformer();
//4、通过Transformer对象对生成的XML文件进行设置
//设置XML编码
tr.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
//设置换行
tr.setOutputProperty(OutputKeys.INDENT, "yes");
//5、创建一个Result对象
File f=new File("src/newbooks.xml");
if(!f.exists()){
f.createNewFile();
}
Result result=new StreamResult(new FileOutputStream(f));
//6、创建result对象并使其与handler关联
handler.setResult(result);
//7、使用handler对象进行XML文件的编写
//打开document
handler.startDocument();
AttributesImpl attr=new AttributesImpl();
//开始标签
handler.startElement("", "", "bookstore", attr);

for(Book book:bookList){
attr.clear();
attr.addAttribute("", "", "id", "", book.getId());
handler.startElement("", "", "book", attr);
attr.clear();
//创建name节点
handler.startElement("", "", "name", attr);
handler.characters(book.getName().toCharArray(),
0, book.getName().length());
handler.endElement("", "", "name");
//创建author节点
attr.clear();
handler.startElement("", "", "author", attr);
handler.characters(book.getAuthor().toCharArray(),
0, book.getAuthor().length());
handler.endElement("", "", "author");
//创建price节点
attr.clear();
handler.startElement("", "", "price", attr);
handler.characters(book.getPrice().toCharArray(),
0, book.getPrice().length());
handler.endElement("", "", "price");
//创建year节点
//判断当有此节点时才进行创建操作
if(book.getYear()!=null&&!book.getYear().trim().equals("")){

attr.clear();
handler.startElement("", "", "year", attr);
handler.characters(book.getYear().toCharArray(),
0, book.getYear().length());
handler.endElement("", "", "year");
}

handler.endElement("", "", "book");
}

//结束标签
handler.endElement("", "", "bookstore");
//关闭document
handler.endDocument();

} catch (TransformerConfigurationException | IOException | SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) {
SAXTest test=new SAXTest();
test.createXML();
}
}

DOM4J方式：

RSS就是一个特殊格式的XML

package Dom4jTest;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Iterator;
import java.util.List;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

public class DOM4JTest {

public static void main(String[] args) {
new DOM4JTest().createXML();
}

public void parseXML() {

// TODO Auto-generated method stub
// 创建SAXReader对象
SAXReader reader = new SAXReader();
// 通过reader对象read 方法加载book.xml
try {
Document document = reader.read(new File("src/res/books.xml"));
// 通过document对象获取根节点bookstore
Element bookStore = document.getRootElement();
// 通过element对象的elementIterator方法获取迭代器
Iterator it = bookStore.elementIterator();
// 遍历迭代器，获取根节点中的信息
while (it.hasNext()) {
System.out.println("开始遍历一本书");
Element book = (Element) it.next();
// 获取book的属性名和属性值
List<Attribute> bookAttrs = book.attributes();
for (Attribute attr : bookAttrs) {
System.out.println("属性名：" + attr.getName() + "\t属性值：" + attr.getValue());
}

Iterator itt = book.elementIterator();
while (itt.hasNext()) {
Element bookChild = (Element) itt.next();
System.out.println("节点名：" + bookChild.getName() + "\t节点值：" + bookChild.getStringValue());
}

System.out.println("结束遍历一本书" + "\n");
}
} catch (DocumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public void createXML(){
//1、创建Document对象，代表整个XML
Document document=DocumentHelper.createDocument();
//2、创建根节点
Element rss=document.addElement("rss");
//3、向rss节点中添加version属性
rss.addAttribute("version", "2.0");
//4、生成子节点及内容
Element channel=rss.addElement("channel");
Element title=channel.addElement("title");
title.setText("新闻资讯");
//设置换行
OutputFormat format=OutputFormat.createPrettyPrint();
format.setEncoding("UTF-8");
//5、生成XML文件
File file=new File("rssnews.xml");
XMLWriter writer;
try {
writer = new XMLWriter(new FileOutputStream(file),format);
//设置是否转义，默认是true进行转义
writer.setEscapeText(false);
writer.write(document);
writer.close();
} catch (UnsupportedEncodingException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (FileNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

JDOM方式：

package test;

import java.util.ArrayList;
import java.util.List;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import org.jdom2.Attribute;
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 test3.Book;

public class JDOMTest {
private static ArrayList<Book> booksList = new ArrayList<Book>();

public static void main(String[] args) {
new JDOMTest().createXML();
}

public void parserXML() {
// JDOM解析XML文件
// 创建一个SAXBuilder对象
SAXBuilder saxbuilder = new SAXBuilder();

InputStream in;
try {
// 创建一个输入流，将xml文件加载到流中
in = new FileInputStream("src/res/books.xml");
// InputStreamReader ins=new InputStreamReader(in,"UTF-8");
// 通过saxbuilder的build方法将输入流加载到saxbuilder中
Document document = saxbuilder.build(in);

// 通过document对象获取xml文件的根节点
Element rootElement = document.getRootElement();

// 获取根节点下的子节点的集合
List<Element> bookList = rootElement.getChildren();

// 使用foreach循环解析

for (Element book : bookList) {
Book bookEntity = new Book();
System.out.println("开始解析第" + (bookList.indexOf(book) + 1) + "本书============");

// 解析book的属性
List<Attribute> attrList = book.getAttributes();

// //知道节点属性名
// book.getAttribute("id");

// 针对不清楚book节点下属性名和数量的情况
// 遍历attrList
for (Attribute attr : attrList) {
// 获取属性名和属性值
String attrName = attr.getName();
String attrValue = attr.getValue();
System.out.println("属性名：" + attrName + "\t属性值：" + attrValue);
// 存储book节点
if (attrName.equals("id")) {
bookEntity.setId(attrValue);
}
}

// 对book节点的子节点的节点名和节点值进行遍历
List<Element> bookChilds = book.getChildren();
for (Element child : bookChilds) {
System.out.println("节点名：" + child.getName() + "\t节点值：" + child.getValue());

// 存储子节点名
if (child.getName().equals("name")) {
bookEntity.setName(child.getValue());
} else if (child.getName().equals("author")) {
bookEntity.setAuthor(child.getValue());
} else if (child.getName().equals("year")) {
bookEntity.setYear(child.getValue());
} else if (child.getName().equals("price")) {
bookEntity.setPrice(child.getValue());
}
}

System.out.println("结束解析第" + (bookList.indexOf(book) + 1) + "本书============");
// 添加booksList集合对象
booksList.add(bookEntity);
bookEntity = null;
System.out.println(booksList.size());
System.out.println(booksList.get(0).getId());
System.out.println(booksList.get(0).getName());
}

} catch (FileNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (JDOMException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public void createXML(){
//1、生成一个根节点
Element rss=new Element("rss");
rss.setAttribute("version","2.0");//添加节点属性
//2、生成一个document对象
Document document=new Document(rss);

Element channel=new Element("channel");
rss.addContent(channel);
Element title=new Element("title");
title.setText("ceshiceshi测试");
channel.addContent(title);

Format format=Format.getCompactFormat();
format.setIndent("");
format.setEncoding("GBK");

//创建XMLOutputter对象
XMLOutputter outputer=new XMLOutputter(format);
try {
outputer.output(document, new FileOutputStream(new File("rssnews")));

} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}

生成方式对比

DOM 基于树结构，始终在内存中，方便增删改操作

SAX基于事件

JDOM 基于底层API

DOM4J基于底层API