Java 四种创建解析XML方法 XML学习

比眉伴天荒 2022-10-26 03:51 384阅读 0赞

### Java 创建 解析XML ###

*  创建解析XMl
 *   *  四中解析方式的归纳和总结
     *   *  基础解析方式
         *  SAX ：基于事件驱动的解析方式。
         *  扩展解析方式 ：需要导入相应的的jar包，只有在Java中才能使用
 *  创建XML
 *  解析XML
 *  XML 简介
 *   *  XML 是什么？
     *  XML 与 HTML 的主要差异
 *  XML 的用途
 *   *  XML 把数据从 HTML 分离
     *  XML 简化数据共享
     *  XML 简化数据传输
     *  XML 用于创建新的 Internet 语言
 *  XML 树结构
 *   *  一个 XML 文档实例
 *  XML 语法规则
 *   *  CDATA 可以不适用特殊字符转义
 *  XML命名规范
 *  XML 属性

# 创建解析XMl #

为什么要使用XML：

*  不同应用程序之间的通信
 *  不同平台间通信
 *  不同平台之间的数据共享

## 四中解析方式的归纳和总结 ##

### 基础解析方式 ###

不需要导入jar包 DOM：平台无关的官方解析。  
解析时：一次性将xml文件加载至内存，生成DOM树，比较 耗内存  
优点：形成了树型结构，直观好理解，代码更容易编写。  
解析过程中结构保存在内存中，方便修改。  
缺点：当xml文件较大时，对内存消耗比较大，容易影响解析性能并造成内存溢出。

### SAX ：基于事件驱动的解析方式。 ###

优点：采用事件驱动模式，对内存消耗较少 适用于只需要处理xml中数据时  
缺点：不易编码 很难同时访问同一个xml中的多处不同数据

### 扩展解析方式 ：需要导入相应的的jar包，只有在Java中才能使用 ###

JDOM ：仅使用具体类而不使用接口  
API大量使用Collections类

DOM4J：JDOM的一种智能分支，它合并了许多超出基本XML文档表示的功能。如： dtd、Scheme等

*  使用接口和抽象基本类方法，是一个优秀的Java xml api
 *  具有性能优异、灵活性好、功能强大和极端易用的特点 是一个开放源代码的软件

**总结：由于DOM4J的出众，项目中使用DOM4J的较多。**

# 创建XML #

package com.create.test;
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.parsers.ParserConfigurationException;
    import javax.xml.transform.OutputKeys;
    import javax.xml.transform.Result;
    import javax.xml.transform.Transformer;
    import javax.xml.transform.TransformerConfigurationException;
    import javax.xml.transform.TransformerException;
    import javax.xml.transform.TransformerFactory;
    import javax.xml.transform.dom.DOMSource;
    import javax.xml.transform.sax.SAXTransformerFactory;
    import javax.xml.transform.sax.TransformerHandler;
    import javax.xml.transform.stream.StreamResult;
    
    import org.dom4j.DocumentHelper;
    import org.dom4j.io.OutputFormat;
    import org.dom4j.io.XMLWriter;
    import org.jdom2.output.Format;
    import org.jdom2.output.XMLOutputter;
    import org.junit.Test;
    import org.w3c.dom.Document;
    import org.w3c.dom.Element;
    import org.xml.sax.SAXException;
    import org.xml.sax.helpers.AttributesImpl;
    
    
    public class CreateTest { 
    
    	/** * DOM方式生成xml文档 */
    	private void DOMCreateXML() { 
    		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    		DocumentBuilder db = null;
    		try { 
    			db = dbf.newDocumentBuilder();
    		} catch (ParserConfigurationException e) { 
    			e.printStackTrace();
    		}
    		Document document = db.newDocument();
    		document.setXmlStandalone(true);
    		Element bookstore = document.createElement("bookStore");
    		Element book = document.createElement("book");
    		Element name = document.createElement("name");
    		name.setTextContent("小王子");
    		book.appendChild(name);
    		book.setAttribute("id", "1");
    		bookstore.appendChild(book);
    		document.appendChild(bookstore);
    		TransformerFactory tff = TransformerFactory.newInstance();
    		try { 
    			Transformer tf = tff.newTransformer();
    			tf.setOutputProperty(OutputKeys.INDENT, "yes");
    			tf.transform(new DOMSource(document), new StreamResult(new File(
    					"books1.xml")));
    		} catch (TransformerConfigurationException e) { 
    			e.printStackTrace();
    		} catch (TransformerException e) { 
    			e.printStackTrace();
    		}
    	}
    	
    	/** * SAX方式生成xml文档 */
    	public void SAXCreateXML() { 
    		SAXTransformerFactory tff = (SAXTransformerFactory) SAXTransformerFactory
    				.newInstance();
    		try { 
    			TransformerHandler handler = tff.newTransformerHandler();
    			Transformer tr = handler.getTransformer();
    			tr.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
    			tr.setOutputProperty(OutputKeys.INDENT, "yes");
    			File f = new File("books2.xml");
    			if (!f.exists()) { 
    				f.createNewFile();
    			}
    			Result result = new StreamResult(new FileOutputStream(f));
    			handler.setResult(result);
    			handler.startDocument();
    			AttributesImpl attr = new AttributesImpl();
    			handler.startElement("", "", "bookstore", attr);
    			attr.clear();
    			attr.addAttribute("", "", "id", "", "1");
    			handler.startElement("", "", "book", attr);
    			attr.clear();
    			handler.startElement("", "", "name", attr);
    			handler.characters("小王子".toCharArray(), 0, "小王子".length());
    			handler.endElement("", "", "name");
    		
    			handler.endElement("", "", "book");
    			handler.endElement("", "", "bookstore");
    			handler.endDocument();
    
    		} catch (TransformerConfigurationException e) { 
    			e.printStackTrace();
    		} catch (FileNotFoundException e) { 
    			e.printStackTrace();
    		} catch (IOException e) { 
    			e.printStackTrace();
    		} catch (SAXException e) { 
    			e.printStackTrace();
    		}
    	}
    	
    	/** * JDOM方式生成xml文档 */
    	private void JDOMCreateXML() { 
    		org.jdom2.Element bookstore = new org.jdom2.Element("bookstore");
    		org.jdom2.Document document = new org.jdom2.Document(bookstore);
    		
    		org.jdom2.Element book = new org.jdom2.Element("book");
    		book.setAttribute("id", "1");
    		org.jdom2.Element name = new org.jdom2.Element("name");
    		name.setText("小王子");
    		book.addContent(name);
    		bookstore.addContent(book);
    		Format format = Format.getCompactFormat();
    		format.setIndent("");
    		format.setEncoding("UTF-8");
    		XMLOutputter outputer = new XMLOutputter(format);
    		try { 
    			outputer.output(document, new FileOutputStream(new File("books3.xml")));
    		} catch (FileNotFoundException e) { 
    			e.printStackTrace();
    		} catch (IOException e) { 
    			e.printStackTrace();
    		}
    	}
    	
    	/** * DOM4J方式生成xml文档 */
    	private void DOM4JCreateXML(){ 
    		org.dom4j.Document document = DocumentHelper.createDocument();
    		org.dom4j.Element bookstore = document.addElement("bookstore");
    		org.dom4j.Element book = bookstore.addElement("book");
    		book.addAttribute("id", "1");
    		org.dom4j.Element name = book.addElement("name");
    		name.setText("小王子");
    		OutputFormat format = OutputFormat.createPrettyPrint();
    		format.setEncoding("UTF-8");
    		File file = new File("books4.xml");
    		XMLWriter writer;
    		try { 
    			writer = new XMLWriter(new FileOutputStream(file), format);
    			writer.setEscapeText(false);
    			writer.write(document);
    			writer.close();
    		} catch (IOException e) { 
    			e.printStackTrace();
    		}
    	}
    
    	@Test
    	public void testPerformance() throws Exception{ 
    		System.out.println("性能测试:");
    		//测试DOM的性能:
    		long start = System.currentTimeMillis();
    		DOMCreateXML();
    		System.out.println("DOM:"+ (System.currentTimeMillis() - start));
    		//测试SAX的性能:
    		start = System.currentTimeMillis();
    		SAXCreateXML();
    		System.out.println("SAX:"+ (System.currentTimeMillis() - start) );
    		//测试JDOM的性能:
    		start = System.currentTimeMillis();
    		JDOMCreateXML();
    		System.out.println("JDOM:"+ (System.currentTimeMillis() - start) );
    		//测试DOM4J的性能:
    		start = System.currentTimeMillis();
    		DOM4JCreateXML();
    		System.out.println("DOM4J:"+ (System.currentTimeMillis() - start) );
    	}
    }

# 解析XML #

package com.parser.test;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.parsers.ParserConfigurationException;
    import javax.xml.parsers.SAXParser;
    import javax.xml.parsers.SAXParserFactory;
    
    import org.dom4j.DocumentException;
    import org.dom4j.io.SAXReader;
    import org.jdom2.Attribute;
    import org.jdom2.JDOMException;
    import org.jdom2.input.SAXBuilder;
    import org.junit.Test;
    import org.w3c.dom.Document;
    import org.w3c.dom.Element;
    import org.w3c.dom.NamedNodeMap;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    import org.xml.sax.SAXException;
    
    import com.imooc.entity.Book;
    import com.imooc.handler.SAXParserHandler;
    
    public class ParseTest { 
    
    
    	public void domXmlParser() { 
    		ArrayList<Book> bookLists = new ArrayList<Book>();
    		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    		try { 
    			DocumentBuilder db = dbf.newDocumentBuilder();
    			Document document = db.parse("books.xml");
    			NodeList bookList = document.getElementsByTagName("book");
    			for (int i = 0; i < bookList.getLength(); i++) { 
    				Node book = bookList.item(i);
    				Book bookEntity = new Book();
    				NamedNodeMap attrs = book.getAttributes();
    				for (int j = 0; j < attrs.getLength(); j++) { 
    					Node attr = attrs.item(j);
    					if (attr.getNodeName().equals("id")) { 
    						bookEntity.setId(attr.getNodeValue());
    					}
    				}
    				NodeList childNodes = book.getChildNodes();
    				for (int k = 0; k < childNodes.getLength(); k++) { 
    					if (childNodes.item(k).getNodeType() == Node.ELEMENT_NODE) { 
    						String name = childNodes.item(k).getNodeName();
    						String value = childNodes.item(k).getFirstChild().getNodeValue();
    						if (name.equals("name")) { 
    							bookEntity.setName(value);
    						}
    						else if (name.equals("author")) { 
    							bookEntity.setAuthor(value);
    						}
    						else if (name.equals("year")) { 
    							bookEntity.setYear(value);
    						}
    						else if (name.equals("price")) { 
    							bookEntity.setPrice(value);
    						}
    						else if (name.equals("language")) { 
    							bookEntity.setLanguage(value);
    						}
    					}
    				}
    				bookLists.add(bookEntity);
    				bookEntity = null;
    			}
    		} catch (ParserConfigurationException e) { 
    			e.printStackTrace();
    		} catch (SAXException e) { 
    			e.printStackTrace();
    		} catch (IOException e) { 
    			e.printStackTrace();
    		}
    	}
    	
    	public void saxXmlParser(){ 
    		SAXParserFactory factory = SAXParserFactory.newInstance();
    		try { 
    			SAXParser parser = factory.newSAXParser();
    			SAXParserHandler handler = new SAXParserHandler();
    			parser.parse("books.xml", handler);
    		} catch (ParserConfigurationException e) { 
    			e.printStackTrace();
    		} catch (SAXException e) { 
    			e.printStackTrace();
    		} catch (IOException e) { 
    			e.printStackTrace();
    		}
    	}
    	
    	public void jdomXmlParser() { 
    		ArrayList<Book> booksList = new ArrayList<Book>();
    		SAXBuilder saxBuilder = new SAXBuilder();
    		InputStream in;
    		try { 
    			in = new FileInputStream("books.xml");
    			InputStreamReader isr = new InputStreamReader(in, "UTF-8");
    			org.jdom2.Document document = saxBuilder.build(isr);
    			org.jdom2.Element rootElement = document.getRootElement();
    			List<org.jdom2.Element> bookList = rootElement.getChildren();
    			for (org.jdom2.Element book : bookList) { 
    				Book bookEntity = new Book();
    				List<Attribute> attrList = book.getAttributes();
    				for (Attribute attr : attrList) { 
    					String attrName = attr.getName();
    					String attrValue = attr.getValue();
    					if (attrName.equals("id")) { 
    						bookEntity.setId(attrValue);
    					}
    				}
    				List<org.jdom2.Element> bookChilds = book.getChildren();
    				for (org.jdom2.Element child : bookChilds) { 
    					if (child.getName().equals("name")) { 
    						bookEntity.setName(child.getValue());
    					}
    					else if (child.getName().equals("author")) { 
    						bookEntity.setAuthor(child.getValue());
    					}
    					else if (child.getName().equals("year")) { 
    						bookEntity.setYear(child.getValue());
    					}
    					else if (child.getName().equals("price")) { 
    						bookEntity.setPrice(child.getValue());
    					}
    					else if (child.getName().equals("language")) { 
    						bookEntity.setLanguage(child.getValue());
    					}
    				}
    				booksList.add(bookEntity);
    				bookEntity = null;
    			}
    		} catch (FileNotFoundException e) { 
    			e.printStackTrace();
    		} catch (JDOMException e) { 
    			e.printStackTrace();
    		} catch (IOException e) { 
    			e.printStackTrace();
    		}
    
    	}
    	
    	public void dom4jXmlParser(){ 
    		ArrayList<Book> booksList = new ArrayList<Book>();
    		SAXReader reader = new SAXReader();
    		try { 
    			org.dom4j.Document document = reader.read(new File("books.xml"));
    			org.dom4j.Element bookStore = document.getRootElement();
    			List<org.dom4j.Element> bookEles = bookStore.elements();
    			for (org.dom4j.Element book : bookEles) { 
    				Book bookEntity = new Book();
    				List<org.dom4j.Attribute> bookAttrs = book.attributes();
    				for (org.dom4j.Attribute attr : bookAttrs) { 
    					if (attr.getName().equals("id")) { 
    						bookEntity.setId(attr.getValue());
    					}
    				}
    				List<org.dom4j.Element> bookss = book.elements();
    				for (org.dom4j.Element bookChild : bookss) { 
    					String name = bookChild.getName();
    					String value = bookChild.getStringValue();
    					if (name.equals("name")) { 
    						bookEntity.setName(value);
    					}
    					else if (name.equals("author")) { 
    						bookEntity.setAuthor(value);
    					}
    					else if (name.equals("year")) { 
    						bookEntity.setYear(value);
    					}
    					else if (name.equals("price")) { 
    						bookEntity.setPrice(value);
    					}
    					else if (name.equals("language")) { 
    						bookEntity.setLanguage(value);
    					}
    				}
    				booksList.add(bookEntity);
    				bookEntity = null;
    			}
    		} catch (DocumentException e) { 
    			e.printStackTrace();
    		}
    	}
    
    	@Test
    	public void testPerformance() throws Exception{ 
    		System.out.println("性能测试:");
    		//测试DOM的性能:
    		long start = System.currentTimeMillis();
    		domXmlParser();
    		System.out.println("DOM:"+ (System.currentTimeMillis() - start) );
    		//测试SAX的性能:
    		start = System.currentTimeMillis();
    		saxXmlParser();
    		System.out.println("SAX:"+ (System.currentTimeMillis() - start) );
    		//测试JDOM的性能:
    		start = System.currentTimeMillis();
    		jdomXmlParser();
    		System.out.println("JDOM:"+ (System.currentTimeMillis() - start) );
    		//测试DOM4J的性能:
    		start = System.currentTimeMillis();
    		dom4jXmlParser();
    		System.out.println("DOM4J:"+ (System.currentTimeMillis() - start) );
    	
    	}
    }

# XML 简介 #

XML 被设计用来传输和存储数据。  
HTML 被设计用来显示数据。

## XML 是什么？ ##

*  XML 指可扩展标记语言（EXtensible Markup Language）
 *  XML 是一种标记语言，类似HTML
 *  XML 的设计宗旨是传输数据
 *  XML标签 需要自己定义
 *  XML 被设计为具有自我描述性

## XML 与 HTML 的主要差异 ##

*  XML 不是 HTML 的替代。
 *  XML 和 HTML 为不同的目的而设计
 *  XML 被设计为传输和存储数据，其焦点是数据的内容。
 *  HTML 被设计用来显示数据，其焦点是数据的外观。
 *  HTML 旨在显示信息，而 XML 旨在传输信息。

# XML 的用途 #

XML 应用于 web 开发的许多方面，常用于简化数据的存储和共享。

## XML 把数据从 HTML 分离 ##

HTML 文档中显示动态数据，每当数据改变时将花费大量的时间来编辑 HTML。

通过 XML，数据能够存储在独立的 XML 文件中。这样你就可以专注于使用 HTML 进行布局和显示，并确保修改底层数据不再需要对 HTML 进行任何的改变。

通过使用几行 JavaScript，就可以读取一个外部 XML 文件，然后更新 HTML 中的数据内容。

## XML 简化数据共享 ##

XML 数据以纯文本格式进行存储，提供了一种独立于软件和硬件的数据存储方法。创建不同应用程序可以共享的数据变得更加容易。

## XML 简化数据传输 ##

通过 XML，可以在不兼容的系统之间轻松地交换数据。以 XML 交换数据降低了这种复杂性。

## XML 用于创建新的 Internet 语言 ##

很多新的 Internet 语言是通过 XML 创建的：其中的例子包括：

*  XHTML - 最新的 HTML 版本
 *  WSDL - 用于描述可用的 web service
 *  WAP 和 WML - 用于手持设备的标记语言
 *  RSS - 用于 RSS feed 的语言
 *  RDF 和 OWL - 用于描述资源和本体
 *  SMIL - 用于描述针针对 web 的多媒体

# XML 树结构 #

**XML 文档形成了一种树结构，它从“根部”开始，然后扩展到“枝叶”。**

## 一个 XML 文档实例 ##

XML 使用简单的具有自我描述性的语法：

<?xml version="1.0" encoding="UTF-8"?>
    <bookstore>
    <book category="COOKING">
      <title lang="en">Everyday Italian</title> 
      <author>Giada De Laurentiis</author> 
      <year>2005</year> 
      <price>30.00</price> 
    </book>
    <book category="CHILDREN">
      <title lang="en">Harry Potter</title> 
      <author>J K. Rowling</author> 
      <year>2005</year> 
      <price>29.99</price> 
    </book>
    <book category="WEB">
      <title lang="en">Learning XML</title> 
      <author>Erik T. Ray</author> 
      <year>2003</year> 
      <price>39.95</price> 
    </book>
    </bookstore>

第一行是 XML 声明。它定义 XML 的版本 (1.0) 和所使用的编码

*元素*

book是bookstore的子元素  
title、author、year、price是book的子元素

<book category="COOKING">
      <title lang="en">Everyday Italian</title> 
      <author>Giada De Laurentiis</author> 
      <year>2005</year> 
      <price>30.00</price> 
    </book>

*元素属性*

category、lang 元素的属性

# XML 语法规则 #

XML 的语法规则很简单，且很有逻辑。

*  元素都有关闭标签
 *  大小写敏感
 *  正确嵌套
 *  必备根元素
 *  属性加引号
 *  特殊符号 大于、小于、单引号、双引号
 *  保留空格

XML 中的注释

## CDATA 可以不适用特殊字符转义 ##

CDATA 部分由 “*<!\[CDATA\[\*" 开始，由 "\*\]\]>*” 结束：

# XML命名规范 #

*  名称可以含字母、数字以及其他的字符
 *  名称**不能以数字或者标点符号开始**
 *  名称不能以字符 “xml”（或者 XML、Xml）开始
 *  名称不能包含空格
 *  名称具有描述性。使用下划线的名称也很不错。
 *  名称应当比较简短，比如：<book\_title>
 *  **避免 “-” 字符。如果您按照这样的方式进行命名**：“first-name”，一些软件会认为你需要提取第一个单词。
 *  **避免 “.” 字符。如果您按照这样的方式进行命名**：“first.name”，一些软件会认为 “name” 是对象 “first” 的属性。
 *  **避免 “:” 字符。冒号会被转换为命名空间来使用**。

# XML 属性 #

XML 元素可以在开始标签中包含属性，类似 HTML。

属性 (Attribute) 提供关于元素的额外（附加）信息。

*  属性必须加引号
 *  属性无法包含多重的值（元素可以）
 *  属性无法描述树结构（元素可以）
 *  属性不易扩展（为未来的变化）
 *  属性难以阅读和维护