生成和解析XML
1.什么是XML，XML的作用是什么，如何编写XML文件?
XML就是可扩展标记语言。与HTML相似都是标记语言。
XML提供的标记都是自定义的；HTML提供的标记都是预先定义好的。
XML用来存储数据的文本格式；HTML是同来设计网页。
XML是一种简单的数据存储语言。
如何编写XML文件?
一个简单的XML文件格式
<?xml version="1.0" encoding=”utf-8”?>
<students>
<student id=”1001” >
<name>zhangsan</name>
<age>23</age>
<sex>男</sex>
</student>
<student id=”1002”>
<name>lisi</name>
<age>24</age>
<sex>女</sex>
</student>
</students>说明:
<?xml version="1.0" encoding=”utf-8”?>---xml的文件头,表示xml文档开始。与html中的“<!DOCTYPE html>”作用相似。【土地】
<students></students>----自定义的xml标记，表示一个xml文件的根元素。【树根】
<student id=”1001” ></student>---自定义的xml标记，表示一个xml文件的根元素中的子元素。【树枝】
id=”1001”， id=”1002”----元素的属性，是一个键值对。
<name></name>，<age></age>，<sex></sex>---自定义的xml标记，表示一个xml文件的根元素中的子子元素。【树叶】
zhangsan，23，男...---都是被存储的具体数据值。【果实】
注意：1.标记都是自定义的，成对出现“<name></name>”
2.元素可以携带属性，属性是一个键值对，可以出现多个
例如：<小狗 id=”1001” color=”黑色”></小狗>
3.保存文件的时候，文件的后缀名是以“.xml”结尾
例如:
package com.wangxing.bean;
public class Person {
private int id;
private String name;
private int age;
private String address;
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 getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}package com.wangxing.XMLDemo.TestMain;
import java.util.ArrayList;
import java.util.List;
import com.wangxing.XMLDemo.Helper.XMLHelper;
import com.wangxing.XMLDemo.Util.XMLUtil;
import com.wangxing.bean.Person;
public class TestMain {
public static void main(String a[]) throws Exception{
Person per1=new Person();
per1.setId(1001);
per1.setName("zhangsan");
per1.setAge(23);
per1.setAddress("西安");
Person per2=new Person();
per2.setId(1002);
per2.setName("lisi");
per2.setAge(24);
per2.setAddress("北京");
List<Person> personlist=new ArrayList<Person>();
personlist.add(per1);
personlist.add(per2);
}
} 请将上面的personlist集合转换成xml文件？
<?xml version="1.0" encoding=”utf-8”?>
<personlist>
<person perid=”1001” >
<pername>张三</pername>
<perage>23</perage>
<peraddress>西安</peraddress>
</person>
<person perid=”1002” >
<pername>李四</pername>
<perage>24</perage>
<peraddress>北京</peraddress>
</person>
</personlist>2.常见的XML文件的生成方式和解析方式
2.1 XML文件的生成【Dom生成】
1.java默认的dom生成方式
package com.wangxing.XMLDemo.Helper;
import java.io.File;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
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 com.wangxing.bean.Person;
public class XMLHelper {
/**
* 1.java默认的dom生成方式
* @throws Exception
* @throws Exception
*/
public static void creatXMLByDom(List<Person> personlist) throws Exception{
//得到Dom解析器工厂
DocumentBuilderFactory builderFactory=DocumentBuilderFactory.newInstance();
//得到从解析工厂得到解析器
DocumentBuilder documentBuilder=builderFactory.newDocumentBuilder();
//得到Document对象
Document document=documentBuilder.newDocument();
//设置文件头
document.setXmlStandalone(true);
//创建根元素1.[Dom生成中创建元素使用createElement("元素名称");]
Element rootElement=document.createElement("personlist");
for(Person person:personlist){
//创建子元素
Element personElement=document.createElement("person");
//为子元素设置属性值2.[Dom生成中设置元素属性值使用setAttribute("属性名称","属性值");]
personElement.setAttribute("perid", String.valueOf(person.getId()));
//创建子子元素
Element pernameElement=document.createElement("pername");
Element perageElement=document.createElement("perage");
Element peraddressElement=document.createElement("peraddress");
//为子子元素设置数据值3.[Dom生成中设置元素数据值使用setTextContent("数据值");]
pernameElement.setTextContent(person.getName());
perageElement.setTextContent(String.valueOf(person.getAge()));
peraddressElement.setTextContent(person.getAddress());
//将子子元素添加到子元素中4.[Dom生成中将元素添加到另一元素中使用appendChild(Node[节点] node)]
personElement.appendChild(pernameElement);
personElement.appendChild(perageElement);
personElement.appendChild(peraddressElement);
//将子元素添加到根元素中
rootElement.appendChild(personElement);
}
//将根元素添加到Document对象中
document.appendChild(rootElement);
//创建TransformerFactory工厂对象
TransformerFactory tff=TransformerFactory.newInstance();
//创建Transformer对象
Transformer tf=tff.newTransformer();
//设置输出内容是否换行
tf.setOutputProperty(OutputKeys.INDENT,"yes");
//创建xml文件并写入内容
//Transform将xml文件转换为Resullt(Source[接口],Result[接口]);
//DOMSource 实现了Source接口 new DOMSource(Node[接口] node);
//Document 实现了Node[节点]接口
//StreamResult 实现了Result接口 new StreamResult(File file);
//new File(String string);
tf.transform(new DOMSource(document), new StreamResult(new File("person1.xml")));
}
}测试：
package com.wangxing.XMLDemo.TestMain;
import java.util.ArrayList;
import java.util.List;
import com.wangxing.XMLDemo.Helper.XMLHelper;
import com.wangxing.bean.Person;
public class TestMain {
public static void main(String a[]) throws Exception{
Person per1=new Person();
per1.setId(1001);
per1.setName("zhangsan");
per1.setAge(23);
per1.setAddress("西安");
Person per2=new Person();
per2.setId(1002);
per2.setName("lisi");
per2.setAge(24);
per2.setAddress("北京");
List<Person> personlist=new ArrayList<Person>();
personlist.add(per1);
personlist.add(per2);
XMLHelper.creatXMLByDom(personlist)；
}
}
2.使用第三方开发包
A.dom4j
package com.wangxing.XMLDemo.Helper;
import java.io.FileOutputStream;
import java.io.UnsupportedEncodingException;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
import com.wangxing.bean.Person;
public class XMLHelper {
/**
* 2.使用dom4j生成方式
* @throws Exception
* @throws UnsupportedEncodingException
*/
public static void createXMLByDom4j(List<Person> personlist) throws Exception{
//创建document对象
Document document=DocumentHelper.createDocument();
//创建根元素
Element rootElement=document.addElement("personlist");
for(Person person:personlist){
//创建子元素
Element personElement=rootElement.addElement("person");
//为子元素设置属性
personElement.addAttribute("perid", String.valueOf(person.getId()));
//创建子子元素
Element pernameElement=personElement.addElement("pername");
Element perageElement=personElement.addElement("perage");
Element peraddressElement=personElement.addElement("peraddress");
//为子子元素添加数据
pernameElement.setText(person.getName());
perageElement.setText(String.valueOf(person.getAge()));
peraddressElement.setText(person.getAddress());
}
//设置生成xml的格式
OutputFormat format=OutputFormat.createPrettyPrint();
//设置编码格式
format.setEncoding("UTF-8");
//创建XML字符输出流
XMLWriter writer=new XMLWriter(new FileOutputStream("person2.xml"),format);
//设置是否转义，默认使用转义字符
writer.setEscapeText(false);
//写出DOcument对象
writer.write(document);
}
}测试：
package com.wangxing.XMLDemo.TestMain;
import java.util.ArrayList;
import java.util.List;
import com.wangxing.XMLDemo.Helper.XMLHelper;
import com.wangxing.bean.Person;
public class TestMain {
public static void main(String a[]) throws Exception{
Person per1=new Person();
per1.setId(1001);
per1.setName("zhangsan");
per1.setAge(23);
per1.setAddress("西安");
Person per2=new Person();
per2.setId(1002);
per2.setName("lisi");
per2.setAge(24);
per2.setAddress("北京");
List<Person> personlist=new ArrayList<Person>();
personlist.add(per1);
personlist.add(per2);
XMLHelper.createXMLByDom4j(personlist);
}
}
B.jdom
package com.wangxing.XMLDemo.Helper;
import java.io.File;
import java.io.FileOutputStream;
import java.util.List;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;
import com.wangxing.bean.Person;
public class XMLHelper {
/**
* 3.使用jdom生成方式
*/
public static void createXMLByJdom(List<Person> personlist)throws Exception{
//创建根元素
Element rootElement=new Element("personlist");
for(Person person:personlist){
//创建子元素
Element personElement=new Element("person");
//为子元素设置属性值
personElement.setAttribute("perid",String.valueOf(person.getId()));
//创建子子元素
Element nameElement=new Element("pername");
Element ageElement=new Element("perage");
Element addressElement=new Element("peraddress");
//为子子元素设置数据
nameElement.setText(person.getName());
ageElement.setText(String.valueOf(person.getId()));
addressElement.setText(person.getAddress());
//将子子元素添加到子元素
personElement.addContent(nameElement);
personElement.addContent(ageElement);
personElement.addContent(addressElement);
//将子元素添加到根元素里
rootElement.addContent(personElement);
}
//依赖根元素创建Document对象
Document document=new Document(rootElement);
//输出Document
Format format=Format.getCompactFormat();
//设置换行Tab或空格
format.setIndent(" ");
format.setEncoding("UTF-8");
//创建XMLOutputter对象
XMLOutputter output=new XMLOutputter(format);
output.output(document,new FileOutputStream(new File("person3.xml")));
}
}测试：
package com.wangxing.XMLDemo.TestMain;
import java.util.ArrayList;
import java.util.List;
import com.wangxing.XMLDemo.Helper.XMLHelper;
import com.wangxing.bean.Person;
public class TestMain {
public static void main(String a[]) throws Exception{
Person per1=new Person();
per1.setId(1001);
per1.setName("zhangsan");
per1.setAge(23);
per1.setAddress("西安");
Person per2=new Person();
per2.setId(1002);
per2.setName("lisi");
per2.setAge(24);
per2.setAddress("北京");
List<Person> personlist=new ArrayList<Person>();
personlist.add(per1);
personlist.add(per2);
XMLHelper.createXMLByJdom(personlist);
}
}
3.使用字符串拼接的方式创建XML
package com.wangxing.XMLDemo.Helper;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.util.List;
import com.wangxing.bean.Person;
public class XMLHelper {
/**
* 4.拼接字符串的方式
*/
public static void creatXMLByString(List<Person> personlist)throws Exception{
//定义一个保存拼接好的字符串变量
String xmlcontent=null;
//为了拼接字符串更加方便我们使用StringBuilder类拼接字符串
StringBuilder Stringbuilder=new StringBuilder();
Stringbuilder.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
Stringbuilder.append("\r\n");
Stringbuilder.append("<personlist>");
Stringbuilder.append("\r\n");
//便利需要被生成成xml文件的集和
for(Person person:personlist){
Stringbuilder.append("\t<person perid=\""+person.getId()+"\">");
Stringbuilder.append("\r\n");
Stringbuilder.append("\t\t<pername>"+person.getName()+"</pername>");
Stringbuilder.append("\r\n");
Stringbuilder.append("\t\t<perage>"+person.getAge()+"</perage>");
Stringbuilder.append("\r\n");
Stringbuilder.append("\t\t<peraddress>"+person.getAddress()+"</peraddress>");
Stringbuilder.append("\r\n");
Stringbuilder.append("\t</person>");
Stringbuilder.append("\r\n");
}
Stringbuilder.append("</personlist>");
xmlcontent=Stringbuilder.toString();
System.out.println(xmlcontent);
//创建输出流对象，将创建好的xml，保存到文件中
File file=new File("person4.xml");
BufferedWriter out=new BufferedWriter(new FileWriter(file));
out.write(xmlcontent);
out.close();
}
}测试:
package com.wangxing.XMLDemo.TestMain;
import java.util.ArrayList;
import java.util.List;
import com.wangxing.XMLDemo.Helper.XMLHelper;
import com.wangxing.bean.Person;
public class TestMain {
public static void main(String a[]) throws Exception{
Person per1=new Person();
per1.setId(1001);
per1.setName("zhangsan");
per1.setAge(23);
per1.setAddress("西安");
Person per2=new Person();
per2.setId(1002);
per2.setName("lisi");
per2.setAge(24);
per2.setAddress("北京");
List<Person> personlist=new ArrayList<Person>();
personlist.add(per1);
personlist.add(per2);
XMLHelper.creatXMLByString(personlist);
}
}
2.2 XML文件的解析
实际上就是将xml文件中保存的数据取出，转换成java对象
1.DOM（Document Object Model)解析
Java默认的Dom / dom4j / jdom
package com.wangxing.XMLDemo.Util;
import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import com.wangxing.bean.Person;
public class XMLUtil {
/**
* 1.java默认的Dom解析xml
*/
public static List<Person> parseXMLByDom()throws Exception{
//定义保存对象的集和
List<Person> personlist=new ArrayList<Person>();
//得到解析工厂
DocumentBuilderFactory builderFactory=DocumentBuilderFactory.newInstance();
//从解析工厂得到解析器
DocumentBuilder builder=builderFactory.newDocumentBuilder();
//将需要被解析的xml文件读取成Document对象
Document document=builder.parse("person1.xml");
//从Document对象中取出一组子元素
NodeList personNodeList=document.getElementsByTagName("person");
for(int i=0;i<personNodeList.getLength();i++){
Person person=new Person();
Node personNode=personNodeList.item(i);
//得到属性值
String id=personNode.getAttributes().item(0).getNodeValue();
person.setId(Integer.parseInt(id));
//从子元素中得到包含有子子元素的一组集和
NodeList nodeList=personNode.getChildNodes();
for(int j=0;j<nodeList.getLength();j++){
//得到子子元素
Node node=nodeList.item(j);
if(node.getNodeName().equals("pername")){
String name=node.getTextContent();
person.setName(name);
}
if(node.getNodeName().equals("perage")){
String age=node.getTextContent();
person.setAge(Integer.parseInt(age));
}
if(node.getNodeName().equals("peraddress")){
String address=node.getTextContent();
person.setAddress(address);
}
}
personlist.add(person);
}
return personlist;
}
}测试：
package com.wangxing.XMLDemo.TestMain;
import java.util.ArrayList;
import java.util.List;
import com.wangxing.XMLDemo.Util.XMLUtil;
import com.wangxing.bean.Person;
public class TestMain {
public static void main(String a[]) throws Exception{
Person per1=new Person();
per1.setId(1001);
per1.setName("zhangsan");
per1.setAge(23);
per1.setAddress("西安");
Person per2=new Person();
per2.setId(1002);
per2.setName("lisi");
per2.setAge(24);
per2.setAddress("北京");
List<Person> personlist=new ArrayList<Person>();
personlist.add(per1);
personlist.add(per2);
List<Person> personList=XMLUtil.parseXMLByDom();
for(Person person:personList){
System.out.println(person.getId()+"\r\n"+person.getName()+"\r\n"+person.getAge()+"\r\n"+person.getAddress());
}
}
}2.dom4j解析xml
package com.wangxing.XMLDemo.Util;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import com.wangxing.bean.Person;
public class XMLUtil {
/**
* 2.使用dom4j解析xml
*/
public static List<Person> parseXMLByDom4j()throws Exception{
//定义保存对象的集和
List<Person> personlist=new ArrayList<Person>();
//创建xml解析器对象
SAXReader saxReader=new SAXReader();
//通过解析器对象读取被解析的xml文件为document对象
Document document=saxReader.read(new File("person1.xml"));
//得到根元素
Element rootElement=document.getRootElement();
//从根元素中得到一组person子元素
List<Element> elementlist=rootElement.elements("person");
for(Element personelement:elementlist){
Person person=new Person();
//得到子元素的属性值
person.setId(Integer.parseInt(personelement.attributeValue("perid")));
//得到子子元素的数据值
String pername=personelement.element("pername").getText();
person.setName(pername);
String perage=personelement.elementText("perage");
person.setAge(Integer.parseInt(perage));
String peraddress=personelement.element("peraddress").getText();
person.setAddress(peraddress);
personlist.add(person);
}
return personlist;
}
}测试：
package com.wangxing.XMLDemo.TestMain;
import java.util.ArrayList;
import java.util.List;
import com.wangxing.bean.Person;
public class TestMain {
public static void main(String a[]) throws Exception{
Person per1=new Person();
per1.setId(1001);
per1.setName("zhangsan");
per1.setAge(23);
per1.setAddress("西安");
Person per2=new Person();
per2.setId(1002);
per2.setName("lisi");
per2.setAge(24);
per2.setAddress("北京");
List<Person> personlist=new ArrayList<Person>();
personlist.add(per1);
personlist.add(per2);
for(Person person:XMLUtil.parseXMLByDom4j()){
System.out.println(person.getId()+"\r\n"+person.getName()+"\r\n"+person.getAge()+"\r\n"+person.getAddress());
}
}
}3.jdom解析xml
package com.wangxing.XMLDemo.Util;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
import com.wangxing.bean.Person;
public class XMLUtil {
/**
*3.使用jdom解析xml
*/
public static List<Person> parseXMLByJdom()throws Exception{
//创建保存对象的集和
List<Person> personlist=new ArrayList<Person>();
//得到解析器对象
SAXBuilder saxBuilder=new SAXBuilder();
//读取被解析的xml文件成Document
Document document=saxBuilder.build(new File("person1.xml"));
//得到根元素
Element rootElement=document.getRootElement();
//从根元素中得到一组person的子元素
List<Element> elementList=rootElement.getChildren("person");
for(Element PersonElement:elementList){
Person person=new Person();
//得到子元素的属性
person.setId(Integer.parseInt(PersonElement.getAttributeValue("perid")));
//得到子子元素的数据值
person.setName(PersonElement.getChildText("pername"));
person.setAge(Integer.parseInt(PersonElement.getChildText("perage")));
person.setAddress(PersonElement.getChildText("peraddress"));
personlist.add(person);
}
return personlist;
}
}测试：
package com.wangxing.XMLDemo.TestMain;
import java.util.ArrayList;
import java.util.List;
import com.wangxing.bean.Person;
public class TestMain {
public static void main(String a[]) throws Exception{
Person per1=new Person();
per1.setId(1001);
per1.setName("zhangsan");
per1.setAge(23);
per1.setAddress("西安");
Person per2=new Person();
per2.setId(1002);
per2.setName("lisi");
per2.setAge(24);
per2.setAddress("北京");
List<Person> personlist=new ArrayList<Person>();
personlist.add(per1);
personlist.add(per2);
for(Person person:XMLUtil.parseXMLByJdom()){
System.out.println(person.getId()+"\r\n"+person.getName()+"\r\n"+person.getAge()+"\r\n"+person.getAddress());
}
}
}4.sax解析xml
package com.wangxing.XMLDemo.Util;
import java.io.File;
import java.util.List;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import com.wangxing.bean.Person;
public class XMLUtil {
/**
* 4.使用sax解析方式
*/
public static List<Person> parseXMLBySax()throws Exception{
//定义保存对象的集和
//List<Person> personlist=new ArrayList<Person>();
//得到SAX解析工厂
SAXParserFactory saxfac=SAXParserFactory.newInstance();
//从工厂中得到解析器对象
SAXParser saxParser=saxfac.newSAXParser();
MyDefaultHandler myDefaultHandler=new MyDefaultHandler();
saxParser.parse(new File("person4.xml"), myDefaultHandler);
return myDefaultHandler.getPersonList();
}
}
测试：
package com.wangxing.XMLDemo.TestMain;
import java.util.ArrayList;
import java.util.List;
import com.wangxing.bean.Person;
public class TestMain {
public static void main(String a[]) throws Exception{
Person per1=new Person();
per1.setId(1001);
per1.setName("zhangsan");
per1.setAge(23);
per1.setAddress("西安");
Person per2=new Person();
per2.setId(1002);
per2.setName("lisi");
per2.setAge(24);
per2.setAddress("北京");
List<Person> personlist=new ArrayList<Person>();
personlist.add(per1);
personlist.add(per2);
for(Person person:XMLUtil.parseXMLBySax()){
System.out.println(person.getId()+"\r\n"+person.getName()+"\r\n"+person.getAge()+"\r\n"+person.getAddress());
}
}
}SAX（Simple API for XML)解析xml文件的原理是基于事件的模型，它在解析XML文档的时候可以触发一系列的事件，当发现 给定的标签的时候，它可以激活一个回调方法，告诉该方法指定的标签已经找到，如果这个指定的标记中中有我们需要数据值就解析，没有就不用处理。
优点:1.只在读取数据时检查数据，不需要保存在内存中
2.可以在某个条件得到满足时停止解析，不必解析整个文档。
3.效率和性能较高，能解析大于系统内存的文档。
缺点:没有清晰的解析结构
3.XML文件解析方式的区别
DOM（Document Object Model)解析的原理就是需要被解析的xml文件，读取成一个文档树【Document 对象】，依据提供的开发类库和方法从文档树中得到根元素，再从根元素中得到子元素，从子元素中的到子子元素，再得到具体的数据值。
优点:结构清晰明了。
缺点:通常需要加载整个XML文档来构造层次结构，消耗资源大.
SAX（Simple API for XML)解析xml文件的原理是基于事件的模型，它在解析XML文档的时候可以触发一系列的事件，当发现给定的标签的时候，它可以激活一个回调方法，告诉该方法指定的标签已经找到，如果这个指定的标记中中有我们需要数据值就解析，没有就不用处理。
优点:1.只在读取数据时检查数据，不需要保存在内存中
2.可以在某个条件得到满足时停止解析，不必解析整个文档。
3.效率和性能较高，能解析大于系统内存的文档。
缺点:没有清晰的解析结构