JAVA的XML解析

╰半夏微凉° 2024-02-18 17:22 23阅读 0赞

**XML解析**

XML有四种解析方式：DOM，SAX，Jdom，Dom4j

DOM：(Document Object Model, 文档对象模型) 是 W3C 组织推荐的处理 XML 的一种方式。  
  
  
SAX：(Simple API for XML) 不是官方标准，但它是XML社区事实上的标准(相当于是一个民间标准)，几乎所有的 XML 解析器都支持它。  
  
  
Jdom：是第一个java特定模型，简化了与xml的交互并且比使用dom实现更快。  
  
  
Dom4j：是一个简单、灵活的开放源代码的库。Dom4j是由早期开发JDOM的人分离出来而后独立开发的。与JDOM不同的是，dom4j使用接口和抽象基类，虽然Dom4j的API相对要复杂一些，但它提供了比JDOM更好的灵活性。Dom4j是一个非常优秀的Java XML API，具有性能优异、功能强大和极易使用的特点。  
  
  
 （一）DOM解析:  
 采用dom解析，会将xml文档全部载入到内存当中，然后将xml文档  
 中的所有内容转换为tree上的节点(对象)。  
 优点：   
 可以随机解析  
 可以修改文件  
 可以创建xml文件  
 适合解析小文件  
 缺点：  
 不适合解析大文件，对内存要求高  
  
  
  
  
 （二）SAX解析：  
 SAX：基于事件处理的机制  
 sax解析xml文件时，遇到开始标签，结束标签，字符内容，空白字符等都会触发各自的方法。  
  
  
 优点：  
 适合解析大文件，对内存要求不高  
 轻量级的解析数据方式，效率更高   
 缺点：   
 不能随机解析  
 不能修改XML文件，只能进行查询  
  
  
  
  
JAXP介绍(Java API for XMLProcessing)  
JAXP 是J2SE的一部分，它由javax.xml、org.w3c.dom 、org.xml.sax 包及其子包组成.  
在 javax.xml.parsers 包中，定义了几个工厂类，程序员调用这些工厂类，可以得到对xml文档进行解析的 DOM 或 SAX 的解析器对象。   
  
  
\------------------------------------------------------------------------------------------  
  
  
DOM解析：  
1调用DocumentBuilderFactory.newInstance() 方法得到创建 DOM 解析器的工厂。  
2调用工厂对象的newDocumentBuilder方法得到 DOM 解析器对象。  
3调用DOM 解析器对象的 parse() 方法解析 XML 文档，得到代表整个文档的 Document 对象，进而可以利用DOM特性对整个XML文档进行操作。  
  
  
例:  
//获得生产DocumentBuilder对象的工厂实例  
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  
  
  
//设置是否支持名称空间 默认是不支持  
factory.setNamespaceAware(true);  
  
  
//通过工厂获得一个DocumentBuilder对象  
DocumentBuilder builder = factory.newDocumentBuilder();  
  
  
//如果xml中声明了对DTD的引用,则可以这样忽略掉DTD,否则会自动根据地址查找DTD  
//其实就是给builder设置一个自定义的实体解析器(匿名内部类)  
builder.setEntityResolver(new EntityResolver() \{   
 @Override  
 public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException \{   
 byte\[\] data = "<?xml version=\\"1.0\\" encoding=\\"UTF-8\\"?>".getBytes();  
 return new InputSource(new ByteArrayInputStream(data));  
 \}  
\});  
  
  
  
  
//获得Document对象,可以表示一个xml文档  
Document document = builder.parse(fileName);  
  
  
//获得根元素  
//注意Document和Element都是Node的子接口  
Element root = document.getDocumentElement();  
//获取根元素的相关属性  
root.getNodeName()  
//获得根元素下面的所有子元素  
//注意回车换行也算是一个节点(文本节点)  
//xml文件中主要是文本节点和元素节点  
//元素节点中还包含属性节点  
//我们要解析的值就在这些节点中  
//这一步之后就是循环解析节点中的数据（获取节点名称 属性名 属性值...）  
NodeList rootChildNodes = root.getChildNodes();  
System.out.println(root.getNodeName());  
  
  
  
  
DOM创建xml：  
 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  
 DocumentBuilder builder = factory.newDocumentBuilder();  
 Document document = builder.parse(fileName);  
  
 //创建一个stu元素 并且设置属性  
 Element stu = document.createElement("stu");  
 stu.setAttribute("id", s.getId()+"");  
 //创建name和age元素  
 Element name = document.createElement("name");  
 Element age = document.createElement("age");  
 //设置name和age元素中的文本值  
 name.setTextContent(s.getName());  
 age.setTextContent(s.getAge()+"");  
  
 //name和age元素追加到stu元素里面  
 stu.appendChild(name);  
 stu.appendChild(age);  
  
 //stu元素追加到根元素里面（此时文档中并没有真正添加一个元素）  
 document.getDocumentElement().appendChild(stu);  
  
 //得到TransformerFactory工厂实例  
 TransformerFactory tff = TransformerFactory.newInstance();  
 //通过工厂得到一个转换器  
 Transformer tf = tff.newTransformer();  
 //设置编码  
 tf.setOutputProperty(OutputKeys.ENCODING, "UTF-8");  
 //设置格式  
 tf.setOutputProperty(OutputKeys.INDENT, "yes");  
  
 //把一个dom模型转换成对应的xml文件  
 tf.transform(new DOMSource(document), new StreamResult(fileName));  
  
  
  
  
  
  
DOM删除xml的某个节点：  
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  
 DocumentBuilder builder = factory.newDocumentBuilder();  
 Document document = builder.parse(fileName);  
  
 NodeList elementsByTagName = document.getElementsByTagName("stu");  
 for(int i=0;i<elementsByTagName.getLength();i++)\{   
 Node node = elementsByTagName.item(i);  
 String idValue = node.getAttributes().getNamedItem("id").getNodeValue();  
 if(idValue.equals(stu\_id))\{   
 node.getParentNode().removeChild(node);  
 break;  
 \}  
  
 \}  
  
 //得到TransformerFactory工厂实例  
 TransformerFactory tff = TransformerFactory.newInstance();  
 //通过工厂得到一个转换器  
 Transformer tf = tff.newTransformer();  
 //设置编码  
 tf.setOutputProperty(OutputKeys.ENCODING, "UTF-8");  
 //设置格式  
 tf.setOutputProperty(OutputKeys.INDENT, "yes");  
  
 //把一个dom模型转换成对应的xml文件  
 tf.transform(new DOMSource(document), new StreamResult(fileName));  
  
  
  
  
在使用DOM解析XML文档时，需要读取整个XML文档，在内存中构建代表整个DOM 树的Doucment对象，从而再对XML文档进行操作。此种情况下，如果XML 文档特别大，就会消耗计算机的大量内存，严重情况下可能还会导致内存溢出。  
  
  
\------------------------------------------------------------------------------------------  
SAX解析：  
  
  
SAX解析允许在读取文档的时候，即对文档进行处理，而不必等到整个文档装载完才会文档进行操作。  
  
  
SAX解析器在发现XML文档中的内容时就会调用程序员自己重写之后的方法， 如何处理这些内容，由自己决定。  
在基于SAX的程序中,有五个最常用SAX事件  
startDocument() ---> 解析器发现了文档的开始标签  
endDocument() ---> 解析器发现了文档结束标签  
startElement() ---> 解析器发现了一个起始标签  
character() ---> 解析器发现了标签里面的文本值  
endElement() ---> 解析器发现了一个结束标签  
  
  
SAX采用事件处理的方式解析XML文件，利用 SAX 解析 XML 文档，涉及两个部分，解析器和事件处理器。  
  
  
解析器可以使用JAXP的API创建，创建出SAX解析器后，就可以指定解析器去解析某个XML文档。  
解析器采用SAX方式在解析某个XML文档时，它只要解析到XML文档的一个组成部分，都会去调用事件处理器的一个方法，解析器在调用事件处理器的方法时，会把当前解析到的XML文件内容作为方法的参数传递给事件处理器。  
  
  
事件处理器由程序员编写，程序员通过事件处理器中方法的参数，就可以得到SAX解析器解析到的数据，从而可以决定如何对数据进行处理。  
  
  
SAX解析步骤：  
使用SAXParserFactory创建SAX解析工厂  
SAXParserFactory spf = SAXParserFactory.newInstance();  
通过SAX解析工厂得到解析器对象   
SAXParser sp = spf.newSAXParser();  
将解析对象和事件处理器对象关联  
sp.parse("src/class.xml", new DefaultHandler()\{...\});  
// DefaultHandler中有五个方法需要重写  
 //解析器发现了文档的开始标签调用的方法  
 public void startDocument() throws SAXException \{   
  
 \}  
 //解析器发现了文档的结束标签调用的方法  
 @Override  
 public void endDocument() throws SAXException \{   
  
  
 \}  
 //解析器发现了一个起始标签调用的方法  
   //uri 命名空间  
  //localName 本地名称（不带前缀）  
  //qName 限定的名称（带有前缀）   
 //attributes 附加到元素的属性  
 @Override  
 public void startElement(String uri, String localName, String qName, Attributes attributes)  
 throws SAXException \{   
  
  
 \}  
 //解析器发现了一个结束标签 调用的方法  
 //uri 命名空间  
  //localName 本地名称 （不带前缀）  
  //qName 限定的名称（带有前缀）   
 @Override  
 public void endElement(String uri, String localName, String qName) throws SAXException \{   
  
 \}  
  
 //解析器发现了标签里面的文本值调用的方法  
 @Override  
 public void characters(char\[\] ch, int start, int length) throws SAXException \{   
  
 \}  
  
\------------------------------------------------------------------------------------------  
  
  
Dom4j解析：  
  
  
\*使用Dom4j解析，需要dom4j的jar包。  
  
  
DOM4j中，获得Document对象的方式有三种：  
  
  
1.读取XML文件,获得document对象   
 SAXReader reader = new SAXReader();   
 Document document = reader.read(new File(“src/input.xml"));  
  
  
2.解析XML形式的文本,得到document对象  
 String text = "<members></members>";   
 Document document = DocumentHelper.parseText(text);  
  
  
3.主动创建document对象  
 Document document = DocumentHelper.createDocument();   
 //创建根节点  
 Element root = document.addElement("members");  
 root.addAttribute("name", "上海");  
 Element num = root.addElement("peopleNumber");  
 num.addText("23343");  
  
  
==========================================================================================  
Dom4j解析实例：  
\------------------------------------------------------------------------------------------  
xml文件：  
  
  
<?xml version="1.0" encoding="UTF-8"?>  
<test>  
<hang1 id="h1">  
<lie1 class="1l1">第1行第1列</lie1>  
<lie2 class="1l2">第1行第2列</lie2>  
</hang1>  
<hang2 id="h2">  
<lie1 class="2l1">第2行第1列</lie1>  
<lie2 class="2l2">第2行第2列</lie2>  
</hang2>  
</test>  
\------------------------------------------------------------------------------------------  
java文件：  
  
  
package dom4j;  
  
  
import java.io.File;  
import java.util.Iterator;  
  
  
import org.dom4j.Document;  
import org.dom4j.DocumentException;  
import org.dom4j.Element;  
import org.dom4j.Node;  
import org.dom4j.io.SAXReader;  
  
  
public class dom4j \{   
 public static void main(String\[\] args) throws Exception \{   
  //获得Document对象  
 SAXReader reader=new SAXReader();  
 Document document=reader.read(new File("src/dom4j/test.xml"));  
 //获得根节点  
 Element root=document.getRootElement();  
 //输出根节点名称  
 System.out.println(root.getName());  
 //获取根节点下的hang1节点（名称已知）  
 Element hang1=root.element("hang1");  
 //获取hang1节点的id属性值（名称已知）  
 System.out.println(hang1.attributeValue("id"));  
 //获取hang1下的lie1节点（名称已知）  
 Element lie1=hang1.element("lie1");  
 //获取lie1节点的class属性值（名称已知）  
 System.out.println(lie1.attributeValue("class"));  
 //获取lie1节点中的内容  
 System.out.println(lie1.getText());  
  
 System.out.println("-----------");  
  
 //遍历root下的子节点  
 Iterator i=root.elementIterator();  
 while(i.hasNext())\{   
 Element e = (Element) i.next();  
 System.out.println(e.getName());  
 \}  
 System.out.println("-----------");  
 //遍历hang1下的子节点  
 Iterator j=hang1.elementIterator();  
 while(j.hasNext())\{   
 Element e = (Element) j.next();  
 System.out.println(e.getName());  
 \}  
 \}  
\}  
  
  
\------------------------------------------------------------------------------------------  
控制台输出：  
  
  
test  
h1  
1l1  
第1行第1列  
\-----------  
hang1  
hang2  
\-----------  
lie1  
lie2  
  
  
====================================================================================