XML的生成和解析

一、什么是XML

XML就是可扩展标记语言，HTML是超文本标记语言
标记语言就是通过一个一个的标记来组织数据的一种语法格式
与HTMl超文本语言比较的话XML这种可扩展语言它的标记是自己定义的
XML中自己定义的标记表示：
例如：<标记名称  属性1=“属性值”  属性2=“属性值”·····> 具体数据 </标记结束>
<标记名称>–开始标记
<标记名称 属性1=“属性值”属性2=“属性值”….>–开始标记
 </标记名称>–结束标记

二、XML的作用是什么

 存储数据的一种语法格式
它还可以是一种数据包交换格式

三、如何编写XML文件 

我们现在需要将一个java对象组织成一个xml格式的数据，我们来开一下具体的做法。
public   class   Student{
        private  int  stuid;
        private  String  stuname;
        private  int   stuage;
        private  String  stuaddress;
        “““`
        getXXX()/setXXX()
}
Student student=new  Student();
student.setStuid(1001);
student.setStuname(“zhangsan”);
student.setStuage(23);
student.setStuaddress(“西安”);
XML类型的数据/文件【student.xml】
<?xml  version=”1.0″  encoding=”utf-8″?>
<students>——xml的根元素【必不可少】
        <student  stuid=”1001″>—–xml的子元素，stuid=”1001″就是当前子元素的一个属性
                <stuname>zhangsan</stuname>–XML的子子【孙子】元素，zhangsan具体数值
                <stuage>23</stuage>-xml的子子【孙子】元素,23具体数据值
            <stuaddress>西安</stuaddress>-xml的子子【孙子】元素,西安具体数据值                
        </student>
</students>
注意:1.<?xml version=”1.0″  encoding=”utf-8″?>不能少
         2.根元素只有一个，必不可少
         3.具体的数据值都是由于子元素/子子【孙子】元素保存。
         4.如果是一个文件,那么文件的后缀名使用“.xml”
我们现在需要将一个保存有java对象的集合/数组组织成一个xml格式的数据，我们来看一下具体的做法。
public  class  Student{
        private  int  stuid;
        private  String  stuname;
        private  int  stuage;
        private  String  stuaddress;
        …..
        getXXX()/setXXX()
    
    }
    Student  student1=new Student();
    student1.setStuid(1001);
    student1.setStuname(“zhangsan”);
    student1.setStuage(23);
    student1.setStuaddress(“西安”);
    Student  student2=new Student();
    student2.setStuid(1002);
    student2.setStuname(“lisi”);
    student2.setStuage(24);
    student2.setStuaddress(“北京”);
    Student  student3=new Student();
    student3.setStuid(1003);
    student3.setStuname(“wangwu”);
    student3.setStuage(25);
    student3.setStuaddress(“上海”);
    List<Student>  studentlist=new ArrayList<Student>();
    studentlist.add(student1);
    studentlist.add(student2);
    studentlist.add(student3);
将上面的 studentlist 组织成xml数据/文件【student.xml】
<?xml version=”1.0″  encoding=”utf-8″?>
    <studentlist>
        <student stuid=”1001″>
            <stuname>zhangsan</stuname>
            <stuage>23</stuage>
            <stuaddress>西安</stuaddress>
        </student>
        <student stuid=”1002″>
            <stuname>lisi</stuname>
            <stuage>24</stuage>
            <stuaddress>北京</stuaddress>
        </student>
        <student stuid=”1003″>
            <stuname>wangwu</stuname>
            <stuage>25</stuage>
            <stuaddress>上海</stuaddress>
        </student>
    </studentlist>
注意:1.标记都是自己定义，没有固定的具体标记
         2.子元素、子子元素是可以有多个的。

四、XML文件的生成

1.Dom生成
        1.1java默认的dom生成方式【jdk提供的java类】
例如：
创建student类从而创建student的xml文件

package com.wangxing.test1;

public class Student {
	private int stuid;
	private String stuname;
	private int stuage;
	private String stuaddress;
	public int getStuid() {
		return stuid;
	}
	public void setStuid(int stuid) {
		this.stuid = stuid;
	}
	public String getStuname() {
		return stuname;
	}
	public void setStuname(String stuname) {
		this.stuname = stuname;
	}
	public int getStuage() {
		return stuage;
	}
	public void setStuage(int stuage) {
		this.stuage = stuage;
	}
	public String getStuaddress() {
		return stuaddress;
	}
	public void setStuaddress(String stuaddress) {
		this.stuaddress = stuaddress;
	}	
}

创建一个类里面有得到xml文件方法

package com.wangxing.test1;

import java.io.File;
import java.util.ArrayList;

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;

public class xmlHelper {
	/**
	 * 1.java默认的dom生成方式【jdk提供的java类】
	 */
	public static void createXml1(ArrayList<Student> stulist) throws Exception{
		//得到DOM解析器工厂
		DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
		//创建DocumentBuilder对象
		DocumentBuilder documentBuilder=factory.newDocumentBuilder();
		//创建Document对象
		Document document=documentBuilder.newDocument();
		//设置文档对象的文件头
		document.setXmlStandalone(true);
		//创建根元素
		Element rootElment=document.createElement("studentlist");
		//遍历集合
		for(Student student:stulist){
			//创建子元素
			Element studentElement=document.createElement("student");
			//给子元素设置属性
			studentElement.setAttribute("stuid",String.valueOf(student.getStuid()));
			//创建子子元素
			Element stunameElement=document.createElement("stuname");
			//为子子元素设置具体数值
			stunameElement.setTextContent(student.getStuname());
			//创建子子元素
			Element stuageElement=document.createElement("stuage");
			//为子子元素设置具体数值
			stuageElement.setTextContent(String.valueOf(student.getStuage()));
			//创建子子元素
			Element stuaddressElement=document.createElement("stuaddress");
			//为子子元素设置具体数值
			stuaddressElement.setTextContent(student.getStuaddress());
			//将子子元素添加到子元素中
			studentElement.appendChild(stunameElement);
			studentElement.appendChild(stuageElement);
			studentElement.appendChild(stuaddressElement);
			//将子元素添加进根元素中
			rootElment.appendChild(studentElement);
		}
		//将根元素添加到Document对象中
		document.appendChild(rootElment);
		//将document对象写出到文件中
		File file=new File("student1.xml");
		//创建TransformerFactory对象
		TransformerFactory tff=TransformerFactory.newInstance();
		//创建Transformer对象
		Transformer tf=tff.newTransformer();
		//输出内容是否使用换行
		tf.setOutputProperty(OutputKeys.INDENT,"yes");
		//创建xml文件并写入内容
		tf.transform(new DOMSource(document),new StreamResult(file));
	}
}

测试

package com.wangxing.test1;

import java.util.ArrayList;

public class Main {
	public static void main(String[] args) throws Exception {
		Student student1=new Student();
		student1.setStuid(1001);
		student1.setStuname("fxt");
		student1.setStuage(22);
		student1.setStuaddress("西安");
		Student student2=new Student();
		student2.setStuid(1002);
		student2.setStuname("ch");
		student2.setStuage(22);
		student2.setStuaddress("西安");
		Student student3=new Student();
		student3.setStuid(1003);
		student3.setStuname("wh");
		student3.setStuage(22);
		student3.setStuaddress("西安");
		//创建集合
		ArrayList<Student> stulist=new ArrayList<Student>();
		stulist.add(student1);
		stulist.add(student2);
		stulist.add(student3);
		xmlHelper.createXml1(stulist);
	}
}

得到结果

<?xml version="1.0" encoding="UTF-8"?><studentlist>
<student stuid="1001">
<stuname>fxt</stuname>
<stuage>22</stuage>
<stuaddress>西安</stuaddress>
</student>
<student stuid="1002">
<stuname>ch</stuname>
<stuage>22</stuage>
<stuaddress>西安</stuaddress>
</student>
<student stuid="1003">
<stuname>wh</stuname>
<stuage>22</stuage>
<stuaddress>西安</stuaddress>
</student>
</studentlist>

1.2使用第三方开发包【提前下载】
        dom4j
例如：

package com.wangxing.test1;

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

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.dom4j.DocumentHelper;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
//import org.jdom.Document;
//import org.jdom.Element;

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
//import org.w3c.dom.Document;
//import org.w3c.dom.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;

public class xmlHelper {
	
	/**
	 * 使用第三方开发包
	 * dom4j
	 * @param studentlist
	 */
	
	public static void createXml2(ArrayList<Student> stulist) throws Exception{
		//创建Document对象
		Document document=DocumentHelper.createDocument();
		//创建根元素
		Element rootElement=document.addElement("studentlist");
		//遍历集合
		for(Student student:stulist){
			//创建子元素并直接添加进根元素
			Element studentElement=rootElement.addElement("student");
			studentElement.addAttribute("stuid", String.valueOf(student.getStuid()));
			//创建子子元素并添加进子元素
			Element stunameElement=studentElement.addElement("stuname");
			stunameElement.setText(student.getStuname());
			Element stuageElement=studentElement.addElement("stuage");
			stuageElement.setText(String.valueOf(student.getStuage()));
			Element stuaddressElement=studentElement.addElement("stuaddress");
			stuaddressElement.setText(student.getStuaddress());
		}
		//设置生成xml的格式
		OutputFormat format=OutputFormat.createPrettyPrint();
		//设置编码格式
		format.setEncoding("UTF-8");
		//创建xml字符输出流
		XMLWriter writer=new XMLWriter(new FileOutputStream(new File("student2.xml")),format);
		//设置是否转义，默认使用转义字符
		writer.setEscapeText(false);
		//写出Document对象
		writer.write(document);
		//关闭流
		writer.close();
	}
}

         jdom
例如：

package com.wangxing.test1;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

public class xmlHelper {
	/**
	 * jdom
	 * @param studentlist
	 */
	public static void createXml3(ArrayList<Student> stulist) throws Exception{
		//创建根元素
		Element rootElement=new org.jdom.Element("studentlist");
		//遍历集合
		for(Student student:stulist){
			//创建子元素
			Element studentElement=new Element("student");
			//给子元素设置属性
			studentElement.setAttribute("stuid", String.valueOf(student.getStuid()));
			//创建子子元素
			Element stunameElement=new Element("stuname");
			stunameElement.setText(student.getStuname());
			Element stuageElement=new Element("stuage");
			stuageElement.setText(String.valueOf(student.getStuage()));
			Element stuaddressElement=new Element("stuaddress");
			stuaddressElement.setText(student.getStuaddress());
			//将子子元素放进子元素
			studentElement.addContent(stunameElement);
			studentElement.addContent(stuageElement);
			studentElement.addContent(stuaddressElement);
			//将子元素放进根元素中
			rootElement.addContent(studentElement);
		}
		//创建Document对象,将根元素放进去
		Document document=new Document(rootElement);
		//输出Document对象
		Format format=Format.getCompactFormat();
		//设置换行Tab或换行以及编码格式
		format.setIndent(" ");
		format.setEncoding("utf-8");
		//创建XMLOutputter的对象
		XMLOutputter outputter=new XMLOutputter(format);
		//写出Document
		outputter.output(document, new FileOutputStream(new File("student3.xml")));
	}
}

 2.通过拼接字符串【不推荐，容易出错】
例如：

public  static void createXML4(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("F:"+File.separator+"personlist.xml");
		BufferedWriter  out=new BufferedWriter(new FileWriter(file));
		out.write(xmlcontent);
		out.close();
	}

五、XML文件的解析

 1.DOM（Document  Object  Model）解析
        1.1java默认的Dom解析xml
例如：
创建接收student对象数值的类

package com.wangxing.test2;

public class Student {
	private int stuid;
	private String stuname;
	private int stuage;
	private String stuaddress;
	public int getStuid() {
		return stuid;
	}
	public void setStuid(int stuid) {
		this.stuid = stuid;
	}
	public String getStuname() {
		return stuname;
	}
	public void setStuname(String stuname) {
		this.stuname = stuname;
	}
	public int getStuage() {
		return stuage;
	}
	public void setStuage(int stuage) {
		this.stuage = stuage;
	}
	public String getStuaddress() {
		return stuaddress;
	}
	public void setStuaddress(String stuaddress) {
		this.stuaddress = stuaddress;
	}
}

创建解析xml文件的类

package com.wangxing.test2;

import java.io.File;
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;

public class xmlHelper {
	/**
	 * java默认的Dom解析xml
	 * @param filename
	 * @return
	 * @throws Exception
	 */
	public static List<Student> getstudentXML(String filename) throws Exception{
		//创建最后解析得到的Student对象放入集合中
		List<Student> stulist=new ArrayList<Student>();
		//得到解析器工厂
		DocumentBuilderFactory builderFactory=DocumentBuilderFactory.newInstance();
		//得到解析对象
		DocumentBuilder documentBuilder=builderFactory.newDocumentBuilder();
		//创建Document对象
		Document document=documentBuilder.parse(new File(filename));
		//得到所有子元素集合
		NodeList studentNodeList=document.getElementsByTagName("student");
		//遍历得到的集合
		for(int i=0;i<studentNodeList.getLength();i++){
			Student student=new Student();
			//拿到外层没个集合中子元素的标记节点
			Node studentElement=studentNodeList.item(i);
			//得到每个子元素的属性值
			int stuid=Integer.parseInt(studentElement.getAttributes().item(0).getNodeValue());
			//将每次得到stuid设置给student对象
			student.setStuid(stuid);
			//从子元素的标记节点中获取子子元素标记节点集合
			NodeList childElement=studentElement.getChildNodes();
			//遍历子子元素
			for(int j=0;j<childElement.getLength();j++){
				//得到子子元素的每一项标记节点
				Node elementName=childElement.item(j);
				//得到每一个子子元素的标记内容
				String info=elementName.getTextContent();
				//通过得到每个标记节点得到标记名称来得到想要的标记内容
				if(elementName.getNodeName().equals("stuname")){
					student.setStuname(info);
				}
				if(elementName.getNodeName().equals("stuage")){
					student.setStuage(Integer.parseInt(info));;
				}
				if(elementName.getNodeName().equals("stuaddress")){
					student.setStuaddress(info);;
				}
			}
			//每次循环外层子元素的时候将每个子元素得到Student对象放入集合中
			stulist.add(student);
		}
		return stulist;
	}
}

测试：

package com.wangxing.test2;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.List;

public class Main {
	public static void main(String[] args) throws Exception {
		BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
		System.out.print("请输入要解析的xml文件的文件名称+后缀名：");
		String filename=reader.readLine();
		List<Student> stulist=xmlHelper.getstudentXML(filename);
		for(Student student:stulist){
			System.out.println(student.getStuname());
		}
	}
}

         1.2  dom4j
例如;

package com.wangxing.test2;

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;

public class xmlHelper {
	/**
	 * java默认的Dom解析xml
	 * @param filename
	 * @return
	 * @throws Exception
	 */
	/*
	public static List<Student> getstudentXML(String filename) throws Exception{
		//创建最后解析得到的Student对象放入集合中
		List<Student> stulist=new ArrayList<Student>();
		//得到解析器工厂
		DocumentBuilderFactory builderFactory=DocumentBuilderFactory.newInstance();
		//得到解析对象
		DocumentBuilder documentBuilder=builderFactory.newDocumentBuilder();
		//创建Document对象
		Document document=documentBuilder.parse(new File(filename));
		//得到所有子元素集合
		NodeList studentNodeList=document.getElementsByTagName("student");
		//遍历得到的集合
		for(int i=0;i<studentNodeList.getLength();i++){
			Student student=new Student();
			//拿到外层没个集合中子元素的标记节点
			Node studentElement=studentNodeList.item(i);
			//得到每个子元素的属性值
			int stuid=Integer.parseInt(studentElement.getAttributes().item(0).getNodeValue());
			//将每次得到stuid设置给student对象
			student.setStuid(stuid);
			//从子元素的标记节点中获取子子元素标记节点集合
			NodeList childElement=studentElement.getChildNodes();
			//遍历子子元素
			for(int j=0;j<childElement.getLength();j++){
				//得到子子元素的每一项标记节点
				Node elementName=childElement.item(j);
				//得到每一个子子元素的标记内容
				String info=elementName.getTextContent();
				//通过得到每个标记节点得到标记名称来得到想要的标记内容
				if(elementName.getNodeName().equals("stuname")){
					student.setStuname(info);
				}
				if(elementName.getNodeName().equals("stuage")){
					student.setStuage(Integer.parseInt(info));;
				}
				if(elementName.getNodeName().equals("stuaddress")){
					student.setStuaddress(info);;
				}
			}
			//每次循环外层子元素的时候将每个子元素得到Student对象放入集合中
			stulist.add(student);
		}
		return stulist;
	}
	*/
	/**
	 * dom4j
	 * @param filename
	 * @return
	 */
	public static List<Student> getstudentXML(String filename) throws Exception{
		List<Student> stulst=new ArrayList<Student>();
		//创建SAXReader对象
		SAXReader saxread=new SAXReader();
		//通过SAXReader读取xml文件创建document对象
		 Document document=saxread.read(new File(filename));
		 //通过document对象得到根元素对象
		 Element rootElement=document.getRootElement();
		 //通过根元素得到每个子元素标记名称为student组成的集合（包括里面的子子元素）
		 List<Element> studentElementList=rootElement.elements("student");
		 //遍历得到的子元素集合
		 for(Element studentElement:studentElementList){
			 Student student=new Student();
			 //得到子元素的属性值
			 int stuid=Integer.parseInt(studentElement.attributeValue("stuid"));
			 //得到子元素中的子子元素stuname元素对象
			 Element stunameElement=studentElement.element("stuname");
			 String stuname=stunameElement.getText();
			 Element stuageElement=studentElement.element("stuage");
			 int stuage=Integer.parseInt(stuageElement.getText());
			 Element stuaddressElement=studentElement.element("stuaddress");
			 String stuaddress=stuaddressElement.getText();
			 student.setStuid(stuid);
			 student.setStuname(stuname);
			 student.setStuage(stuage);
			 student.setStuaddress(stuaddress);
			 stulst.add(student);
		 }
		 return stulst;
	}
}

         1.3jdom
例如：

package com.wangxing.test2;

import java.io.File;
import java.util.ArrayList;
//import java.util.List;
import java.util.List;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;

//import javax.xml.parsers.DocumentBuilder;
//import javax.xml.parsers.DocumentBuilderFactory;

//import org.dom4j.Document;
//import org.dom4j.Element;
//import org.dom4j.io.SAXReader;
//import org.w3c.dom.Document;
//import org.w3c.dom.Node;
//import org.w3c.dom.NodeList;

public class xmlHelper {
	/**
	 * java默认的Dom解析xml
	 * @param filename
	 * @return
	 * @throws Exception
	 */
	/*
	public static List<Student> getstudentXML1(String filename) throws Exception{
		//创建最后解析得到的Student对象放入集合中
		List<Student> stulist=new ArrayList<Student>();
		//得到解析器工厂
		DocumentBuilderFactory builderFactory=DocumentBuilderFactory.newInstance();
		//得到解析对象
		DocumentBuilder documentBuilder=builderFactory.newDocumentBuilder();
		//创建Document对象
		Document document=documentBuilder.parse(new File(filename));
		//得到所有子元素集合
		NodeList studentNodeList=document.getElementsByTagName("student");
		//遍历得到的集合
		for(int i=0;i<studentNodeList.getLength();i++){
			Student student=new Student();
			//拿到外层没个集合中子元素的标记节点
			Node studentElement=studentNodeList.item(i);
			//得到每个子元素的属性值
			int stuid=Integer.parseInt(studentElement.getAttributes().item(0).getNodeValue());
			//将每次得到stuid设置给student对象
			student.setStuid(stuid);
			//从子元素的标记节点中获取子子元素标记节点集合
			NodeList childElement=studentElement.getChildNodes();
			//遍历子子元素
			for(int j=0;j<childElement.getLength();j++){
				//得到子子元素的每一项标记节点
				Node elementName=childElement.item(j);
				//得到每一个子子元素的标记内容
				String info=elementName.getTextContent();
				//通过得到每个标记节点得到标记名称来得到想要的标记内容
				if(elementName.getNodeName().equals("stuname")){
					student.setStuname(info);
				}
				if(elementName.getNodeName().equals("stuage")){
					student.setStuage(Integer.parseInt(info));;
				}
				if(elementName.getNodeName().equals("stuaddress")){
					student.setStuaddress(info);;
				}
			}
			//每次循环外层子元素的时候将每个子元素得到Student对象放入集合中
			stulist.add(student);
		}
		return stulist;
	}
	*/
	/**
	 * dom4j
	 * @param filename
	 * @return
	 */
	/*
	public static List<Student> getstudentXML2(String filename) throws Exception{
		List<Student> stulst=new ArrayList<Student>();
		//创建SAXReader对象
		SAXReader saxread=new SAXReader();
		//通过SAXReader读取xml文件创建document对象
		 Document document=saxread.read(new File(filename));
		 //通过document对象得到根元素对象
		 Element rootElement=document.getRootElement();
		 //通过根元素得到每个子元素标记名称为student组成的集合（包括里面的子子元素）
		 List<Element> studentElementList=rootElement.elements("student");
		 //遍历得到的子元素集合
		 for(Element studentElement:studentElementList){
			 Student student=new Student();
			 //得到子元素的属性值
			 int stuid=Integer.parseInt(studentElement.attributeValue("stuid"));
			 //得到子元素中的子子元素stuname元素对象
			 Element stunameElement=studentElement.element("stuname");
			 String stuname=stunameElement.getText();
			 Element stuageElement=studentElement.element("stuage");
			 int stuage=Integer.parseInt(stuageElement.getText());
			 Element stuaddressElement=studentElement.element("stuaddress");
			 String stuaddress=stuaddressElement.getText();
			 student.setStuid(stuid);
			 student.setStuname(stuname);
			 student.setStuage(stuage);
			 student.setStuaddress(stuaddress);
			 stulst.add(student);
		 }
		 return stulst;
	}
	*/
	/**
	 * jdom
	 * @param filename
	 * @return
	 * @throws Exception
	 */
	public static List<Student> getstudentXML3(String filename)throws  Exception{
		List<Student> stulist=new ArrayList<Student>();
		//创建SAXReader对象
		SAXBuilder saxBuilder=new SAXBuilder();
		//通过SAXReader读取xml文件创建document对象
		Document document=saxBuilder.build(new File(filename));
		Element rootElement=document.getRootElement();
		//通过根元素对象得到他的子/子子元素对象集合
		List<Element> childElement=rootElement.getChildren();
		//遍历
		for(Element studentElement:childElement){
			 Student student=new Student();
			//得到子元素的属性值
			int stuid=Integer.parseInt(studentElement.getAttributeValue("stuid"));
			//得到子子元素的标记对象
			Element stuidElement=studentElement.getChild("stuname");
			String stuname=stuidElement.getText();
			Element stuageElement=studentElement.getChild("stuage");
			int stuage=Integer.parseInt(stuageElement.getText());
			Element stuaddressElement=studentElement.getChild("stuaddress");
			String stuaddress=stuidElement.getText();
			student.setStuid(stuid);
			student.setStuname(stuname);
			student.setStuage(stuage);
			student.setStuaddress(stuaddress);
			stulist.add(student);
		}
		return stulist;
	}
}

 DOM（Document Object Model)解析的原理就是需要被解析的xml文件，读取成一个文档树【Document 对象】，依据提供的开发类库和方法从文档树中得到根元素，再从根元素中得到子元素，从子元素中的到子子元素，再得到具体的数据值。
    优点:结构清晰明了。
    缺点:通常需要加载整个XML文档来构造层次结构，消耗资源大.
2.SAX（Simple API for XML)解析
    DefaultHandler这个类是缺省的，需要继承这个类才能使用
例如：
创建student类

package com.wangxing.test2;

public class Student {
	private int stuid;
	private String stuname;
	private int stuage;
	private String stuaddress;
	public int getStuid() {
		return stuid;
	}
	public void setStuid(int stuid) {
		this.stuid = stuid;
	}
	public String getStuname() {
		return stuname;
	}
	public void setStuname(String stuname) {
		this.stuname = stuname;
	}
	public int getStuage() {
		return stuage;
	}
	public void setStuage(int stuage) {
		this.stuage = stuage;
	}
	public String getStuaddress() {
		return stuaddress;
	}
	public void setStuaddress(String stuaddress) {
		this.stuaddress = stuaddress;
	}
}

创建xml的解析类得到SAX解析器对象，里面使用DefaultHandler类中的方法去解析

package com.wangxing.test2;

import java.io.File;
import java.util.List;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;


@SuppressWarnings("deprecation")
public class xmlHelper {
	/**
	 * 2.SAX（Simple API for XML)解析
	 * @param filename
	 * @return
	 */
	public static List<Student> getstudentXML4(String filename) throws Exception{
		//得到SAX解析器工厂
		SAXParserFactory saxFactroy=SAXParserFactory.newInstance();
		//从工厂中得到解析器对象
		SAXParser saxparser=saxFactroy.newSAXParser();
		MyDefaultHandler  myDefaultHandler=new MyDefaultHandler();
		System.out.println(myDefaultHandler);
		saxparser.parse(new File(filename), myDefaultHandler);
		return myDefaultHandler.getStudentList();
	}
}

创建继承了DefaultHandler类的子类

package com.wangxing.test2;

import java.util.ArrayList;
import java.util.List;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class MyDefaultHandler extends DefaultHandler{
	//保存每次接受的student对象
	private List<Student> studentlist=null;
	private Student student=null;
	//创建保存得到的元素标记名称
	private String ElementName=" ";
	/**
	 * 得到解析后的数据集合
	 * @return
	 */
	public List<Student> getStudentList() {
		return studentlist;
	}
	/**
	 * 文档开始
	 */
	@Override
	public void startDocument() throws SAXException {
		//生成集对象
		studentlist=new ArrayList<Student>();
	}
	/**
	 * 文档结束
	 */
	@Override
	public void endDocument() throws SAXException {
		// TODO Auto-generated method stub
		super.endDocument();
	}
	/**
	 * 元素开始
	 */
	@Override
	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		//当元素的标签名称是student时创建是student对象
		if (qName.equals("student")) {
			student=new Student();
			int stuid=Integer.parseInt(attributes.getValue("stuid"));
			student.setStuid(stuid);
		}
		if (qName.equals("stuname")) {
			ElementName=qName;
		}
		if (qName.equals("stuage")) {
			ElementName=qName;
		}
		if (qName.equals("stuaddress")) {
			ElementName=qName;
		}
	}
	/**
	 * 元素结束
	 */
	@Override
	public void endElement(String uri, String localName, String qName) throws SAXException {
		ElementName=" ";
		if (qName.equals("student")) {
			studentlist.add(student);
			student=null;
		}
	}
	/**
	 * 得到数据值
	 */
	@Override
	public void characters(char[] ch, int start, int length) throws SAXException {
		String info=new String(ch,start,length);
		if (ElementName.equals("stuname")) {
			student.setStuname(info);
		}
		if (ElementName.equals("stuage")) {
			student.setStuage(Integer.parseInt(info));
		}
		if (ElementName.equals("stuaddress")) {
			student.setStuaddress(info);
		}
	}	
}

测试：

package com.wangxing.test2;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.List;

public class Main {
	public static void main(String[] args) throws Exception {
		BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
		System.out.print("请输入要解析的xml文件的文件名称+后缀名：");
		String filename=reader.readLine();
		//List<Student> stulist=xmlHelper.getstudentXML1(filename);
		//List<Student> stulist=xmlHelper.getstudentXML2(filename);
		//List<Student> stulist=xmlHelper.getstudentXML3(filename);
		List<Student> stulist=xmlHelper.getstudentXML4(filename);
		for(Student student:stulist){
			System.out.println(student.getStuname());
		}
	}
}

 SAX（Simple API for XML)解析xml文件的原理是基于事件的模型，它在解析XML文档的时候可以触发一系列的事件，当发现给定的标签的时候，它可以激活一个回调方法，告诉该方法指定的标签已经找到，如果这个指定的标记中中有我们需要数据值就解析，没有就不用处理。读取一个元素，判断这一个元素属于xml文件的哪一个元素【文档开始/文档结束/标记开始/标记结束/文本元素】，不同的元素触发不同的方法来执行解析数据，如果当前元素中没有数据值就跳过读取下一个元素。
    优点:1.只在读取数据时检查数据，不需要保存在内存中 
         2.可以在某个条件得到满足时停止解析，不必解析整个文档。
         3.效率和性能较高，能解析大于系统内存的文档。
    缺点:没有清晰的解析结构
与SAX解析相似的一种解析方法pull解析