java基础

14.生成和解析XML

1.什么是XML?xml的作用？如何编写xml?

XML就是可扩展标记语言。【是一种简单的数据存储语言】

作用：XML--可扩展标记语言--是一种简单的数据存储语言--没有固定的标记元素，在使用的时候可以根据自己的需要创造一个。

名称	作用	特征
HTML	制作网页	有一组静态的标记元素，无法扩展。 例如：<table></table>表示一个表格
XML	数据存储语言 保存数据	没有固定的标记元素，在使用的时候可以根据自己的需要去创建一个标记。 例如：<表格></表格>

1.可以在可扩展标记语言文件的内容包括几乎所有的万国码Unicode字符，元素和属性的名称也可以由非ascii字符组成；

2.标签由包围在一个小于号（<）和一个大于号（>）之间的文本组成，例如<标记>；

3.起始标签（外国语：starttag）表示一个特定区域的开始，例如<起始>；

4.结束标签（外国语：end tag）定义了一个区域的结束，除了在小于号之后紧跟着一个斜线（/）外，和起始标签基本一样，例如</结束>；

5.标准通用标记语言还定义了标签的特性“属性”，它们是定义在小于号和大于号之间的值，例如<图片 源="我的靓照.jpg">中的“源”特性。

<图片 源="我的靓照.jpg">---我们自己定义的一个xml元素/标记

 源="我的靓照.jpg"----表示这个标记的一个属性

源--属性名称

"我的靓照.jpg"---属性值

...........

一个简单的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文件中

<?xml version="1.0"  encoding=”utf-8”?> --文件头

<students>/</students>---根元素 【不能省略】我们自己定义

<student>/</student>-----子元素，可以有多个，也可以只有一个，我们自己定义

<name>/</name>,<age>/</age>,<sex>/</sex>--子子元素【孙子元素】我们自己定义

id=”1001”---属性 ，出现在开始标记中，可以有多个。

zhangsan、23、男 /lisi、24、女---文本元素【真实的被xml存储起来的真实的数据值】

所有的元素都是成对出现。

2.Xml文件的生成方式和解析方式？

生成

1.Dom生成

package com.clic369.test;

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.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

import com.clic369.bean.Person;
import com.clic369.util.XMHelper;

public class CreateXML {
      /**
       * 测试Dom生成XML
       * @throws Exception
       */
	 @Test
	  public  void  testCreateDomXML()throws  Exception{
		   //得到需要的数据
		 List<Person>  personlist= XMHelper.getPersonData();
		 //得到DOM解析器工厂
		 DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
		 //从解析器工厂的解析器
		 DocumentBuilder  builder=factory.newDocumentBuilder();
		  //得到Document对象
		 Document   document= builder.newDocument();
		  // 不显示standalone="no"
         document.setXmlStandalone(true);
		 //创建根据元素
		 Element   rootElement = document.createElement("persons");
		 for(Person  per:personlist){
			 //创建子元素
			 Element   personElement = document.createElement("person");
			 //为子元素添加属性
			 personElement.setAttribute("perid",String.valueOf(per.getPerid()));
			 //创建name子子元素
			 Element   pernameElement = document.createElement("pername");
			 //为子子元素设置文本数据
			 pernameElement.setTextContent(per.getPername());
			 //创建age子子元素
			 Element   perageElement = document.createElement("perage");
			 //为子子元素设置文本数据
			 perageElement.setTextContent(String.valueOf(per.getPerage()));
			 //创建address子子元素
			 Element   peraddressElement = document.createElement("peraddress");
			 //为子子元素设置文本数据
			 peraddressElement.setTextContent(per.getPeraddress());
			 //将子子元素添加到子元素
			 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文件并写入内容
         tf.transform(new DOMSource(document), new StreamResult(new File("person1.xml")));
	  }
}

二 dom4j生成XML

package com.clic369.test;
import java.io.File;
import java.io.FileOutputStream;
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 org.junit.Test;
import com.clic369.bean.Person;
import com.clic369.util.XMHelper;
public class CreateXML {
 //通过第三方的开发库生成xml文件
	 //1.dom4j
	 //下载dom4j开发包
	 /**
	  * 通过dom4j开发包来生成xml
	  * @throws Exception
	  */
	 @Test
	  public  void  testCreateDom4jXML()throws  Exception{
		   //得到需要的数据
			List<Person>  personlist= XMHelper.getPersonData();
			//得到Document对象
			Document document=DocumentHelper.createDocument();
			//创建根节点
			Element  rootElement= document.addElement("persons");
			for(Person per:personlist){
				//创建子元素
				Element personElement=rootElement.addElement("person");
				//设置子元素的熟悉
				personElement.addAttribute("perid",String.valueOf(per.getPerid()));
				//创建name子子元素
				Element pernameElement=personElement.addElement("pername");
				//设置文本数据
				pernameElement.setText(per.getPername());
				//创建age子子元素
				Element perageElement=personElement.addElement("perage");
				//设置文本数据
				perageElement.setText(String.valueOf(per.getPerage()));
				//创建address子子元素
				Element peraddressElement=personElement.addElement("peraddress");
				//设置文本数据
				peraddressElement.setText(per.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();
	 }

三 、jdom生成xml文件

package com.clic369.test;
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 org.junit.Test;

import com.clic369.bean.Person;
import com.clic369.util.XMHelper;
public class CreateXML {
 //2.jdom
	// 下载jdom开发包
	 @Test
	  public  void  testCreateJdomXML()throws  Exception{
		 //得到需要的数据
		 List<Person>  personlist= XMHelper.getPersonData();
		//创建根元素
		 Element  rootElement= new Element("persons");
		 for(Person  per:personlist){
			 //创建子元素
			 Element  personElement= new Element("person");
			 //设置属性
			 personElement.setAttribute("perid",String.valueOf(per.getPerid()));
			 //创建name元素
			 Element  pernameElement= new Element("pername");
			 //设置文本元素
			 pernameElement.setText(per.getPername());
			 //创建age元素
			 Element  perageElement= new Element("perage");
			 //设置文本元素
			 perageElement.setText(String.valueOf(per.getPerage()));
			 //创建address元素
			 Element  peraddressElement= new Element("peraddress");
			 //设置文本元素
			 peraddressElement.setText(per.getPeraddress());
			 //将子子元素添加到子元素
			 personElement.addContent(pernameElement);
			 personElement.addContent(perageElement);
			 personElement.addContent(peraddressElement);
			 //将子元素添加到根元素
			 rootElement.addContent(personElement);
		 }
		 //通过根元素创建Document对象
		 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")));
	 }


/**
	 * 通过拼接字符串的方式创建一个xml文件
	 * @param personlist
	 * @throws Exception
	 */
	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文件的解析

将xml文件转换成java对象

XML文件的解析实际上就是将xml文件中保存的数据取出，转换成java对象

 

1.Dom解析XML文件

package com.clic369.test;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import com.clic369.bean.Person;

/*
 * 解析XML文件
 */
public class ParserXml {
    /**
     * dom解析XML文件
     * @throws Exception
     */
	@Test
	public  void  parserDomXml()throws Exception{
		//得到解析器工程
		DocumentBuilderFactory  builderFactory=DocumentBuilderFactory.newInstance();
		//得到解析器对象
		DocumentBuilder  documentBuilder=builderFactory.newDocumentBuilder();
		//通过解析器得到Document对象
		//parse执行之后就会读取对应的XML文件到内存中形成一个文档树结构，返回一个文档对象
		//我们解析xml文件的过程就是从Document对象中得到自己需要的数据值
		Document  document=documentBuilder.parse(new File("person3.xml"));
		//根据指定的元素名称得到包含有众多子元素的集合
		NodeList   perlist=document.getElementsByTagName("person");
		//保存解析成功后的集合
		List<Person>  personlist=new ArrayList<Person>();
		//遍历包含有众多子元素的集合
		for(int i=0;i<perlist.getLength();i++){
			//得到具体的某一个子元素对象
			Node  sunElement=perlist.item(i);
		   Person  person = new Person();
		   //得到子元素的第一个属性值
			int perid=Integer.parseInt(sunElement.getAttributes().item(0).getNodeValue());
		   person.setPerid(perid);
		   //得到子元素中包含的子子元素的集合
		    NodeList  perChildList=sunElement.getChildNodes();
		    //遍历子子元素的集合
		    for(int j=0;j<perChildList.getLength();j++){
		    	//得到每一个子子元素的对象
		    	Node perchild=perChildList.item(j);
		    	//如何子子元素的名称是“pername”,则获取这个子子元素对应的文件数据值
		    	if(perchild.getNodeName().equals("pername")){
		    		   person.setPername(perchild.getTextContent());
		    	}
		    	//如何子子元素的名称是“perage”,则获取这个子子元素对应的文件数据值
		    	if(perchild.getNodeName().equals("perage")){
	    		    person.setPerage(Integer.parseInt(perchild.getTextContent()));
	    	    }
		    	//如何子子元素的名称是“peraddress”,则获取这个子子元素对应的文件数据值
		    	if(perchild.getNodeName().equals("peraddress")){
	    		    person.setPeraddress(perchild.getTextContent());
	    	}
		    }
		    personlist.add(person);
		}
		System.out.println(personlist.size());
		for(Person per:personlist){
			System.out.println(per.getPerid()+"   "+per.getPername()+"  "+per.getPerage()+" "+per.getPeraddress());
		}
	}
}

2.Dom4j解析XML文件

public  void  parserDom4jXml()throws Exception{
		//创建xml解析器对象
		SAXReader   saxReader=new SAXReader();
		//通过解析器对象读取被解析的xml文件一个Document
		Document  document=saxReader.read(new File("person3.xml"));
		//得到根元素
		Element  rootElement=document.getRootElement();
		List<Element> elementlist= rootElement.elements("person");
		List<Person>  personlist=new ArrayList<Person>();
		for(Element  personElement:elementlist){
			Person  person=new Person();
			person.setPerid(Integer.parseInt(personElement.attributeValue("perid")));
			person.setPername(personElement.element("pername").getText());
			person.setPerage(Integer.parseInt(personElement.element("perage").getText()));
			person.setPeraddress(personElement.element("peraddress").getText());
			personlist.add(person);
		}
		
		for(Person per:personlist){
			System.out.println(per.getPerid()+"   "+per.getPername()+"  "+per.getPerage()+" "+per.getPeraddress());
		}
	}

3.Jdom解析XML文件

public  void  parserJdomXml()throws Exception{
		//得到解析器对象
		SAXBuilder saxBuilder=new SAXBuilder();
		//读取被解析的xml文件成document
		 Document  document=saxBuilder.build(new File("person3.xml"));
		 //得到根元素
		 Element  rootElement= document.getRootElement();
		 //得到指定的子元素
		List<Element>  elementList= rootElement.getChildren("person");
		List<Person>  personlist=new ArrayList<Person>();
		for(Element personElement:elementList){
			Person  person=new Person();
			person.setPerid(Integer.parseInt(personElement.getAttributeValue("perid")));
			person.setPername(personElement.getChildText("pername"));
			person.setPerage(Integer.parseInt(personElement.getChildText("perage")));
			person.setPeraddress(personElement.getChildText("peraddress"));
			personlist.add(person);
		}
		
		for(Person per:personlist){
			System.out.println(per.getPerid()+"   "+per.getPername()+"  "+per.getPerage()+" "+per.getPeraddress());
		}
	}

4.Sax解析xml文件

/**
	 * 通过sax解析xml文件
	 * 下载 -- 导入 --  sax.jar
	 */
	@Test
	public  void  parserSaxXml()throws Exception{
		//得到SAX解析器工厂
		SAXParserFactory saxfac = SAXParserFactory.newInstance();
		//从工厂中得到解析器对象
		SAXParser   saxParser=saxfac.newSAXParser();
		//调用解析方法解析xml文件
		//参数1--被解析的文件
		//参数2--实现解析步骤的具体java类【继承DefaultHandler 】
		File  f=new File("person3.xml");
		MyDefaultHandler  dh=new MyDefaultHandler();
		saxParser.parse(f, dh);
		//System.out.println(dh.getPersonList().size());
		for(Person per:dh.getPersonList()){
			System.out.println(per.getPerid()+"   "+per.getPername()+"  "+per.getPerage()+" "+per.getPeraddress());
		}
	}

package com.clic369.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.clic369.bean.Person;

public class MyDefaultHandler extends DefaultHandler{
     private  List<Person> personList;
     private  Person  person;
     private String tempName="";
     /**
      * 文档开始方法
      */
	@Override
	public void startDocument() throws SAXException {
		personList=new ArrayList<Person>();
	}

	/**
	 * 元素开始方法
	 * String qName--当前开始元素的名称
	 */
	@Override
	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		if(qName.equals("person")){
			person=new Person();
			person.setPerid(Integer.parseInt(attributes.getValue("perid")));
		}
		if(qName.equals("pername")){
			tempName=qName;
		}
		if(qName.equals("perage")){
			tempName=qName;
		}
		if(qName.equals("peraddress")){
			tempName=qName;
		}
	}
   /**
    * 得到元素文本值的方法
    */
	@Override
	public void characters(char[] ch, int start, int length) throws SAXException {
		String  info=new String(ch,start,length);
		if(tempName.equals("pername")){
			person.setPername(info);
		}
		if(tempName.equals("perage")){
			person.setPerage(Integer.parseInt(info));
		}
		if(tempName.equals("peraddress")){
			person.setPeraddress(info);
		}
	}
	/**
	 * 元素结束方法
	 */
	@Override
   public void endElement(String uri, String localName, String qName) throws SAXException {
	   if(qName.equals("person")){
		   personList.add(person);
		   person=null;
		   tempName="";
	   }else{
		   tempName="";
	   }
   }
   /**
    * 文档结束	
    */
	@Override
	public void endDocument() throws SAXException {

	}

	/**
	 * 得到解析后包含有Person对象的java集合
	 * @return
	 */
	public  List<Person>  getPersonList(){
		return personList;
	}
  }

3.XML解析方式的区别？

1. DOM（Document Object Model)

      DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而DOM被认为是基于树或基于对象的。

【优点】
      ①允许应用程序对数据和结构做出更改。
      ②访问是双向的，可以在任何时候在树中上下导航，获取和操作任意部分的数据。
【缺点】
      ①通常需要加载整个XML文档来构造层次结构，消耗资源大。
2. SAX（Simple API for XML)

【优势】
     ①不需要等待所有数据都被处理，分析就能立即开始。
     ②只在读取数据时检查数据，不需要保存在内存中。
     ③可以在某个条件得到满足时停止解析，不必解析整个文档。
     ④效率和性能较高，能解析大于系统内存的文档。

【缺点】
     ①需要应用程序自己负责TAG的处理逻辑（例如维护父/子关系等），文档越复杂程序就越复杂。
     ②单向导航，无法定位文档层次，很难同时访问同一文档的不同部分数据，不支持XPath。

3. JDOM(Java-based Document Object Model)

优点】
     ①使用具体类而不是接口，简化了DOM的API。
     ②大量使用了Java集合类，方便了Java开发人员。

【缺点】
     ①没有较好的灵活性。
     ②性能较差。

4. DOM4J(Document Object Model for Java)

【优点】
     ①大量使用了Java集合类，方便Java开发人员，同时提供一些提高性能的替代方法。
     ②支持XPath。
     ③有很好的性能。

【缺点】
     ①大量使用了接口，API较为复杂。