解析XML文档

时间 2019-11-24

标签解析 xml 文档栏目 XML 繁體版

原文原文链接

    DOM:文档驱动。DOM在解析文件以前把整个文档装入内存，处理大型文件时其性能不好，是因为DOM的树结构所形成的，此结构占用的内存较多。
    SAX:事件驱动型的XML解析方式。顺序读取XML文件，不须要一次所有装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，会触发一个事件，用户经过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问，且是只读的
    StAX采用流模型中的拉模型分析方式。提供基于指针和基于迭代器两种方式的支持。 
优势： 一、接口简单，使用方便。 二、采用流模型分析方式，有较好的性能。
缺点： 一、单向导航，不支持XPath，很难同时访问同一文档的不一样部分。

DOM解析：
java

1、DOM4j中，得到Document对象的方式有三种：
1.读取XML文件,得到document对象              
                  SAXReader reader = new SAXReader();                
       Document   document = reader.read(new File("csdn.xml"));  
2.解析XML形式的文本,获得document对象.  
                  String text = "<csdn></csdn>";              
                  Document document = DocumentHelper.parseText(text);  
3.主动建立document对象.  
                 Document document = DocumentHelper.createDocument();             //建立根节点  
                 Element root = document.addElement("csdn");  
                 
2、节点对象操做的方法:
 1.获取文档的根节点.  
      Element root = document.getRootElement();  
    2.取得某个节点的子节点.  
      Element element=node.element(“四大名著");  
    3.取得节点的文字  
        String text=node.getText();  
    4.取得某节点下全部名为“csdn”的子节点，并进行遍历.  
       List nodes = rootElm.elements("csdn");   
         for (Iterator it = nodes.iterator(); it.hasNext();) {     
      Element elm = (Element) it.next();    
    // do something  
 }  
     5.对某节点下的全部子节点进行遍历.      
      for(Iterator it=root.elementIterator();it.hasNext();){        
        Element element = (Element) it.next();        
       // do something   
 }  
    6.在某节点下添加子节点  
      Element elm = newElm.addElement("朝代");  
    7.设置节点文字.  elm.setText("明朝");  
    8.删除某节点.//childElement是待删除的节点,parentElement是其父节点  parentElement.remove(childElment);  
    9.添加一个CDATA节点.Element contentElm = infoElm.addElement("content");contentElm.addCDATA(“cdata区域”);
3、将文档写入XML文件
    1.文档中全为英文,不设置编码,直接写入的形式.    
       XMLWriter writer = new XMLWriter(new  FileWriter("ot.xml"));   
       writer.write(document);    
       writer.close();  
    2.文档中含有中文,设置编码格式写入的形式.  
       OutputFormat format = OutputFormat.createPrettyPrint();// 建立文件输出的时候，自动缩进的格式
       format.setEncoding("UTF-8");//设置编码  
       XMLWriter writer = new XMLWriter(newFileWriter("output.xml"),format);  
       writer.write(document);  
       writer.close(); 
       
4、字符串与XML的转换
1.将字符串转化为XML  
      String text = "<csdn> <java>Java班</java></csdn>";  
      Document document = DocumentHelper.parseText(text);  
2.将文档或节点的XML转化为字符串.  
       SAXReader reader = new SAXReader();  
       Document   document = reader.read(new File("csdn.xml"));              
       Element root=document.getRootElement();      
       String docXmlText=document.asXML();  
       String rootXmlText=root.asXML();  
       Element memberElm=root.element("csdn");  
       String memberXmlText=memberElm.asXML();

dom4j解析示例：node

package dom4j;

import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.OutputStreamWriter;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.util.Iterator;
import java.util.List;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;

public class Demo01 {

	@Test
	public void test() throws Exception {

		// 建立saxReader对象
		SAXReader reader = new SAXReader();
		// 经过read方法读取一个文件 转换成Document对象
		Document document = reader.read(new File("src/dom4j/sida.xml"));
		//获取根节点元素对象
		Element node = document.getRootElement();
		//遍历全部的元素节点
		listNodes(node);

		// 获取四大名著元素节点中，子节点名称为红楼梦元素节点。
		Element element = node.element("红楼梦");
		//获取element的id属性节点对象
		Attribute attr = element.attribute("id");
		//删除属性
		element.remove(attr);
		//添加新的属性
		element.addAttribute("name", "做者");
		// 在红楼梦元素节点中添加朝代元素的节点
		Element newElement = element.addElement("朝代");
		newElement.setText("清朝");
		//获取element中的做者元素节点对象
		Element author = element.element("做者");
		//删除元素节点
		boolean flag = element.remove(author);
		//返回true代码删除成功，不然失败
		System.out.println(flag);
		//添加CDATA区域
		element.addCDATA("红楼梦，是一部爱情小说.");
		// 写入到一个新的文件中
		writer(document);

	}

	/**
	 * 把document对象写入新的文件
	 * 
	 * @param document
	 * @throws Exception
	 */
	public void writer(Document document) throws Exception {
		// 紧凑的格式
		// OutputFormat format = OutputFormat.createCompactFormat();
		// 排版缩进的格式
		OutputFormat format = OutputFormat.createPrettyPrint();
		// 设置编码
		format.setEncoding("UTF-8");
		// 建立XMLWriter对象,指定了写出文件及编码格式
		// XMLWriter writer = new XMLWriter(new FileWriter(new
		// File("src//a.xml")),format);
		XMLWriter writer = new XMLWriter(new OutputStreamWriter(
				new FileOutputStream(new File("src//a.xml")), "UTF-8"), format);
		// 写入
		writer.write(document);
		// 当即写入
		writer.flush();
		// 关闭操做
		writer.close();
	}

	/**
	 * 遍历当前节点元素下面的全部(元素的)子节点
	 * 
	 * @param node
	 */
	public void listNodes(Element node) {
		System.out.println("当前节点的名称：：" + node.getName());
		// 获取当前节点的全部属性节点
		List<Attribute> list = node.attributes();
		// 遍历属性节点
		for (Attribute attr : list) {
			System.out.println(attr.getText() + "-----" + attr.getName()
					+ "---" + attr.getValue());
		}

		if (!(node.getTextTrim().equals(""))) {
			System.out.println("文本内容：：：：" + node.getText());
		}

		// 当前节点下面子节点迭代器
		Iterator<Element> it = node.elementIterator();
		// 遍历
		while (it.hasNext()) {
			// 获取某个子节点对象
			Element e = it.next();
			// 对子节点进行遍历
			listNodes(e);
		}
	}

	/**
	 * 介绍Element中的element方法和elements方法的使用
	 * 
	 * @param node
	 */
	public void elementMethod(Element node) {
		// 获取node节点中，子节点的元素名称为西游记的元素节点。
		Element e = node.element("西游记");
		// 获取西游记元素节点中，子节点为做者的元素节点(能够看到只能获取第一个做者元素节点)
		Element author = e.element("做者");

		System.out.println(e.getName() + "----" + author.getText());

		// 获取西游记这个元素节点 中，全部子节点名称为做者元素的节点 。

		List<Element> authors = e.elements("做者");
		for (Element aut : authors) {
			System.out.println(aut.getText());
		}

		// 获取西游记这个元素节点 全部元素的子节点。
		List<Element> elements = e.elements();

		for (Element el : elements) {
			System.out.println(el.getText());
		}

	}

}

SAX解析：
c++

主要是要复写DefaultHandler类,而后在类中调用便可dom

package saxXml;

import java.io.IOException;
import java.util.List;

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

import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;

public class SAXxml {
	public static void main(String[] args) throws ParserConfigurationException, SAXException{
		//建立解析工厂
		SAXParserFactory factory=SAXParserFactory.newInstance();
		//获得解析器
		SAXParser parse=factory.newSAXParser();
		//获得读取器
		XMLReader reader=  parse.getXMLReader();
		//设置内容处理器
		BeanListHandler beanListHandler=new BeanListHandler();
		reader.setContentHandler(beanListHandler);
		
		//读取文档内容:
		try {
			reader.parse("src/saxXml/bookXml.xml");
			//reader.parse("\\src\\saxXml\\bookXml.xml");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		List<Book> list= beanListHandler.getBooks();
		System.out.println("list 数量"+list.size());
		//遍历获取取得的内容
		for(int i=0;i<list.size();i++){
			System.out.println(i);
			Book book=list.get(i);
			System.out.print("name:"+book.getName());
			System.out.print("author"+book.getAuthor());
			System.out.print("price"+book.getPrice());
			System.out.println();
		}
	}
}

BeanListHandler类：

package saxXml;

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

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

//将XML中的每本书封装到Book中
public class BeanListHandler extends DefaultHandler{
	private List books=new ArrayList();
	private String currentTag;
	private Book book;
	
	public List getBooks(){
		return books;
	}
	
	@Override
	public void characters(char[] ch, int start, int length)
			throws SAXException {
		System.out.println("字符串"+currentTag+new String(ch,start,length)+";");
		if("name".equals(currentTag)){
			book.setName(new String(ch,start,length));
			book.getName();
//			System.out.println("姓名");
//			System.out.println("tag:"+book.getName());
		}
		if("author".equals(currentTag)){
			book.setAuthor(new String(ch,start,length));
		}
		if("price".equals(currentTag)){
			book.setPrice(new String(ch,start,length));
		}
	}

	@Override
	public void endElement(String uri, String localName, String qName)
			throws SAXException {
		if(qName.equals("book")){
			books.add(book);
			System.out.println("name:"+book.getName());
			book=null;
		}
	}

	@Override
	public void startElement(String uri, String localName, String qName,
			Attributes attributes) throws SAXException {
		//+uri+";"+localName+";"  +attributes
		currentTag=qName;
		System.out.println("startElement:"+qName+";"+currentTag);
		if("book".equals(qName)){
			book=new Book();
			System.out.println("start");
		}
	}
}

XML文件：

<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
	<book>
		<name>java</name>
		<author>minyi</author>
		<price>cpp</price>
	</book>
	
	<book>
		<name>c++</name>
		<author>zhouhui</author>
		<price>stl</price>
	</book>
</bookstore>

STAX解析：ide

SAX也是基于事件处理xml文档，但倒是用推模式解析，解析器解析完整个xml文档后，才产生解析事件，而后推给程序去处理这些事件。SAX中解析器是工做主体，而事件处理器是由解析器驱动的，若是解析文档过程当中产生问题，则剩余的全部文档就没法处理。
StAX使用拉模式，解析器首先将XML文档全部的事件所有取出，而后经过处理程序处理这些事件。StAX中处理器是工做主体，若是解析文档过程当中产生问题，只会影响到出问题的部分，其他部分处理不受影响

package staxXml;

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;
import java.util.Timer;
import java.util.TimerTask;

import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartDocument;
import javax.xml.stream.events.XMLEvent;

public class Scheduler {
	 private static final String TAG_ITEM = "item";  
	 private static final String TAG_TASK = "task";  
	      
	 private static final String TAG_STRATEGY = "strategy";  
	 private static final String STRATEGE_REPEAT = "repeat";  
	 private static final String STRATEGE_DAILY = "daily";  
	      
	 private static final String TAG_REPEATFREQ = "repeatFreq";  
	 private static final String TAG_DAILYRUNTIME = "dailyRuntime";
	 
	 void readConfig(){
		 //建立解析工厂
		 XMLInputFactory inputFactory= XMLInputFactory.newInstance();
		 inputFactory.setProperty("javax.xml.stream.isCoalescing", true);//避免读取多行数据时出现问题
		 
		 //简历一个新的eventReader
		 InputStream in = new FileInputStream(Global.SERVICE_CONFIGURE_FILE);  
         XMLEventReader eventReader = inputFactory.createXMLEventReader(in);  
         
         // One specification  
         String task     = null;  
         String strategy = null;  
         Integer freq    = null;// by second 
         
      // for daily job  
         Date firstTime  = null;  
         Calendar calendar = Calendar.getInstance();
         
         while(eventReader.hasNext()){
        	XMLEvent event=(XMLEvent) eventReader.next();
        	//判断其实开始仍是结束标签
        	if(event.isStartElement()){
        		StartDocument startElement= (StartDocument) event.asStartElement();
        		//判断其是哪一个标签
        		if (((EndElement) startElement).getName().getLocalPart().equals(TAG_ITEM)) {  
                    /* 
                        Iterator<Attribute> attributes = startElement.getAttributes(); 
                        while (attributes.hasNext()) { 
                            attributes.next(); 
                            // skip 
                        } 
                    */  
                    } 
        		if (event.asStartElement().getName().getLocalPart().equals(TAG_TASK)) {  
                    event = eventReader.nextEvent();  
                    task = event.asCharacters().getData();  
                    continue;  
                }
        		if (event.asStartElement().getName().getLocalPart().equals(TAG_STRATEGY)) {  
                    event = eventReader.nextEvent();  
                    strategy = event.asCharacters().getData();  
                      
                    continue;  
                }  
                  
                if (event.asStartElement().getName().getLocalPart().equals(TAG_REPEATFREQ)) {  
                    event = eventReader.nextEvent();  
                    freq = Integer.parseInt(event.asCharacters().getData());  
                      
                    continue;  
                }  
                  
                if (event.asStartElement().getName().getLocalPart().equals(TAG_DAILYRUNTIME)) {  
                    event = eventReader.nextEvent();  
                      
                    // hour:min:sec  
                    Scanner scanner = new Scanner(event.asCharacters().getData());  
                    scanner.useDelimiter(":");  
                      
                    int hour = scanner.nextInt();  
                    int minute = scanner.nextInt();  
                    int second = scanner.nextInt();  
                      
                    // firstTime (today)  
                    calendar.set(Calendar.HOUR_OF_DAY, hour);    
                    calendar.set(Calendar.MINUTE, minute);    
                    calendar.set(Calendar.SECOND, second);    
                    firstTime = calendar.getTime();  
                  
                    continue;  
                } 
        	}
        	
        	//若是是结束标签
        	if(event.isEndElement()){
        		EndElement endElement=event.asEndElement();
        		if(endElement.getName().getLocalPart().equals(TAG_ITEM)){
        			Timer timer=new Timer();
        			
        			if(strategy.equals(STRATEGE_REPEAT)) {  
                        
                        Class<?> clz = Class.forName(Global.TASK_PACKAGE_PREFIX + task);  
                        TimerTask ctr = (TimerTask)clz.newInstance();  
                          
                        timer.schedule(ctr, 0, freq*1000);  
                          
                    } else if(strategy.equals(STRATEGE_DAILY)){  
                          
                        Class<?> clz = Class.forName(Global.TASK_PACKAGE_PREFIX + task);  
                        TimerTask ctr = (TimerTask)clz.newInstance();  
                          
                        timer.schedule(ctr, firstTime, Global.PERIOD_DAY);  
                    } else {  
                        _logger.error("Unexpected configuration option "+ strategy +" in " + Global.SERVICE_CONFIGURE_FILE);  
                    }  
        		}
        	}
         }
	 }
}

参考文章：性能

dom4j： http://blog.csdn.net/redarmy_chen/article/details/12969219 ui

stax: http://blog.csdn.net/chjttony/article/details/6125123 编码

http://blog.csdn.net/ro_wsy/article/details/8246882 .net