SAX一章中已经编写了包含用于放映的幻灯片的XML文件。然后又使用SAX API将XML回送到显示器。
本章中,将使用文档对象模型(DOM)建立一个小的SlideShow应用程序。首先构建DOM并查看它,然后看看如何编写XML结构的DOM ,将它显示在GUI中,并且操作树结构。
文档对象模型是普通的树结构,每个节点包含一个来自于XML结构的组件。两种最常见的节点类型是元素节点(element node)和文本节点(text node)。使用DOM函数能够创建节点、删除节点、改变节点内容并且遍历节点层次。
本章将解析现有的XML文件以构建DOM,显示并查看DOM的层次结构,将DOM转换成能够友好显示的Jtree,并且展现命名空间的语法。你将从头开始创建一个DOM,并且了解如何使用Sun的JAXP实现的一些特定实现性能将现有的数据集转换成XML。
首先要确信,在你的应用程序中DOM是最好的选择。下一节何时使用DOM将具体介绍它。
注意:可以在下面的页面中找到本章的例子<JWSDP_HOME>/docs/tutorial/examples/jaxp/dom/samples.
何时使用DOM
文档对象模型 (DOM) 是一个文档标准(例如,文章和书)。另外,JAXP 1.2实现支持XML Schema,在任何给定的应用程序中必须慎重考虑这一点。
另外,如果你正在处理简单数据结构,并且XML Schema不是你计划的一部分,那么你可能会发现一个面向对象的标准如JDOM 和dom4j 更加适合于实现你的目标。
DOM从一开始就是一种与语言无关的模型。这是因为它专门用于像C或Perl这类语言,没有利用Java的面向对象的性能。这个事实再加上文档/数据定义,也能帮助解释处理DOM和处理JDOM或dom4j结构之间的区别。
本节中,将讨论遵守这些标准的模型之间的区别,以便能够帮助你为应用程序选择最合适的模型。
文档vs.数据
DOM中使用的文档模型和JDOM或dom4j中使用的数据模型的主要区别在于:
· 层次结构中的节点类型
· “混合内容”的性能
正是构成数据层次结构的 “节点” 的不同造成了这两个模型之间编程的区别。然而,只有混合内容的性能能解释不同标准定义“节点”有何区别。所以,首先来看看DOM的“混合内容模型”。
混合内容模型
回想在对文档-驱动编程 (DDP) 的讨论中,可以将文本和元素自由结合到DOM层次结构中。这种结构被称为DOM模型中的“混合内容”。
文档中经常出现混合内容。例如,为了表示该结构:
<sentence>This is an <bold>important</bold> idea.</sentence>
DOM节点的层次结构看起来跟下面的很像,其中每行代表一个节点:
ELEMENT: sentence
+ TEXT: This is an
+ ELEMENT: bold
+ TEXT: important
+ TEXT: idea.
注意,句元素(sentence element)包含文本,后面跟着子元素,再后面是其他文本。 “混合内容模型”是通过将文本和元素混合起来而定义的。
节点种类
为了提供混合内容的性能,DOM节点生来就非常简单。例如,在前面的例子中,第一个元素的内容 (它的value)简单地标识了节点的类型。
DOM用户第一次通常都会被这个事实迷惑。到访过<sentence> 节点后,他们就想要节点的“内容”,并且想得到其他有用信息。但是,它们得到的是元素的名字“sentence”。
注意:DOM Node API定义了nodeValue()、node.nodeType()和nodeName() 方法。对于第一个元素节点,nodeName() 返回 "sentence",而nodeValue() 返回空。对于第一个文本节点, nodeName() 返回"#text",并且nodeValue() 返回"This is an "。很重要的一点是元素的value 和它的content不一样。
处理DOM时,获得关心的内容意味着要检查节点包含的子元素列表,忽略那些不感兴趣的,只处理那些感兴趣的。
例如,在上面的例子中,如果要查询句子的“text(文本)”意味着什么?根据你的应用程序,下面的每一条都是合理的:
· This is an
· This is an idea.
· This is an important idea.
· This is an <bold>important</bold> idea.
简单模型
使用DOM可以方便地创建所需的语义。然而,也需要经过必要的处理,以实现这些语义。而像JDOM和dom4j这样的标准,使得事情更加简单,因为层次结构中的每个节点都是一个对象。
虽然JDOM 和dom4j 允许使用混合内容元素,但是它们主要不是用于这类情况的。相反,它们主要用于XML结构包含数据的应用程序中。
如传统数据处理中所介绍的,数据结构中的元素包含文本或其他元素,但是不能两个都包含。例如,下面的XML表示简单的通讯簿:
<addressbook>
<entry>
<name>Fred</name>
<email>fred@home</email>
</entry>
...
</addressbook>
注意: 对于这类非常简单的XML数据结构,也可以使用Java平台1.4版本中的正则表达式包(java.util.regex)。
在JDOM 和dom4j中,一旦到达包含文本的元素,就会调用一个方法如text() 来获得它的内容。处理DOM时,必须查看子元素列表,将节点的文本“放在一起”,就如前面所见到的——即便该列表只包含一项(TEXT 节点)。
所以,对于简单的数据结构(如前面的通讯簿),使用JDOM或dom4j可以节省很多工作。即便是数据在技术上是“混合”的,也可以使用这些模型中的某个模型,除非给定节点有一个(并且仅有一个)文本段。
下面是这类结构的一个例子,它在JDOM或dom4j中也很容易处理:
<addressbook>
<entry>Fred
<email>fred@home</email>
</entry>
...
</addressbook>
这里,每项都有标识文本,并且后面还有其他元素。使用该结构,程序能够浏览一个项,调用text() 来查看它属于谁,并且如果<email> 子元素在当前节点下,就处理它。
增加复杂度
但是要完全理解查找或操作DOM时需要进行的处理,就必需知道DOM包含的节点。
下面的例子主要就是针对这点的。它是该数据的一个表示法:
<sentence>
The &projectName; <![CDATA[<i>project</i>]]> is
<?editor: red><bold>important</bold><?editor: normal>.
</sentence>
该句子包含一个实体引用——一个在其他地方定义的指向“实体”的指针。这里,实体包含项目名。这个例子也包含CDATA段(未解释的数据,如HTML中的<pre> 数据),和处理指令 (<?...?>)。在本例中该处理指令告诉编辑器在绘制文本时使用哪种颜色。
下面是该数据的DOM结构。它代表了强壮的应用程序要处理的结构:
+ ELEMENT: sentence
+ TEXT: The
+ ENTITY REF: projectName
+ COMMENT: The latest name we're using
+ TEXT: Eagle
+ CDATA: <i>project</i>
+ TEXT: is
+ PI: editor: red
+ ELEMENT: bold
+ TEXT: important
+ PI: editor: normal
本例描绘了可能在DOM中出现的节点。虽然在绝大多数时候你的应用程序能够忽略它们中的大部分,但是真正强壮的实现需要识别并处理它们中的每一个。
同样,到访节点的处理涉及到子元素的处理,它忽略你不关心的元素仅仅查看关心的元素,直到找到感兴趣的节点。
通常,在这类情况下,仅对找到包含指定文本的节点感兴趣。例如,在DOM API 中,有一个例子,那个例子中希望找到一个<coffee> 节点,该节点的<name> 元素包含文本“Mocha Java”。要执行该查找,程序需要处理<coffee> 元素列表,并且对于每一个列表:a)获取它下面的<name> 元素。b)检查该元素下的TEXT 节点。
然而,该例是建立在一些简单的假设之上的。它假设处理指令、注释、CDATA节点和实体引用不能存在于数据结构中。许多简单的应用程序能够去掉这些假设。另外,真正强壮的应用程序需要处理各类有效的XML数据。
(仅当输入数据包含所需的简化的XML结构时,“简单”的应用程序才能运行。但是没有任何验证机制能够确保不存在更加复杂的结构。毕竟,XML是专门为它们设计的。)
要变得更加强壮,DOM API中的例子代码必须完成以下事情:
1. 搜索<name> 元素时:
a. 忽略注释、属性和处理指令。
b. 允许出现<coffee> 子元素没有按指定的顺序出现的情况。
c. 如果没有验证,跳过包含可忽略空白的TEXT 节点。
2. 提取节点的文本时:
a. 从CDATA 节点和文本节点提取文本。
b. 收集文本时忽略注释、属性和处理指令。
c. 如果遇到了实体引用节点或另一个元素节点,递归。(也就是说,将文本提取过程应用于所有的子节点)。
注意:JAXP 1.2解析器不将实体引用节点插入DOM。相反,它插入包含引用内容的TEXT 节点。另外,建立在1.4平台中的JAXP 1.1解析器并不插入实体引用。所以,所以独立于解析器的强壮的实现需要能处理实体引用节点。
当然,许多应用程序不用担心这类事情,因为它们看到的数据受到了严格的控制。如果数据能够来自于各类外部源,应用程序就必须考虑这些可能性。
在DOM教程搜索节点 和获得节点内容的结尾处给出了执行这些函数的代码。现在,目标就是确定DOM是不是适合于你的应用程序。
选择模型
可以看到,使用DOM时,即便是像得到节点中的文本这样简单的操作也要进行大量的编码。所以,如果程序将处理简单数据结构,JDOM、dom4j甚至1.4正则表达式包(java.util.regex)将更能满足你的需求。
另外,对于完备的文档和复杂的应用程序,DOM 提供了大量灵活性。并且如果需要使用XML Schema,那么至少DOM是可以使用的方法。
如果你要在开发的应用程序中处理文档和数据,那么DOM可能仍然是最好的选择。毕竟,一旦编写了检查和处理DOM结构的代码,自定义它以实现特定的目的就很容易了。所以,选择在DOM中完成所有的事情,只需要处理一个API集合而不是两个。
还有,DOM标准是标准的。它很强壮且完整,并且有许多实现。这是许多大型安装的决定因素——特别是对产品应用程序,以避免在API发生改变时进行大量的改写。
最后,虽然目前不允许对通讯簿中的文本加粗、倾斜、设置颜色和改变字体大小,某一天可能还是需要处理这些。由于实际上DOM将处理你抛给它的所有内容,选择DOM能够更加容易生成“能适应未来(future-proof)”的应用程序。
将XML数据读入到DOM中
本节将通过读取现有XML文件来构建一个文档对象模型 (DOM)。在下面几节,你将会学习如何在Swing树组件中显示XML并且练习操作DOM。
注意:在教程的下一节转换XML样式表语言中,你将看到如何写出作为XML文件的DOM。(你也将看到如何相对简单地将现有的数据文件转换成XML)
创建程序
文档对象模型(DOM)提供了创建节点、修改节点、删除及重新组织它们的API。在本教程的第五节创建和操纵DOM中可以看到,创建DOM相对比较容易。
然而,在创建DOM之前,要先了解DOM的结构。这系列练习通过在Swing Jtree中显示DOM,以便能看到DOM的内部。
创建框架
既然已经对如何创建DOM有了大致了解,现在来建立一个简单程序来将XML文档读入DOM,然后在回写。
注意:本节讨论的代码在DomEcho01.java中。它操作在文件 slideSample01.xml 上。(可浏览的版本是 slideSample01-xml.html)
先来看看应用程序的基本逻辑,确保命令行上带有一个参数:
public class DomEcho {
public static void main(String argv[])
{
if (argv.length != 1) {
System.err.println(
"Usage: java DomEcho filename");
System.exit(1);
}
}// main
}// DomEcho
导入所需的类
本节中将看到所有的类都是单独命名的。这样,在引用API文档时就能知道每个类的出处。在你自己的应用程序中,你可能希望使用短格式javax.xml.parsers.*来替换如下所示的导入语句。
添加如下代码以导入要使用的JAXP API:
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.parsers.ParserConfigurationException;
想在解析XML文档时抛出异常,添加下面几行:
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
添加下面几行来读取示例XML文件并识别错误:
import java.io.File;
import java.io.IOException;
最后,为DOM和DOM异常导入W3C定义:
import org.w3c.dom.Document;
import org.w3c.dom.DOMException;
注意:仅在遍历或操作DOM时才会抛出DOMException 。使用下面介绍的不同机制来报告解析过程中出现的错误。
声明 DOM
org.w3c.dom.Document 类是文档对象模型(DOM)的W3C名。不管解析XML文档还是创建一个XML文档,都会产生一个文档实例。在教程的后面将在另一个方法中引用该对象,所以,在这里将它定义成全局对象:
public class DomEcho
{
static Document document;
public static void main(String argv[])
{
它必须是static的,因为你需要在很短时间内从main方法生成它的内容。
处理错误
下一步,插入错误处理逻辑。该逻辑基本上跟SAX教程的使用非验证解析器处理错误中的代码相同,所以在这里就不详细介绍了。在这里要特别提醒的是,当解析XML文档遇到困难时,需要JAXP-conformant 文档构造器来报告SAX异常。实际上DOM解析器不需要在内部使用SAX解析器,但是由于早就有了SAX标准,看来可以用它来报告错误。结果,DOM和SAX应用程序的错误处理代码就非常简单:
public static void main(String argv[])
{
if (argv.length != 1) {
...
}
try {
} catch (SAXParseException spe) {
//
Error generated by the parser
System.out.println("\n** Parsing error"
+ ", line " + spe.getLineNumber()
+ ", uri " + spe.getSystemId());
System.out.println(" " + spe.getMessage() );
// Use the contained exception, if any
Exception x = spe;
if (spe.getException() != null)
x = spe.getException();
x.printStackTrace();
} catch (SAXException sxe) {
//
Error generated during parsing
Exception x = sxe;
if (sxe.getException() != null)
x = sxe.getException();
x.printStackTrace();
} catch (ParserConfigurationException pce) {
// Parser with specified options can't be built
pce.printStackTrace();
} catch (IOException ioe) {
// I/O error
ioe.printStackTrace();
}
}// main
实例化工厂
接着,添加下面的代码,得到工厂的一个实例,该实例能够给出一个文档构造器:
public static void main(String argv[])
{
if (argv.length != 1) {
...
}
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
try {
获得解析器并解析文件
现在,添加下面的代码以获得构造器的一个实例,并用它来解析指定的文件:
try {
DocumentBuilder builder = factory.newDocumentBuilder();
document = builder.parse( new File(argv[0]) );
} catch (SAXParseException spe) {
保存该文件!
到现在,你可能觉得启动每个JAXP应用程序的方法几乎相同。的确如此!保存该版本的文件,将它作为模板。后面将要使用它,它是XSLT转换应用程序的基础。
运行程序
在整个DOM教程中,将使用SAX段中看到的示例幻灯片显示。尤其是,你将使用slideSample01.xml(它是一个简单的XML文件,内部没有什么内容)和slideSample10.xml(是一个更加复杂的例子,引入了DTD、处理指令、实体引用和CDATA段)。
关于如何编译并运行程序的说明,请查看SAX教程的编译和运行程序 。以"DomEcho"替代"Echo"作为程序的名字。
在slideSample01.xml上运行该程序。如果运行没有出错,你就成功地解析了一个XML文档并且构建了一个DOM。恭喜!
注意:目前你只能听从我的建议,因为这时你没有任何办法来显示结果。但是在不久的将来...
其他信息
既然你已经成功地读取了一个DOM,要高效使用DocumentBuilder 必须知道一到两点。即:
· 配置Factory
· 处理验证错误
配置工厂
默认情况下,工厂返回非验证解析器,对命名空间一无所知。要获得一个验证解析器,并且/或能理解命名空间,请使用下面的命令来设置一个或多个参数,以配置该工厂:
public static void main(String argv[])
{
if (argv.length != 1) {
...
}
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
factory.setValidating(true);
factory.setNamespaceAware(true);
try {
...
注意:不要求JAXP-conformant解析器支持这些参数的所有的结合,虽然引用解析器支持。如果你指定了一个无效的参数结合,在获得解析器实例时factory产生ParserConfigurationException 。
在DOM教程的最后一节使用命名空间中将详细介绍如何使用命名空间。本节要结束了,虽然你仍然希望知道…
处理验证错误
记住,在你阅读SAX教程时,你所要做的事情就是构建一个DOM?这里,那些信息起作用了。
记住对验证错误的默认反应(由SAX标准提出)就是什么不也做。JAXP标准要求抛出SAX异常,所以使用跟SAX应用程序中几乎相同的错误处理机制。尤其需要使用DocumentBuilder的setErrorHandler方法提供实现SAX ErrorHandler 接口的对象。
注意:也可以使用DocumentBuilder 中的setEntityResolver 方法。
下面的代码使用匿名内部类来定义ErrorHandler。下面的代码确保验证错误产生异常。
builder.setErrorHandler(
new org.xml.sax.ErrorHandler() {
// ignore fatal errors (an exception is guaranteed)
public void fatalError(SAXParseException exception)
throws SAXException {
}
// treat validation errors as fatal
public void error(SAXParseException e)
throws SAXParseException
{
throw e;
}
// dump warnings too
public void warning(SAXParseException err)
throws SAXParseException
{
System.out.println("** Warning"
+ ", line " + err.getLineNumber()
+ ", uri " + err.getSystemId());
System.out.println(" " + err.getMessage());
}
);
本段代码使用匿名内部类来产生实现ErrorHandler 接口的对象实例。由于它没有类名字,所以是“匿名”的。你可以将它看作"ErrorHandler"实例,虽然技术上它是实现指定接口的没有名字的实例。这些代码本质上跟使用非验证解析器处理错误中的相同。要了解验证问题的更多知识,请参照使用验证解析器。
展望未来
下节中将在Jtree中显示DOM结构,并且开始展示它的结构。例如,你将看到实体引用和CDATA段是如何出现在DOM中的。可能更加重要的是,你将看到如何将文本节点(它包含实际的数据)放在DOM中的元素节点下。
显示DOM层次结构
要创建或操纵一个文档对象层次结构 (DOM),必须要清楚地了解DOM中节点的结构。本节中将展示DOM的内部结构。
回送树节点
现在你所需要的是展示DOM中节点的方法,这样你就能看到节点内究竟包含什么。要实现这一点,将DOM转换成JTreeModel 并且在Jtree中显示完整的DOM。这些需要大量的工作,但是它不仅将产生你将来要使用的诊断工具,而且可以帮助你了解DOM结构。
将DomEcho 转换为GUI 应用程序
由于DOM是树,并且Swing JTree 组件都跟显示树有关,所以有必要将DOM放入Jtree,以便查看。该过程的第一步是处理DomEcho 程序,让它成为一个GUI 应用程序。
注意:本节讨论的代码在DomEcho02.java中。
添加Import语句
首先导入建立应用程序和显示Jtree需要的GUI组件:
// GUI components and layouts
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTree;
DOM教程的后面部分将设计DOM显示,以产生Jtree显示的用户友好版本。用户选择树中的元素时,子元素将显示在邻近的编辑器面板中。所以,进行安装工作时,需要导入建立分割视图(JSplitPane)和显示子元素文本(JEditorPane)所需的组件:
import javax.swing.JSplitPane;
import javax.swing.JEditorPane;
添加一些你需要的支持类:
// GUI support classes
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.event.WindowEvent;
import java.awt.event.WindowAdapter;
最后,导入一些类来建立别致的边框:
// For creating borders
import javax.swing.border.EmptyBorder;
import javax.swing.border.BevelBorder;
import javax.swing.border.CompoundBorder;
(这些是可选的。如果想要简化代码,可以跳过它们以及相关代码。)
创建GUI框架
下一步是将应用程序转换为GUI应用程序。为此,静态main方法将创建main类的一个实例,它将成为GUI面板。
首先扩展Swing JPanel 类,将该类变成一个GUI面板:
public class DomEcho02 extends JPanel
{
// Global value so it can be ref'd by the tree-adapter
static Document document;
...
定义一些用来控制窗口大小的常量:
public class DomEcho02 extends JPanel
{
// Global value so it can be ref'd by the tree-adapter
static Document document;
static final int windowHeight = 460;
static final int leftWidth = 300;
static final int rightWidth = 340;
static final int windowWidth = leftWidth + rightWidth;
现在,在main方法中,调用创建GUI面板所在的外部框架的方法:
public static void main(String argv[])
{
...
DocumentBuilderFactory factory ...
try {
DocumentBuilder builder = factory.newDocumentBuilder();
document = builder.parse( new File(argv[0]) );
makeFrame();
} catch (SAXParseException spe) {
...
然后,需要定义makeFrame方法本身。它包含创建框架的标准代码,并能很好地处理退出条件,给出main面板的实例,定制它的大小,最后将其定位于屏幕上并使之可视化:
...
} // main
public static void makeFrame()
{
// Set up a GUI framework
JFrame frame = new JFrame("DOM Echo");
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e)
{System.exit(0);}
});
//
Set up the tree, the views, and display it all
final DomEcho02 echoPanel = new DomEcho02();
frame.getContentPane().add("Center", echoPanel );
frame.pack();
Dimension screenSize =
Toolkit.getDefaultToolkit().getScreenSize();
int w = windowWidth + 10;
int h = windowHeight + 10;
frame.setLocation(screenSize.width/3 - w/2,
screenSize.height/2 - h/2);
frame.setSize(w, h);
frame.setVisible(true)
} // makeFrame
添加显示组件
将程序转换成GUI应用程序的工作只剩下创建类构造函数并让它创建面板的内容。下面是构造函数:
public class DomEcho02 extends JPanel
{
...
static final int windowWidth = leftWidth + rightWidth;
public DomEcho02()
{
} // Constructor
这里,使用前面导入的边框类建立常用边框(可选):
public DomEcho02()
{
// Make a nice border
EmptyBorder eb = new EmptyBorder(5,5,5,5);
BevelBorder bb = new BevelBorder(BevelBorder.LOWERED);
CompoundBorder cb = new CompoundBorder(eb,bb);
this.setBorder(new CompoundBorder(cb,eb));
} // Constructor
然后,创建一棵空树并且将它放入JScrollPane ,这样当它变大时,用户就能看到它的内容:
public DomEcho02(
{
...
//
Set up the tree
JTree tree = new JTree();
// Build left-side view
JScrollPane treeView = new JScrollPane(tree);
treeView.setPreferredSize(
new Dimension( leftWidth, windowHeight ));
} // Constructor
现在,创建不可编辑的JEditPane ,它将最终保存选中的JTree 节点指向的内容:
public DomEcho02(
{
....
// Build right-side view
JEditorPane htmlPane = new JEditorPane("text/html","");
htmlPane.setEditable(false);
JScrollPane htmlView = new JScrollPane(htmlPane);
htmlView.setPreferredSize(
new Dimension( rightWidth, windowHeight ));
} // Constructor
构建了左边的JTree 和右边的JEditorPane 后,创建一个JSplitPane 来存放它们:
public DomEcho02()
{
....
// Build split-pane view
JSplitPane splitPane =
new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,
treeView, htmlView );
splitPane.setContinuousLayout( true );
splitPane.setDividerLocation( leftWidth );
splitPane.setPreferredSize(
new Dimension( windowWidth + 10, windowHeight+10 ));
} // Constructor
该代码建立了带有垂直分割线的JSplitPane 。它将在树和编辑器面板之间产生“水平分割线”。(实际上,更是水平布局)你也要设置分割线的位置,这样树能够得到它要的宽度,将剩下的窗口宽度分配给编辑器面板。
最后,指定面板的布局并且添加split pane:
public DomEcho02()
{
...
// Add GUI components
this.setLayout(new BorderLayout());
this.add("Center", splitPane );
} // Constructor
恭喜!该程序现在是一个GUI应用程序。现在可以运行它,看看屏幕上的总体布局是怎样的。为了引用,这里有完整的构造函数:
public DomEcho02()
{
// Make a nice border
EmptyBorder eb = new EmptyBorder(5,5,5,5);
BevelBorder bb = new BevelBorder(BevelBorder.LOWERED);
CompoundBorder CB = new CompoundBorder(eb,bb);
this.setBorder(new CompoundBorder(CB,eb));
// Set up the tree
JTree tree = new JTree();
// Build left-side view
JScrollPane treeView = new JScrollPane(tree);
treeView.setPreferredSize(
new Dimension( leftWidth, windowHeight ));
// Build right-side view
JEditorPane htmlPane = new JEditorPane("text/html","");
htmlPane.setEditable(false);
JScrollPane htmlView = new JScrollPane(htmlPane);
htmlView.setPreferredSize(
new Dimension( rightWidth, windowHeight ));
// Build split-pane view
JSplitPane splitPane =
new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,
treeView, htmlView )
splitPane.setContinuousLayout( true );
splitPane.setDividerLocation( leftWidth );
splitPane.setPreferredSize(
new Dimension( windowWidth + 10, windowHeight+10 ));
// Add GUI components
this.setLayout(new BorderLayout());
this.add("Center", splitPane );
} // Constructor
创建适配器以便在Jtree中显示DOM
现在已经有一个GUI框架来显示JTree ,下一步是获得Jtree以显示DOM。但是JTree 希望显示TreeModel。 DOM 是树,但它不是TreeModel。所以需要创建一个适配器使得DOM