tfc2005

JDOM让XML在Java中比以前任何时候都容易使用

以前，可能使用一部分Java的一部分库类来操作XML数据结构。那么，JDOM(Java Document Object Model)的要点又是什么，为什么开发人员需要它？
对Java-optimized XML数据操作的JDOM是开放源代码。虽然它很像World Wide Web联盟(W3C)的DOM，但是它是一个可供选择的对象模型，这个模型不是建立在DOM或者基于DOM的模型之上的。主要的不同是DOM作为language-neutral建立并且用于HTML页面的JavaScript操作，JDOM作为Java-specific建立，因此具有了Java 本身的优点，包括method overloading，collections，reflection，and familiar。对于Java编程人员来说，JDOM 倾向于探索更多的本身的能力和好处。这个很象Java-optimized RMI (remote method invocation) 库探索更多本身的能力，而不是象language-neutral CORBA (Common Object Request Broker Architecture)那样。

在jdom.org上的开放代码Apache-style (commercial-friendly)版本中，可以找到JDOM。它是协作设计、开发的产物，它拥有多达3,000多个志愿人员。这个库同时也被Sun's Java Community Process (JCP)作为Java Specification Request (JSR-102)接受，同时正在一步一步的成为一个正式的Java规范。

下面一系列的文章将针对JDOM提供技术说明。文章提供了关于重要类的信息。下篇文章将给一些关于怎样在的Java程序里面使用JDOM的内容。
 
JDOM 包结构

JDOM 库由六个包组成。第一个org.jdom 包支持包括了一个XML文档，同时包括：Attribute，CDATA，Comment，DocType，Document，Element，EntityRef，Namespace，ProcessingInstruction，以及Text。如果对XML很熟悉，类名将帮助理解类的含义。
下来的org.jdom.input包，它支持类用于建立XML文档。最主要也是重要的类是SAXBuilder。SAXBuilder 通过监听输入简单的针对XML (SAX) 事件的API建立文档。当想从一个文件或者其它流来建立文档的时候，可以使用SAXBuilder。它使用SAX 分析器来读取流，然后依据SAX分析器的返回来建立文档。这个设计的一个好的方面是分析器的工作越快，，SAXBuilder的工作也就越快。另外一个主要的输入类是DOMBuilder。DOMBuilder从DOM树建立。这个类很容易从先前的DOM树中获得，而要一个JDOM版本代替。。
对于设计人员是没有限制的。例如：现在Xerces要在比SAX低水平时操作Xerces Native Interface (XNI)，它可以作出判断去做一个XNIBuilder来支持一些分析器的规则，不被SAX暴露。ResultSetBuilder是一种受欢迎的人，他们投稿给JDOM工程。这样让JDBC的更加坚固，并且建立了SQL的XML文档表达模式，包括了许多关于那些是组成部分那些是属性的配置。
org.jdom.outpu包支持类输出XML文档。最重要的类是XMLOutputter。它为了将文档输出到文件，流，以及sockets将其转化为字节流。类XMLOutputter又很多奇特的配置选项来支持原始输出，恰当的输出，或者压缩输出以及其它方式。它是一个相当复杂的类。这也许就是为什么这个不在DOM Level 2存在的原因。
另外的输出包括了类SAXOupputter，它根据文档内容产生了SAX事件。虽然表面上看很神秘，但是这个类在XSLT转换中是非常有用的，因为SAX事件比字节更有效传输文档数据。这里同样有类DOMOutputter，它建立了DOM树文档表示。一个有趣的设计是 JTreeOutputter，它只有很少的一些代码，它建立了Jtree来文档表示。用ResultSetBuilder联合，使用简单的代码，就可以完成SQL查询和队列遍历。
注意，不象DOM，开发人员不会将文档打包。这就产生了一个模式，可以使用类保存数据，许多的类构造了数据，并且许多其它的类放弃了数据。
org.jdom.transform 和 org.jdom.xpath 包的类支持建立XSLT转化和Xpath查找。
最后是org.jdom.adapters包中类支持在DOM内部进行交流。库用户不需要访问这个库的类。每个DOM执行过程都对每步任务有不同的方法名，所以适配器将标准调用转换为parser-specific调用。Java API for XML Processing (JAXP)对于这个问题给出其它的一些解决方法，实际上是对于类的需要，但是一些类仍然保留，因为不是所有的分析器都支持JAXP，或者JAXP不是任何地方都安装了，并且版本正确。

建立一个文档
文档由org.jdom.Documentclass来辅助建立。可以象下面这样建立一个文档：

// This builds: <root/>
Document doc = new Document(new Element("root"));

或者可以由一个文件，流，系统ID，或者URL建立文档：

// This builds a document of whatever's in the given resource
SAXBuilder builder = new SAXBuilder();
Document doc = builder.build(url);

在JDOM中将一些调用组合在一起，可以很容易的建立一个简单的文档：

// This builds: <root>This is the root</root>
Document doc = new Document();
Element e = new Element("root");
e.setText("This is the root");
doc.addContent(e);

如果是个有经验的用户，或许可以使用"method chaining,"，在有多个方法的时候依次被调用。因为固定的方法返回产生的对象。如下：

Document doc = new Document(
  new Element("root").setText("This is the root"));

作为比较，这里给出如何使用JAXP/DOM建立同样的文档：

// JAXP/DOM
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.newDocument();
Element root = doc.createElement("root");
Text text = doc.createText("This is the root");
root.appendChild(text);
doc.appendChild(root);

用SAXBuilder建立

早期，SAXBuilder建立了一个可以从任何byte-oriented资源建立文档的机制。默认的SAXBuilder()在后台使用JAXP选择SAX剖析器。如果要改变剖析器，可以设置javax.xml.parsers.SAXParserFactory系统特性指向SAXParser Factory，由的剖析器保证运行。对于Oracle9i Release 2 XML剖析器，可以这样使用：

java -Djavax.xml.parsers.SAXParserFactory=
oracle.xml.jaxp.JXSAXParserFactory YourApp

对于Xerces 剖析器，可以这样来代替：

java -Djavax.xml.parsers.SAXParserFactory=org.apache.xerces.jaxp
.SAXParserFactoryImpl YourApp

如果没有安装JAXP，SAXBuilder默认为Apache Xerces。一旦建立一个 SAXBuilder 实例，就可以设置一些道具，包括：

setValidation(boolean validate)

这个方法在建立中告诉剖析器针对Document Type Definition (DTD) 是否有效。默认是关闭的。使用DTD 是关于文档的 DocType的一个参考。针对其它DTD是不可能有效的，因为没有剖析器支持这个能力。

setIgnoringElementContentWhitespace(boolean ignoring)

这个方法告诉剖析器是否忽视调用whitespace的元素目录。每个XML 1.0 说明，在元素目录中的whitespace 必须剖析器保存，但是针对一个DTD确认需要确认剖析器知道某些文档的部分没有被声明支持whitespace，则任何在那个区域的whitespace都是"ignorable." 这个默认是关闭的。这个对于部分存储并不是最好的，除非要"round trip"一个文档，并且将输入作为输出。注意，这个标记只有确认打开时是激活的，而且确认使得执行速度减慢，所以最好在确认已经使用的情况下再使用。

setFeature(String name，String value)

这个方法再SAX剖析器的后台做一些设置。这是个无处理的传递调用，所以要非常小心的使用，因为设置错误（例如tweaking namespaces）将会毁坏JDOM。此外，依靠任何parser-specific都有一定的便捷性。这个调用对于计划确认的授权很有用。

setProperty(String name，Object value)

这个方法再SAX剖析器的后台做一些设置。这同样是个无处理的传递调用，对于高级用户同时拥有了高危险性和很高的适用性，特别针对于计划确认。将方法组合，下面的代码在确认打开同时忽视ignorable whitespace的情况下，使用JAXP-selected剖析器读取当地文件。

SAXBuilder builder = new SAXBuilder();
builder.setValidation(true);
builder.setIgnoringElementContentWhitespace(true);
Document doc = builder.build(new File("/tmp/foo.xml"));

通过XMLOutputter建立文档

一个文档可以以多种格式输出，但是最常用的是字节流。在JDOM中，XMLOutputter类提供了这种特性。默认的构造器试图无错误的输出在内存中存储的文档。下面的代码提供了针对文件原始的表示。

// Raw output
XMLOutputter outp = new XMLOutputter();
outp.output(doc，fileStream);

如果担心whitespace，可以清除空白：

// Compressed output
outp.setTextTrim(true);
outp.output(doc，socketStream);

如果要打印出人们习惯的样式，可以添加缩进的空白并且换到新行：

outp.setTextTrim(true);
outp.setIndent("  ");
outp.setNewlines(true);
outp.output(doc，System.out);

当打印一个已经格式化空白的文档，需要确认是可以清理的。否则，必须格式化，这可能很难看。

操作元素树

JDOM让操作元素树很容易。得到根部元素：

Element root = doc.getRootElement();
To get a list of all its child elements:
List allChildren = root.getChildren();

通过名字得到指定元素：

List namedChildren = root.getChildren("name");

根据给定名得到第一个元素：

Element child = root.getChild("name");

getChildren()调用返回的List是一个java.util.List，一个所有Java程序员都知道的List接口操作。列表的活动性很有趣。任何List的改变将会在后台的文档中显示出来。

// Remove the fourth child
allChildren.remove(3);
// Remove children named "jack"
allChildren.removeAll(root.getChildren("jack"));
// Add a new child，at the tail or at the head
allChildren.add(new Element("jane"));
allChildren.add(0，new Element("jill"));

使用List意味着不需要添加众多的方法就可以进行多个元素的操作。为了方便，无论是在最后添加元素还是删除已命名的元素，元素本身都拥有了相应的方法，则不需要在操作之前获得List：

root.removeChildren("jill");
root.addContent(new Element("jenny"));

JDOM的一个优点是它可以很容易在文档内部或者在文档之间移动元素。代码都是一样的：
 
Element movable = new Element("movable");
parent1.addContent(movable);    // place
parent1.removeContent(movable); // remove
parent2.addContent(movable);    // add

使用DOM，移动元素是不容易的，因为在DOM中，元素是和建立工具绑定的。因而，DOM元素在文档之间移动必须是有关系的"imported"。
关于JDOM有一件必须注意的就是移动元素之前先要添加，所以你不能建立一个循环树。有个detach()方法可以分离/添加一条线：

parent3.addContent(movable.detach());

如果在添加一个元素到另外一个父接点之前忘记了分离它，库将会抛出一个异常。库也会检查元素的名字和内容，确认它们不包括不适当的字符，就像空白。它同样还有其它的规则，例如只有一个根元素，相容的名字空间声明，注释和CDATA部分里面没有被禁止的字符序列，等等。这种特性使得在进程中尽可能早的去检查"well-formedness"错误变成可能。

操作元素属性
元素属性：

<table width="100%" border="0"> ..。</table>

对于元素，可以用命名属性值任何名字：

String val = table.getAttributeValue("width");

对于执行特殊的操作，例如类型变化，也可以作为对象得到属性：
 
Attribute border = table.getAttribute("border");
int size = border.getIntValue();

使用setAttribute()设置或者改变属性:

table.setAttribute("vspace"，"0");

使用removeAttribute()删除一个属性:
 
table.removeAttribute("vspace");

关于文本内容的处理

元素文本内容就像：

<description>
  A cool demo
</description>

在JDOM中，文本直接可以被调用使用：

String desc = description.getText();

只要注意，因为XML 1.0规范需要空白被保存，返回"\n A cool demo\n"。当然，作为实际编程人员经常的不想面对空白的格式，所以当忽视了周围的空白的时有了简单的方法：

String betterDesc = description.getTextTrim();

如果需要空白在图片外，需要getTextNormalize() 方法规格化空白。对于文本内容是很便利的：

<description>
  Sometimes you have text content with formatting
  space within the string.
</description>

通过 setText()方法改变文本内容：

description.setText("A new description");

文本里面的任何特殊字符都被相应的字符解释，并且空格在输出中有了恰当的意义。例如：

element.setText("<xml/> content");

内部存储以字符保存文字串。tore will keep that literal string as characters。不需要盲目的对内容分解。在输出时：

<xml/> content<elt>

这些行为保持了早期setText()调用的语义。如果需要XML在一个元素内被支持，必须添加适当的JDOM子元素对象。
JDOM同样可以处理 CDATA 部分。一个CDATA部分需要的一个text文本不需要被分析。它包括了简单一些HTML和XML内容，不含有< and >以及空格。建立一个CDATA 部分，只要用CDATA对象包裹字符串：

element.addContent(new CDATA("<xml/> content"));

混和内容的行为

一些元素包括了很多的内容，例如whitespace，comments，text，child elements，等等：

<table>

  <!-- Some comment -->
  Some text
  <tr>Some child element</tr>
</table>

当一个元素包括了文本和子元素，被称为混和内容。处理混和内容本来是很困难的，但是通过JDOM变得简单。标准的应用－找回文本内容和遍历元素－很简单：

String text = table.getTextTrim();  // "Some text"
Element tr = table.getChild("tr");  // A straight reference

对于大多数高级用户，都需要注释，空白，处理说明和实体参考，未处理的混和文本作为List是可行的：

List mixedCo = table.getContent();
Iterator itr = mixedCo.iterator();
while (itr.hasNext()) {
  Object o = i.next();
  if (o instanceof Comment) {
    ...
  }
  // Types include Comment，Element，CDATA，DocType,
  // ProcessingInstruction，EntityRef，and Text
}

作为子元素列表，改变原始列表影响了后台文档：

// Remove the Comment。 It's "1" because "0" is a whitespace block.
mixedCo.remove(1);

更多关于DocType，ProcessingInstruction，和EntityRef classes的细节可以在jdom.org上的API文档中找到。

ORACLE XML 工具

XML Developer Kit (XDK)是免费的XML工具库，它是有Oracle提供给开发人员的。它包括了XML剖析器和一个XSLT翻译引擎，能和JDOM使用。在OracleXML主页上，你可以找到更多的信息关于这些工具，oracle.com/xml。
下载剖析器，寻找名为"XDK for Java."的XML Developer Kit。在左边的专栏点击"Software"来找到下载连接。一旦你打开分类，文件xalparserv2.jar就包括了剖析器。
使用剖析器的默认来配置JDOM和其它软件，你需要设置JAXP javax.xml.parsers.SAXParserFactory 系统为oracle.xml.jax.JXSAXParserFactory。这将告诉JAXP选择了Oracle剖析器。简单的方法是在命令行输入：

[CODE]java -Djavax.xml.parsers.SAXParserFactory=
oracle.xml.jaxp.JXSAXParserFactory

同样可以设定：

System.setProperty("jaxax.xml.parsers.SAXParserFactory","oracle.xml.jaxp.JXSAXParserFactory");

除了XDK之外，Oracle提供了原先的XML Oracle9i Database Release 2仓库。Oracle9i XML Database (XDB) 是应用很多，本身的XML存储。它充分的吸收了W3C XML 在Oracle9i Database中的数据模式并且为XML遍历和查询提供了新的标准接入方法。关于XDB，得到了数据库相关的优点以及XML技术的优点。

 概述：

jdom是用java语言读、写、操作XML的新api函数。Jason Hunter 和 Brett McLaughlin公开发布了它的测试版本。在直觉、简单和高效的前提下，这些api函数被最大限度的优化。在接下来的篇幅里，Hunter 和  McLaughlin介绍怎么用jdom去读写一个已经存在的XML文档。

Jdom是一个开源的api，它以直接易懂的方式向java程序员描述XML文档和文档的内容。就象名字揭示的那样，jdom是为java优化的。为使用XML文档提供一个低消耗的方法。Jdom的使用者可以不必掌握太多的XML的知识就可以完成想要的操作。

Jdom可以和已有的XML技术如Simple API for XML (SAX)和 Document Object Model (DOM)相互协作.然而，它并不是简单的从这些api中提取出一些。Jdom从这些已存在的技术中吸收了好的方面，自己建立了一套新的类和接口，用一个jdom用户的话来说就是：“这些接口是我从一开始阅读org.w3c.dom就期待的”；jdom可以读入SAX或是DOM的内容，也可以输出SAX或DOM可以接收的格式。这个能力可以使jdom很好的和已有的用SAX或DOM建立的系统之间整合。

Jdom的原则

第一条并且是最重要的一条就是jdom的api函数被设计成对java程序员来说是简单易懂的。其他的XML解析函数被设计成语言通用的（支持相同的api函数在java，c++，甚至是javascript中）。Jdom利用了java的优秀的特征，如：方法重载、回收机制，和后台处理等。

为了能够简单易用，这些函数不得不以程序员喜欢的形式来描绘XML文档。例如：程序员想的到的一个元素的文本内容是什么样子的呢？

<element>This is my text content</element>

在一些api中，元素的文本内容仅被当作是一个元素的孩子节点。从技术角度来说，这个设计需要下面的代码才能访问到元素的内容：

String content = element.getFirstChild().getValue();

Jdom用一种更简单易用的方法来取得元素的内容：

String text = element.getText();

Jdom尽可能的减少程序员的工作量。依据拇指规则，jdom应该用20%或是更少的努力来完成80%或是更多的java/xml方面的问题。这并不是说jdom只是支持80%的XML规范（实际上我们希望jdom100%的支持XML规范）。这个拇指规则是说有些东西可以加进去，但是没有必要。这些api函数应该保持简洁。

Jdom的第二条原则是说jdom应该是快速的和轻量级的。调入和执行文档应该快速，内存的消耗应该尽量小。Jdom的设计明显是遵循这个原则。例如，就算在开始的时候，不太协调的操作已经比DOM快，但是比SAX显的粗糙。尽管这样，jdom还是有许多SAX没有的优点。

你需要jdom吗？

那么，你需要jdom吗？这真是一个很好的问题。已经有了存在的标准，为什么还要去发明一个新的呢？答案是jdom解决了现有的标准解决不了的问题。

DOM完全在内存中描述一个元素树。它是一个大的api，被设计操作几乎所有可能的XML任务。它也必须有相同的api去支持不同的语言。因为这些限制，对那些习惯使用java的特征，如方法重载、简单的set,get方法的java程序员来说，就很不习惯。DOM还需要大量的内存和较高的主频，这使它很难和许多轻量级的web应用一起工作。

 SAX没有在内存中建立一个元素树，它用事情发展的方式来描述。例如：它报告每个读到的开始标记和结束标记。这种处理方式使它成为一个轻量级的快速读取的api。然而，这种事件处理方式对服务器端的java程序员来说不够直观。SAX也不支持修改XML文档和随机读取。

Jdom试图组合DOM和SAX的优点。它被设计成一个可以在小内存上快速执行轻量级api 。jdom也支持随机读取整个文档，但是令人惊奇的是它并不需要把整个文档读到内存中。这个api支持未来的当需要时才读入信息的次轻量级操作。还有，jdom通过标准的构造器和set方法支持XML文档的修改。

public class SimpleTest
{
     public static void main(String[] args)
     {
          System.out.println("Hello world");
     }
}

1、JAVA语言是大小写敏感的。
2、程序是从MAIN（）开始执行。MAIN（）必须是public 的
JAVA中的数据类型

char型

In Java, the char type describes a code unit in the UTF-16 encoding.

boolean型  true false


变量
1、 声名：变量类型：变量名；
例：double salary;
         int    age;

2、初始化
变量必须初始化后才能使用。

注：变量声名可以在任何地方。

常量：

在java中用final表示一个常量
例：

public class Constants
{
   public static void main(String[] args)
   {
      final double CM_PER_INCH = 2.54;
      double paperWidth = 8.5;
      double paperHeight = 11;
      System.out.println("Paper size in centimeters: "
         + paperWidth * CM_PER_INCH + " by " + paperHeight * CM_PER_INCH);
   }
}

    myEnv.registeUserInit(authToken);

 public void registeUserInit(Authorization authToken){
      try{
          this.forumFactory = ForumFactory.getInstance(authToken);
           this.pageUser=this.forumFactory.getUserManager().getUser(authToken.getUserID());
        }catch(Exception ex){
        }
  }

通过myEnv的registeUserInit()方法将UserEnvFront中代表当前用户个人信息的对象pageUser进行赋值，但这不是最主要的，最主要的是该方法中的this.forumFactory = ForumFactory.getInstance(authToken);这句话非常非常关键。让我们潜入ForumFactory的静态方法getInstance（）。


 public static ForumFactory getInstance(Authorization authorization) {
        //If no valid authorization passed in, return null.
        if (authorization == null) {
            return null;
        }
        if (factory == null) {
            synchronized(initLock) {
                if (factory == null) {
                    String classNameProp =
                        JiveGlobals.getJiveProperty("ForumFactory.className");
                    if (classNameProp != null) {
                        className = classNameProp;
                    }
                    try {
                        //Load the class and create an instance.
                        Class c = Class.forName(className);
                        factory = (ForumFactory)c.newInstance();
                    }
                    catch (Exception e) {
                        System.err.println("Failed to load ForumFactory class "
                            + className + ". Jive cannot function normally.");
                        e.printStackTrace();
                        return null;
                    }
                }
            }

        }

        //Now, create a forum factory proxy.
        return new ForumFactoryProxy(authorization, factory,
                factory.getPermissions(authorization));
    }

public class ForumPermissions implements Cacheable { 
/**
* Permission to read object.
*/
public static final int READ = 0;

/**
* Permission to administer the entire sytem.
*/
public static final int SYSTEM_ADMIN = 1;

/**
* Permission to administer a particular forum.
*/
public static final int FORUM_ADMIN = 2;

/**
* Permission to administer a particular user.
*/
public static final int USER_ADMIN = 3;

/**
* Permission to administer a particular group.
*/
public static final int GROUP_ADMIN = 4;

/**
* Permission to moderate threads.
*/
public static final int MODERATE_THREADS = 5;

/**
* Permission to create a new thread.
*/
public static final int CREATE_THREAD = 6;

/**
* Permission to create a new message.
*/
public static final int CREATE_MESSAGE = 7;

/**
* Permission to moderate messages.
*/
public static final int MODERATE_MESSAGES = 8;

.....

public boolean isSystemOrForumAdmin() {
　　return (values[FORUM_ADMIN] || values[SYSTEM_ADMIN]);
}

.....

}

public class ForumProxy implements Forum {

private ForumPermissions permissions;
private Forum forum; 
this.authorization = authorization; 

public ForumProxy(Forum forum, Authorization authorization,
ForumPermissions permissions)
{
this.forum = forum;
this.authorization = authorization;
this.permissions = permissions;
}

.....

public void setName(String name) throws UnauthorizedException,
ForumAlreadyExistsException
{
　　//只有是系统或论坛管理者才可以修改名称
　　if (permissions.isSystemOrForumAdmin()) {
　　　　forum.setName(name);
　　}
　　else {
　　　　throw new UnauthorizedException();
　　}
}

...

}

而DbForum才是接口Forum的真正实现,以修改论坛名称为例:

public class DbForum implements Forum, Cacheable {
...

public void setName(String name) throws ForumAlreadyExistsException {

　　....

　　this.name = name;
　　//这里真正将新名称保存到数据库中 
　　saveToDb();

　　....
}



... 

}

public class ForumFactoryProxy extends ForumFactory { 
　　protected ForumFactory factory;
　　protected Authorization authorization;
　　protected ForumPermissions permissions;

　　public ForumFactoryProxy(Authorization authorization, ForumFactory factory,
　　ForumPermissions permissions)
　　{
　　　　this.factory = factory;
　　　　this.authorization = authorization;
　　　　this.permissions = permissions;
　　}

　　public Forum createForum(String name, String description)
　　　　　　throws UnauthorizedException, ForumAlreadyExistsException
　　{
　　　　//只有系统管理者才可以创建forum 
　　　　if (permissions.get(ForumPermissions.SYSTEM_ADMIN)) {
　　　　　　Forum newForum = factory.createForum(name, description);
　　　　　　return new ForumProxy(newForum, authorization, permissions);
　　　　}
　　　　else {
　　　　　　throw new UnauthorizedException();
　　}
}

public void foFetches(Hashtable ht){
　　synchronized(ht){
　　　　//具体的连续数据获取动作.. 
　　} 

}

public void foFetches(Hashtable ht){


　　Hashttable newht=(Hashtable)ht.clone();

}

问题又来了,由于是针对clone出来的对象操作,如果原来的母体被其他客户端操作修改了, 那么对clone出来的对象操作就没有意义了.

最后解决方案:我们可以等其他客户端修改完成后再进行clone,也就是说,这个特别的客户端先通过调用一个叫clone的方法来进行一系列数据获取操作.但实际上没有真正的进行对象拷贝,直至有其他客户端修改了这个对象Collection.

使用Proxy实现这个方案.这就是copy-on-write操作.

Proxy应用范围很广,现在流行的分布计算方式RMI和Corba等都是Proxy模式的应用.

更多Proxy应用,见http://www.research.umbc.edu/~tarr/cs491/lectures/Proxy.pdf

Sun公司的 Explore the Dynamic Proxy API Dynamic Proxy Classes