构建自己的轻量级XML DOM分析程序

dom|xml|程序

　　XML正迅快速的成为数据存储和交换的标准格式流行开来了。现在可用的完整的Java XML分析器非常庞大而且功能强大--但是实现这些强大的功能的同时也要消耗等量的资源。举例来说，流行的Apache Xerces-J分析器超过1.7 MB，而最新的完整的Sun JAXP（用于XML处理的Java应用编程接口）实现程序包超过了3MB。因此使用一个功能强大的XML分析器可能过于浪费。如果配置环境是一个Java小程序或者是一个J2ME应用程序，网络带宽或者系统存储器的制约可能根本不能够使用完整的XML分析器。本文将告诉你如何构建一个轻量级的XML DOM分析程序。

　　开始编写SimpleDOMParser

　　SimpleDOMParser是一个使用Java写的高度简化和超轻量级的XML DOM分析器。 你可以将配置整个分析器配置为一个小于4KB的.jar文件。源程序还不到400行呢。

　　显然，使用这么小的代码，SimpleDOMParser将不支持XML域名空间，不能够理解多字符集编码或者以DTD文件或者schema验证文件；但是SimpleDOMParser能做的就是把符合语法规则的XML标记解析为一个类似于DOM的元素树，让你执行从XML格式化文本提取的数据的公共任务。

　　为什么使用DOM作为模型而不是SAX呢？这是因为DOM提供一个比SAX更加易用的程序接口。与SAX不同的是，当你把一个XML文件作为一个DOM树来处理的时候，这个文件内的所有的信息都是可以利用的。虽然SAX分析模型能够提供比DOM模型更加优异的性能和利用更少的存储空间，但是大部分开发者在使用SAX的时候都会发现他们自己正在创建一个完整的或者部分的DOM树。使用SAX，一个应用程序每次只能处理一条标记。如果其它的标记内容在处理的过程中必须被用到，那你就必须在处理的整个过程保持一种全局状态。而保持全局状态正是DOM模型目的的精髓。但是许多小型的XML应用程序不需要完整的DOM模型。因此，SimpleDOMParser提供到标记名、层次和内容的访问，但是不涉及完整的W3C DOM的许多用不上的功能。

　　简化DOM模型

　　一个DOM树是由分析XML文件产生的结点组成。结点是一个XML实体的非存储表现。标准W3C DOM模型有几种类型的结点。 举例来说，一个文本结点表示在XML文件中的一段文本，一个元素结点表示XML文件而一个属性结点表示一个元素内部的属性名和值。

　　DOM是一个树，因为除了根或文件结点以外的每个结点都有一个父结点。举例来说，属性结点总是和一个元素结点相关联，而用来封装元素的起始标记和结束标记中的文本是映射到一个文本结点的。文本结点是元素结点的一个子节点。所以，即使很简单的XML文件的表现也可能会需要很多种节点类型。举例来说，图1表示下面XML文件的一个W3C DOM树形表示。

＜parser＞SimpleDOMParser＜/parser＞

　　正如你在图1中所看见的，DOM模型使用一个document类型节点来封装整个XML文件，所以DOM使用三种不同的节点。通过把所有的DOM节点类型抽象成为一个单独的类型SimpleElement来尽可能的简化DOM模型。一个SimpleElement获得一个XML元素的关键的信息，比如标识名、元素属性和任何封装的文本或者XML。此外，SimpleDOMParser不使用任何特殊的节点类型表示最高等级的文档。结果是大大地简化了DOM树，使之只包含SimpleElement节点。图2表示了简化的DOM树。

　　代码段1给出了SimpleElement类的完整的源程序。

public class SimpleElement {
private String tagName;
private String text;
private HashMap attributes;
private LinkedList childElements;

public SimpleElement(String tagName) {
this.tagName = tagName;
attributes = new HashMap();
childElements = new LinkedList();
}

public String getTagName() {
return tagName;
}

public void setTagName(String tagName) {
this.tagName = tagName;
}

public String getText() {
return text;
}

public void setText(String text) {
this.text = text;
}

public String getAttribute(String name) {
return (String)attributes.get(name);
}

public void setAttribute(String name, String value) {
attributes.put(name, value);
}

public void addChildElement(SimpleElement element) {
childElements.add(element);
}

public Object[] getChildElements() {
return childElements.toArray();
}
}

　定义XML语法分析基本元素

　　为了把一个XML文件处理成为上面提到的简化的DOM树模型，我们必须定义一些基本的语法分析规则。使用这些规则，语法分析程序就能容易地从输入的XML文件中提取标记或者文本块。

　　第一个是peek，从输入的XML文件中返回下一个字符，而实际上则不必从下层流中获得这个字符。通过保持输入流的完整性，高级函数比如readTag和readText（后面将介绍）可以更加容易地根据它们接下来期待的字符获取需要的内容。

private int peek() throws IOException {

reader.mark(1);

int result = reader.read();

reader.reset();

return result;

} 

　　下一个方法是skipWhitespce，作用是跳过输入的XML流中的空格、制表符或者回车符。

private void skipWhitespace() throws IOException {

while (Character.isWhitespace((char) peek())) {

reader.read();

}

} 
 

　　在创建了如上所述的这两个方法后，我们就可以写一个函数从输入文件中检索XML标记。

private String readTag() throws IOException {

skipWhitespace();

StringBuffer sb = new StringBuffer();

int next = peek();

if (next != '＜') {

throw new IOException

("Expected ＞ but got " + (char) next);

}

sb.append((char)reader.read());

while (peek() != '＞') {

sb.append((char)reader.read());

}

sb.append((char)reader.read());

return sb.toString();

} 
 

　　和peek方法联合使用，readTag函数只获得一个标记的内容，而让别的函数去处理其他的内容。 最后的一个方法是readText函数，用来读取XML标记之间的文本。

private String readText() throws IOException {

int[] cdata_start = {'＜', '!',

'[', 'C', 'D', 'A', 'T', 'A', '['};

int[] cdata_end = {']', ']', '＞'};

StringBuffer sb = new StringBuffer();

int[] next = new int[cdata_start.length];

peek(next);

if (compareIntArrays(next, cdata_start) == true) {

// CDATA

reader.skip(next.length);

int[] buffer = new int[cdata_end.length];

while (true) {

peek(buffer);

if (compareIntArrays

(buffer, cdata_end) == true) {

reader.skip(buffer.length);

break;

} else {

sb.append((char)reader.read());

}

}

} else {

while (peek() != '＜') {

sb.append((char)reader.read());

}

}
return sb.toString();

} 

　　这次使用的peek方法是前面那个从基本的XML文档返回一个字符串序列的peek方法的变体。这个peek变体让语法分析程序判断它将分析的文本是否被装入一个CDATA块。 compareIntArrays函数是一个执行两个整数数组的深度比较的简单程序。
　XML语法分析策略和SimpleDOMParser实现

　　与一个正常的文本文档不同的是，一个符号语法规则的XML文档有一些独特的特点，可以促进语法分析工作：

　　在一个XML文档中所有的标记都必须匹配。每个起始标记都必须有一个匹配的结束标记，除了当标记本身就是两个起始和结束标记的时候，比如＜parser/＞就是＜parser＞＜/parser＞的简易格式。标记和属性名称是大小写敏感的。

　　在一个XML文档中所有的标记都必须正确地嵌套。XML标记不可以交叉嵌套。 例如：一个包含＜t1＞＜t2＞... ＜/t1＞＜/t2＞的文档就是错误的，因为结束标记＜/t1＞出现在了结束标记＜/t2＞之前。

　　着眼于这些规则，SimpleDOMParser语法分析策略就应该遵循如下伪代码所示的模式：

While Not EOF(Input XML Document)

Tag = Next tag from the document

LastOpenTag = Top tag in Stack

 

If Tag is an open tag

Add Tag as the child of LastOpenTag

Push Tag in Stack

Else

// 结束标记

If Tag is the matching close tag of LastOpenTag

Pop Stack

If Stack is empty

Parse is complete

End If

Else

// 无效标记嵌套

Report error

End If

End If

End While 

　　这算法的关键就是标记堆栈，它可以保存从输入文件中获得的但是没有与它们结束标记匹配的起始标记。堆栈的顶部总是最后的一个起始标记。

　　除第一个标记以外，每个新的起始标记将是上一个起始标记的子标记。所以语法分析程序把新的标记添加为上一个起始标记的子标记，然后把它推到堆栈的顶部，它就成了最新的起始标记。 另一方面，如果输入标记是一个结束标记，它必须匹配最后一个起始标记。 基于正确嵌套规则，一个不匹配结束标记会出现XML语法错误。 当结束标记匹配最后一个起始标记，语法分析程序从堆栈中弹出最后一个起始标记，因为对于这个标记的分析是完整的。这个处理继续下去，直到堆栈为空为止。此时，你就完成了整个文档的语法分析过程。代码段2给出了SimpleDOMParser.parse方法的整个源代码。

SimpleDOMParser.java

package simpledomparser;

import java.io.Reader;
import java.io.IOException;
import java.io.EOFException;
import java.util.Stack;

public class SimpleDOMParser {
private static final int[] cdata_start = {'＜', '!', '[', 'C', 'D', 'A', 'T', 'A', '['};
private static final int[] cdata_end = {']', ']', '＞'};

private Reader reader;
private Stack elements;
private SimpleElement currentElement;

public SimpleDOMParser() {
elements = new Stack();
currentElement = null;
}

public SimpleElement parse(Reader reader) throws IOException {
this.reader = reader;

skipPrologs();

while (true) {
int index;
String tagName;

String currentTag = readTag().trim();
if (currentTag.startsWith("＜/")) {
//结束标记
tagName = currentTag.substring(2, currentTag.length()-1);

//没有起始标记
if (currentElement == null) {
throw new IOException("Got close tag '" + tagName +
"' without open tag.");
}

//结束标记与起始标记不匹配
if (!tagName.equals(currentElement.getTagName())) {
throw new IOException("Expected close tag for '" +
currentElement.getTagName() + "' but got '" +
tagName + "'.");
}

if (elements.empty()) {
//文本处理结束
return currentElement;
} else {
//弹出前面的起始标记
currentElement = (SimpleElement)elements.pop();
}
} else {
// 起始标记或者带有起始标记和结束标记的标记
index = currentTag.indexOf(" ");
if (index ＜ 0) {
// 不带属性的标记
if (currentTag.endsWith("/＞")) {

tagName = currentTag.substring(1, currentTag.length()-2);
currentTag = "/＞";
} else {
// 起始标记
tagName = currentTag.substring(1, currentTag.length()-1);
currentTag = "";
}
} else {
// 带有属性的标记
tagName = currentTag.substring(1, index);
currentTag = currentTag.substring(index+1);
}

//创建元素
SimpleElement element = new SimpleElement(tagName);

//分析属性
boolean isTagClosed = false;
while (currentTag.length() ＞ 0) {

currentTag = currentTag.trim();

if (currentTag.equals("/＞")) {
//结束标记
isTagClosed = true;
break;
} else if (currentTag.equals("＞")) {
//起始标记
break;
}

index = currentTag.indexOf("=");
if (index ＜ 0) {
throw new IOException("Invalid attribute for tag '" +
tagName + "'.");
}

// 取得属性名
String attributeName = currentTag.substring(0, index);
currentTag = currentTag.substring(index+1);

// 取得属性值
String attributeValue;
boolean isQuoted = true;
if (currentTag.startsWith("\"")) {
index = currentTag.indexOf('"', 1);
} else if (currentTag.startsWith("'")) {
index = currentTag.indexOf('\'', 1);
} else {
isQuoted = false;
index = currentTag.indexOf(' ');
if (index ＜ 0) {
index = currentTag.indexOf('＞');
if (index ＜ 0) {
index = currentTag.indexOf('/');
}
}
}

if (index ＜ 0) {
throw new IOException("Invalid attribute for tag '" +
tagName + "'.");
}

if (isQuoted) {
attributeValue = currentTag.substring(1, index);
} else {
attributeValue = currentTag.substring(0, index);
}

// 添加属性到新的元素中
element.setAttribute(attributeName, attributeValue);

currentTag = currentTag.substring(index+1);
}

// 读取起始标记和结束标记之间的文本
if (!isTagClosed) {
element.setText(readText());
}

// 添加一个新的元素作为目前元素的子元素
if (currentElement != null) {
currentElement.addChildElement(element);
}

if (!isTagClosed) {
if (currentElement != null) {
elements.push(currentElement);
}

currentElement = element;
} else if (currentElement == null) {
// 在文档中只有一个标记
return element;
}
}
}
}

private int peek() throws IOException {
reader.mark(1);
int result = reader.read();
reader.reset();

return result;
}

private void peek(int[] buffer) throws IOException {
reader.mark(buffer.length);
for (int i=0; i＜buffer.length; i++) {
buffer[i] = reader.read();
}
reader.reset();
}

private void skipWhitespace() throws IOException {
while (Character.isWhitespace((char)peek())) {
reader.read();
}
}

private void skipProlog() throws IOException {
//跳过"＜?" or "＜!"
reader.skip(2);

while (true) {
int next = peek();

if (next == '＞') {
reader.read();
break;
} else if (next == '＜') {

skipProlog();
} else {
reader.read();
}
}
}

private void skipPrologs() throws IOException {
while (true) {
skipWhitespace();

int[] next = new int[2];
peek(next);

if (next[0] != '＜') {
throw new IOException("Expected '＜' but got '" + (char)next[0] + "'.");
}

if ((next[1] == '?') || (next[1] == '!')) {
skipProlog();
} else {
break;
}
}
}

private String readTag() throws IOException {
skipWhitespace();

StringBuffer sb = new StringBuffer();

int next = peek();
if (next != '＜') {
throw new IOException("Expected ＜ but got " + (char)next);
}

sb.append((char)reader.read());
while (peek() != '＞') {
sb.append((char)reader.read());
}
sb.append((char)reader.read());

return sb.toString();
}

private String readText() throws IOException {
StringBuffer sb = new StringBuffer();

int[] next = new int[cdata_start.length];
peek(next);
if (compareIntArrays(next, cdata_start) == true) {
// CDATA
reader.skip(next.length);

int[] buffer = new int[cdata_end.length];
while (true) {
peek(buffer);

if (compareIntArrays(buffer, cdata_end) == true) {
reader.skip(buffer.length);
break;
} else {
sb.append((char)reader.read());
}
}
} else {
while (peek() != '＜') {
sb.append((char)reader.read());
}
}

return sb.toString();
}

private boolean compareIntArrays(int[] a1, int[] a2) {
if (a1.length != a2.length) {
return false;
}

for (int i=0; i＜a1.length; i++) {
if (a1[i] != a2[i]) {
return false;
}
}

return true;
}
} 

　　为了简单起见，SimpleDOMParser不允许在XML文档中使用注解，并且完全忽视XML声明和DOCTYPE。它使用下面的程序来跳过XML声明和DOCTYPE元素。这个程序递归调用它本身，就像处理一个内部DTD一样处理DOCTYPE。

private void skipProlog() throws IOException {

//跳过"＜?"或者 "＜!"

reader.skip(2);

while (true) {

int next = peek();

if (next == '＞') {

reader.read();

break;

} else if (next == '＜') {

skipProlog();

} else {

reader.read();

}

}

}
 

　　虽然本文中介绍的SimpleDOMParser只有有限的功能，但是对于许多简单的应用程序来说，它仍然是非常有用的。比如说，一个Java applet可以使用它以XML格式传送数据到一个后端服务器应用程序中。因为它是极其轻便的，所以SimpleDOMParser在资源非常有限的环境中更是很有吸引力的。此外，SimpleDOMParser的实现还很简单。虽然目前的实现只能保存元素，而不能保存声明或者DOCTYPE，但是你可以修改它来处理你想要处理的XML文本，而这一切都是非常容易的。

 

时间： 2024-04-27 00:07:31

构建自己的轻量级XML DOM分析程序的相关文章

微软XML分析程序介绍

xml|程序|微软 一,Microsoft XML Parser名称     目前微软XML分析程序被称为Microsoft XML Core Services(MSXML),以前被叫做Microsoft XML Parser,可见XML在微软产品中的地位是越来越重要,已经不再仅仅作为解析器了. 二,MSXML的版本     MSXML最早的版本是1.0,最新的版本为4.0 SP1版本列表: Version File name File version 1.0 msxml.dll 4.71.17

用PHP读取和编写XML DOM的实现代码

用 PHP 读取和编写可扩展标记语言(XML)看起来可能有点恐怖.实际上,XML 和它的所有相关技术可能是恐怖的,但是用 PHP 读取和编写 XML 不一定是项恐怖的任务.首先,需要学习一点关于 XML 的知识 -- 它是什么,用它做什么.然后,需要学习如何用 PHP 读取和编写 XML,而有许多种方式可以做这件事. 本文提供了 XML 的简短入门,然后解释如何用 PHP 读取和编写 XML. 什么是 XML? XML 是一种数据存储格式.它没有定义保存什么数据,也没有定义数据的格式.XML 只

IE中的XML DOM

dom|xml 当微软在IE 5.0中第一次加入对XML支持时,他们只是在MSXML ActiveX库(最初是为了在IE 4.0中解析Active Channels的组件)中实现XML的功能.最初的版本并没有打算公开使用,然而随着开发人员逐渐了解这个组件并尝试使用时,微软才意识到这个库的重要性,很快就在IE 4.01中发布了MSXML完全升级版本.MSXML最初还只是IE的一个组件.直到2001年,微软发布了MSXML 3.0,这是一个通过其公司网站独立发布的产品.在2001年晚些时候,微软又发

使用XML DOM生成XML(1)

dom|xml|生成xml  <--编者按:随着 XML 在网络开发中的应用的不断深入,该语言的复杂度在增加,你可以在本文对XML的新对象库XML DOM的介绍中体会到这一点-->      正如你所了解的,XML是个功能强大的新型数据结构,它可以让你把网页的内容和表现形式分开.尽管如此,目前,我们的文章大多仅介绍了直接生成XML标记得的法.我们在大多数时候,都是手工编写必需的标记和数据的.      幸运的是,微软提供了XML DOM(XML文档对象模型),这是另外一种编写XML代码的方法.

Java与XML（二）用java编写xml的读写程序

xml|程序 Java与XML(二)用java编写xml的读写程序 这是读取xml文件的java程序,我调试好的.采用的是dom方式读取xml文件到Vector中.package src;import java.io.*;import java.util.Vector;import javax.xml.parsers.*;import org.w3c.dom.*;public class readxml { static Document document; private boolean va

objective c-不使用分析程序在XMLNSString中提取值

问题描述 不使用分析程序在XMLNSString中提取值 string如下: <?xml version="1.0" encoding="utf-8"?> <NewDataSet> <Table> <CITY>Jupiter</CITY> <STATE>FL</STATE> <ZIP>33477</ZIP> <AREA_CODE>561</A

php轻量级的性能分析工具xhprof的安装使用_php技巧

一.前言 有用的东西还是记录下来吧,也方便以后的查询:这次记录一下xhprof的安装使用: xhprof是facebook开源出来的一个php轻量级的性能分析工具,跟Xdebug类似,但性能开销更低, 还可以用在生产环境中,也可以由程序开 关来控制是否进行profile. 二.安装 wget http://pecl.php.net/get/xhprof-0.9.3.tgz tar zxf xhprof-0.9.3.tgz cd xhprof-0.9.3/extension /usr/bin/ph

PHP XML DOM

PHP XML DOM 内置的DOM解析器可以处理XML文档在PHP .   这里是什么? 的W3C DOM提供了一套标准的对象为HTML和XML文件,以及一个标准的接口用于访问和操纵它们. 的W3C DOM分为不同部分(核心, XML和HTML )和不同层次( 1/2/3级的DOM ) : *核心的DOM 定义一套标准的对象结构的任何文件 *的XML的DOM 定义一套标准的对象的X ML文件 *的HTML的DOM 定义一套标准的对象为H TML文件 如果您想了解更多有关的XML的DOM ,请访

用PHP读取和编写XML DOM

dom|xml     有许多技术可用于用 PHP 读取和编写 XML.本文提供了三种方法读取 XML:使用 DOM 库.使用 SAX 解析器和使用正则表达式.还介绍了使用 DOM 和 PHP 文本模板编写 XML. 用 PHP 读取和编写可扩展标记语言(XML)看起来可能有点恐怖.实际上,XML 和它的所有相关技术可能是恐怖的,但是用 PHP 读取和编写 XML 不一定是项恐怖的任务.首先,需要学习一点关于 XML 的知识 -- 它是什么,用它做什么.然后,需要学习如何用 PHP 读取和编写