XML的生成与解析详解-优快云博客

本文介绍了XML的基本概念，强调其作为数据存储语言的特点，并详细阐述了如何编写XML文件。接着，文章探讨了两种常见的XML文件生成方法——DOM生成，包括Java默认方式和第三方库如dom4j、jdom的使用。同时，详细解析了DOM和SAX两种解析方式的原理、优缺点，指出DOM解析需要加载整个文档，适合小型文件，而SAX解析基于事件模型，效率高，适合大型文件。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

生成和解析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”结尾

2、常见的XML文件的生成方式和解析方式

2.1 XML文件的生成【Dom生成】

1.java默认的dom生成方式

2.使用第三方开发包

A.dom4j

B.jdom

Person类：

package com.wangxinng.xmldemo.bean;

public class Person {

	private int perid;
	private String pername;
	private int perage;
	private String peraddress;
	public int getPerid() {
		return perid;
	}
	public void setPerid(int perid) {
		this.perid = perid;
	}
	public String getPername() {
		return pername;
	}
	public void setPername(String pername) {
		this.pername = pername;
	}
	public int getPerage() {
		return perage;
	}
	public void setPerage(int perage) {
		this.perage = perage;
	}
	public String getPeraddress() {
		return peraddress;
	}
	public void setPeraddress(String peraddress) {
		this.peraddress = peraddress;
	}
}

4中生成XML文件的方式：

package com.wangxing.xmldemo.helper;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.util.List;

import com.wangxinng.xmldemo.bean.Person;

public class XMLHelper {
	/**
	 * 1、默认的dom生成方式
	 */
	/*
	public static void createXMLByJavaDom(List<Person> personlist)throws Exception{
		//得到dom解析工厂
		DocumentBuilderFactory buildFactory=DocumentBuilderFactory.newInstance();
		//从解析工厂得到解析器
		DocumentBuilder documentBuilder=buildFactory.newDocumentBuilder();
		//得到document对象
		Document document=documentBuilder.newDocument();
		//设置文件头
		document.setXmlStandalone(true);
		//创建根元素
		Element rootElement=document.createElement("personlist");
		for (Person person : personlist) {
			//创建子元素
			Element personElement=document.createElement("person");
			//为子元素添加属性
			personElement.setAttribute("perid",String.valueOf(person.getPerid()));
			//创建子子元素
			Element nameElement=document.createElement("pername");
			//为子子元素添加数据值
			nameElement.setTextContent(person.getPername());
			//创建子子元素
			Element ageElement=document.createElement("perage");
			//为子子元素添加数据值
			ageElement.setTextContent(String.valueOf(person.getPerage()));
			//创建子子元素
			Element addressElement=document.createElement("peraddress");
			//为子子元素添加数据值
			addressElement.setTextContent(person.getPeraddress());
			
			//将子子元素添加到子元素
			personElement.appendChild(nameElement);
			personElement.appendChild(ageElement);
			personElement.appendChild(addressElement);
			//将子元素添加到根元素
			rootElement.appendChild(personElement);		
		}
		//将根元素添加到document对象
		document.appendChild(rootElement);
		//创建Transformer对象
		TransformerFactory tff=TransformerFactory.newInstance();
		//创建Transformer对象
		Transformer tf=tff.newTransformer();
		//输出内容是否换行
		tf.setOutputProperty(OutputKeys.INDENT,"yes");
		//创建XML文件并写入内容
		 tf.transform(new DOMSource(document), new StreamResult(new     
             File("person1.xml")));
	}
	*/
	/**
	 * 2、使用dom4j(第三方开发包)生成xml
	 */
	/*
	public static void creatXMLByDom4j(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.getPerid()));
			//创建子子元素
			Element nameElement=personElement.addElement("pername");
			//添加子子元素数据值
			nameElement.setText(person.getPername());
			//创建子子元素
			Element ageElement=personElement.addElement("perage");
			//添加子子元素数据值
			ageElement.setText(String.valueOf(person.getPerage()));
			//创建子子元素
			Element addressElement=personElement.addElement("peraddress");
			//添加子子元素数据值
			addressElement.setText(person.getPeraddress());
		}
		//设置生成xml格式
		OutputFormat format=OutputFormat.createPrettyPrint();
		//设置编码格式
		format.setEncoding("UTF-8");
		//创建xml字符输出流
		XMLWriter writer=new XMLWriter(new FileOutputStream(new 
              File("person2.xml")),format);
		//设置是否转义，默认使用转义字符
		writer.setEscapeText(false);
		//写出Document对象
		writer.write(document);
		//关闭流
		writer.close();
	}
	*/
	/**
	 * 3、使用jdom(第三方开发包)生成xml
	 */
	/*
	public static void creatXMLByJdom(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.getPerid()));
			//创建子子元素
			Element nameElement=new Element("pername");
			Element ageElement=new Element("perage");
			Element addressElement=new Element("peraddress");
			//子子元素赋值
			nameElement.setText(person.getPername());
			ageElement.setText(String.valueOf(person.getPerage()));
			addressElement.setText(person.getPeraddress());
			//将子子元素添加到 子元素
			personElement.addContent(nameElement);
			personElement.addContent(ageElement);
			personElement.addContent(addressElement);
			//将子元素添加到根
			rootElement.addContent(personElement);	
		}
		//依赖根元素创建Docuement
		Document document=new Document(rootElement);
		//输出Document对象
		Format format=Format.getCompactFormat();
		// 设置换行Tab或空格 format.setIndent("  ");
		format.setEncoding("UTF-8"); 
		// 创建XMLOutputter的对象 
		XMLOutputter outputer =new XMLOutputter(format); 
		//写出Document 
		outputer.output(document, new FileOutputStream(new File("person3.xml"))); 	
	}
	*/
	/**
	 * 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.getPerid() + 
                       "\">");
					stringBuilder.append("\r\n");
					stringBuilder.append("\t\t<pername>" + person.getPername() + " 
                       </pername>");
					stringBuilder.append("\r\n");
					stringBuilder.append("\t\t<perage>" + person.getPerage() + " 
                       </perage>");
					stringBuilder.append("\r\n");
					stringBuilder.append("\t\t<peraddress>" + person.getPeraddress() + " 
                       </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("personlist.xml");
				BufferedWriter out = new BufferedWriter(new FileWriter(file));
				out.write(xmlcontent);
				out.close();
	}
}

4中解析XML文件的方式：

package com.wangxing.xmldemo.util;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import com.wangxing.xmldemo1.util.MyDefaultHandler;
import com.wangxinng.xmldemo.bean.Person;
public class XMLUtil {
	/**
	 * 1.java默认的dom解析xml
	 */
	/*
	public static List<Person> parseXMLByDom()throws Exception{
		//定义保存对象的集合
		List<Person> personlist=new ArrayList<Person>();
		//得到解析器工厂
		DocumentBuilderFactory buildfactory=DocumentBuilderFactory.newInstance();
		//得到解析器对象
		DocumentBuilder documentBuilder=buildfactory.newDocumentBuilder();
		//将需要被解析的xml文件读成Document对象
		Document document=documentBuilder.parse(new File("person2.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.setPerid(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.setPername(name);
				}
				if(node.getNodeName().equals("perage")){
					int age=Integer.parseInt(node.getTextContent());
					person.setPerage(age);
				}
				if(node.getNodeName().equals("peraddress")){
					String address=node.getTextContent();
					person.setPeraddress(address);
				}
			}
			personlist.add(person);
		}
		return personlist;
	}
	*/
	/**
	 * 2.使用dom4j解析xml
	 */
	/*
	public static List<Person> parseXMLByDom4j()throws Exception {
		//定义保存对象的集合
		List<Person> personlist=new ArrayList<>();
		//创建xml解析对象
		SAXReader saxReader=new SAXReader();
		//通过解析器对象读取解析的xml文件一个Document
		Document document=saxReader.read(new File("person2.xml"));
		//得到根元素
		Element rootElement=document.getRootElement();
		//从根元素得到一组person的子元素
		List<Element> elementlist=rootElement.elements("person");
		for (Element personelement : elementlist) {
			Person person=new Person();
			//得到子元素的属性值
			int perid=Integer.valueOf(personelement.attributeValue("perid"));
			person.setPerid(perid);
			//得到子子元素的数据值
			String name=personelement.element("pername").getText();
			person.setPername(name);
			int age=Integer.parseInt(personelement.element("perage").getText());
			person.setPerage(age);
			String address=personelement.element("peraddress").getText();
			person.setPeraddress(address);
			//将子元素放入集合中
			personlist.add(person);
		}
		return personlist;
	}
	*/
	/**
	 * 3.使用jdom解析xml
	 */
	/*
	public static List<Person> parseXMLByJdom()throws Exception{
		//定义保存对象的集合
		List<Person> personlist=new ArrayList<>();
		//得到解析器对象
				SAXBuilder saxBuilder=new SAXBuilder();
				//读取被解析的xml文件成document
				Document  document=saxBuilder.build(new File("person2.xml"));
				//得到根元素
				Element  rootElement= document.getRootElement();
				//从根元素中得到一组person的子元素
				List<Element>  elementList=rootElement.getChildren("person");
				for(Element personElement:elementList){
					Person  person=new Person();
					//得到属性
					int perid=Integer.parseInt(personElement.getAttributeValue("perid"));
					person.setPerid(perid);
					String pername=personElement.getChild("pername").getText();
					person.setPername(pername);
					intperage=
                       Integer.parseInt(personElement.getChild("perage").getText());
					person.setPerage(perage);
					String peraddress=personElement.getChild("peraddress").getText();
					person.setPeraddress(peraddress);
					personlist.add(person);
				}
		return personlist;
	}	
	*/
	/**
	 * 4. 使用sax解析xml
	 */
	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("person2.xml"), myDefaultHandler);
		return  myDefaultHandler.getPersonList();
	}
}

使用sax第三方开发包解析XML文件所用的帮助类：

package com.wangxing.xmldemo1.util;

import java.util.ArrayList;
import java.util.List;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import com.wangxinng.xmldemo.bean.Person;
/**
 * sax解析类
 * @author Administrator
 *
 */
public class MyDefaultHandler extends DefaultHandler{
	  private  List<Person>  personList=null; //定义保存对象的集合
	  private  Person  person=null;
	  private  String tagName="";
	/**
	 * 文档开始的解析方法
	 */
	@Override
	public void startDocument() throws SAXException {
		personList=new  ArrayList<Person>();
	}
	/**
	 * 元素开始的解析方法
	 * String qNam--当前开始元素的名称
	 */
	@Override
	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		if(qName.equals("person")) {
			person=new Person();
			//得到属性值
			int perid=Integer.parseInt(attributes.getValue("perid"));
			person.setPerid(perid);
		}
		if(qName.equals("pername")){
			//保存当前开始元素名称
			tagName=qName;
		}
		if(qName.equals("perage")){
			//保存当前开始元素名称
			tagName=qName;
		}
		if(qName.equals("peraddress")){
			//保存当前开始元素名称
			tagName=qName;
		}
	}
	@Override
	public void endDocument() throws SAXException {
		// TODO Auto-generated method stub
		super.endDocument();
	}
	
	/**
	 * 文本元素对应的解析方法
	 */
	@Override
	public void characters(char[] ch, int start, int length) throws SAXException {
		String  value=new String(ch,start,length);
		if(tagName.equals("pername")){
			person.setPername(value);
		}
		if(tagName.equals("perage")){
			person.setPerage(Integer.valueOf(value));
		}
		if(tagName.equals("peraddress")){
			person.setPeraddress(value);
		}
	}
	/**
	 * 元素结束的解析方法
	 */
	@Override
	public void endElement(String uri, String localName, String qName) throws SAXException {
		if(qName.equals("person")){
			personList.add(person);
			person=null;
			tagName="";
		}else{
			tagName="";
		}
	}	
	public  List<Person> getPersonList(){
		return personList;
    }
}

主类---验证生成XML文件+解析XML文件：

package com.wangxing.xmldemo.test;
import java.util.ArrayList;
import java.util.List;
import com.wangxing.xmldemo.helper.XMLHelper;
import com.wangxing.xmldemo.util.XMLUtil;
import com.wangxinng.xmldemo.bean.Person;

public class Main {
	public static void main(String[] args) throws Exception {
		/*
		Person per1=new  Person();
			per1.setPerid(1001);
			per1.setPername("张三");
			per1.setPerage(23);
			per1.setPeraddress("西安");
			List<Person> personlist=new ArrayList<>();
			personlist.add(per1);
			XMLHelper.createXMLByJavaDom(personlist);	
		*/
		/*
		Person per2=new  Person();
		per2.setPerid(1002);
		per2.setPername("李四");
		per2.setPerage(24);
		per2.setPeraddress("上海");
		List<Person> personlist=new ArrayList<>();
		personlist.add(per2);
		XMLHelper.creatXMLByDom4j(personlist);
		*/
		/*
		Person per3=new  Person();
		per3.setPerid(1002);
		per3.setPername("王五");
		per3.setPerage(25);
		per3.setPeraddress("北京");
		List<Person> personlist=new ArrayList<>();
		personlist.add(per3);
		XMLHelper.creatXMLByJdom(personlist);
		*/	
		/*
		 * 1--默认dom解析
		List<Person> list=XMLUtil.parseXMLByDom();
		for (Person person : list) {
			System.out.println(person.getPerid()+"  "+person.getPername());
		}
		*/
		/**
		 * 2--使用dom4j解析xml
		 */
		/*
		List<Person> list2=XMLUtil.parseXMLByDom4j();
		for (Person person : list2) {
			System.out.println(person.getPerid()+"  "+person.getPername());
		}
		*/
		/**
		 * 3.使用jdom解析xml
		 */
		/*
		List<Person> list3=XMLUtil.parseXMLByJdom();
		for (Person person : list3) {
			System.out.println(person.getPerid()+"  "+person.getPername());
		}
		*/
		/**
		 * 4. 使用sax解析xml
		 */
		List<Person> list4=XMLUtil.parseXMLBySax();
		for (Person person : list4) {
			System.out.println(person.getPerid()+"  "+person.getPername());
		}
	}
}

3.XML文件解析方式的区别

DOM（Document Object Model)解析的原理就是需要被解析的xml文件，读取成一个文档树【Document 对象】，依据提供的开发类库和方法从文档树中得到根元素，再从根元素中得到子元素，从子元素中的到子子元素，再得到具体的数据值。

优点:结构清晰明了。

缺点:通常需要加载整个XML文档来构造层次结构，消耗资源大.

SAX（Simple API for XML)解析xml文件的原理是基于事件的模型，它在解析XML文档的时候可以触发一系列的事件，当发现给定的标签的时候，它可以激活一个回调方法，告诉该方法指定的标签已经找到，如果这个指定的标记中中有我们需要数据值就解析，没有就不用处理。

优点:1.只在读取数据时检查数据，不需要保存在内存中

2.可以在某个条件得到满足时停止解析，不必解析整个文档。

3.效率和性能较高，能解析大于系统内存的文档。

缺点:没有清晰的解析结构