实现文件的上传，代码如下：
<%!
 //服务器端保存上传文件的路径
    String saveDirectory = "g:\\upload\\";
    // 临时路径 一旦文件大小超过getSizeThreshold()的值时数据存放在硬盘的目录
    String tmpDirectory = "g:\\upload\\tmp\\";
    // 最多只允许在内存中存储的数据大小,单位:字节
    int maxPostSize = 1024 * 1024;
%>
<%
    // 文件内容 
    String FileDescription = null;
    // 文件名（包括路径）
    String FileName = null;
    // 文件大小
    long FileSize = 0;
    // 文件类型
    String ContentType = null;

%>

<%
   DiskFileUpload fu = new DiskFileUpload();
    // 设置允许用户上传文件大小,单位:字节
   fu.setSizeMax(200*1024*1024);
    // 设置最多只允许在内存中存储的数据,单位:字节
   fu.setSizeThreshold(maxPostSize);
    // 设置一旦文件大小超过getSizeThreshold()的值时数据存放在硬盘的目录
   fu.setRepositoryPath("g:\\upload\\tmp\\");
    //开始读取上传信息 得到所有文件
   try{
      List fileItems = fu.parseRequest(request);
     }catch(FileUploadException e){
         //这里异常产生的原因可能是用户上传文件超过限制、不明类型的文件等
         //自己处理的代码
     }
%>
<%
   // 依次处理每个上传的文件
   Iterator iter = fileItems.iterator();
   while (iter.hasNext()) {
     FileItem item = (FileItem) iter.next();
       //忽略其他不是文件域的所有表单信息
     if (!item.isFormField()) {
       String name = item.getName();
       long size = item.getSize();
       String  contentType = item.getContentType();
     if((name==null||name.equals("")) && size==0)
       continue;
%>
<%
   //保存上传的文件到指定的目录
  String[] names=StringUtils.split(name,"\\");  //对原来带路径的文件名进行分割
   name = names[names.length-1];
   item.write(new File(saveDirectory+ name));
  }
}
%>
 下面是其简单的使用场景：
 A、上传项目只要足够小，就应该保留在内存里。
 B、较大的项目应该被写在硬盘的临时文件上。
 C、非常大的上传请求应该避免。
 D、限制项目在内存中所占的空间，限制最大的上传请求，并且设定临时文件的位置。
 
 可以根据具体使用用servlet来重写，具体参数配置可以统一放置到一配置文件
 

         try
   {
          
             aFilePath = getFilePath(request);
             aFileName = getFileName(request);

             response.setContentType(getContentType(aFileName) + "; charset=UTF-8");
             response.setHeader("Content-disposition", "attachment; filename=" + aFileName);

             in = new  FileInputStream(aFilePath + aFileName); //读入文件
            out = response.getOutputStream();
            out.flush();
            int aRead = 0;
           while((aRead = in.read()) != -1 & in != null)
        {
             out.write(aRead);
         }
           out.flush();
      }
       catch(Throwable e)
     {
     log.error("FileDownload doGet() IO error!",e);
      }
         finally
         {
             try
             {
                 in.close();
                 out.close();
             }
             catch(Throwable e)
             {
              log.error("FileDownload doGet() IO close error!",e);
             }
         }
     }

3、Jsp如何实现网页的重定向 ，2002-05-16· ·包路跃··Yesky，http://www.yesky.com/SoftChannel/72342371945283584/20020424/1608521.shtml

4、判断文件或文件夹是否存在，作者：罗会涛，http://www.fawcette.com/china/XmlFile.aspx?ID=205

5、java.util中的Date类,By Wing, 出处：处处,http://www.linuxaid.com.cn/articles/1/1/119413536.shtml

6、计算Java日期－－学习怎样创建和使用日期，作者：Robert Nielsen ，http://www.javaresearch.org/article/showarticle.jsp?column=1&thread=497

本文是分享文档站长胡萝卜的作品。大家可以自由阅读、在网络上进行分发，前提是必须保留本文档的完整性。
分享文档是一家专业的Java技术网站，给中国Java 程序员提供各种Java资源如文档，工具，教程，社区交流等。
我们的官方网站是：http://chinesedocument.com
我们的官方论坛是：http://bbs.chinesedocument.com
请大家多多关注分享文档，我们还会发布更多优秀的文档！

第1章 使用FileUpload
FileUpload能以多种方式使用，这取决于你的应用需求。举个简单的例子，你可能调用一个单独的方法来解析servelt的请求，并且处理那些项目。 从另一个方面来讲，你可能想自定义FileUpload来完全控制个别项目的存贮；例如，你想流化那些内容，并存到数据库里去。
这里我们会介绍使用FileUpload的基础原则，并描述一些简单的通用的使用模式。我们会在在其它地方介绍关于FileUpload的自定义。
FileUpload依赖于一些公用的IO，因此，要确保在你继续之前，你的classpath里已经有依赖页面里提起的那些版本。

第2章 FileUpload如何工作？
一个上传请求由一系列根据RFC1867（"Form-based File Upload in HTML".）编码的项目列表组成。FileUpload可以解析这样的请求，并为你的应用提供那些已上传的项目的列表。每一个这样的项目都实现了FielItem接口，我们不用管它们的底层实现。
这个页面描述了commons fileupload库的常用API。这些常用API是非常方便的途径。然而，为了最好的性能，你可能更喜欢最快的Streaming API 。
每一个文件项目有一些自己的属性，这些属性也许正是你的应用程序感兴趣的地方。例如，每个项目有个一个名字和内容类型，并且可以提供一个输入流来访问它们的数据。另一方面来看，你可能需要用不同方式来处理不同的项目，这就依赖于那些项目是否是一个正常的表单字域，也就是说，这些数据来自于一个普通的文本框或类似HTML的字域，还是一个要上传文件字段。FileItem接口提供一些方法来做这样一个决定，并且用最合适的方法访问这些数据。
FileUpload使用FileItemFactory创建一个新的文件项目。这将会给FileUpload最好的灵活性。工厂最终控制每个项目如何被创建。默认的工厂在内存或者硬盘里存储项目的数据，这依赖于项目的大小（例如，有多少字节的数据。）。不过，为了适用于你的应用，你还是可以自定义这种行为的。

第3章 servlets and portlets
从V1.1版开始，FileUpload就开始支持servlet和portlet的文件上传请求。这两种环境的用法基本上差不多，因此，文档的剩下部分都将是在servlet环境里。
如果你正在构建一个portet应用，那么下面两个差别是你在读文档时应注意的：
你在哪里引用了ServletFileUpload类，就用PortletFileUpload类来替代它。
你在哪里引用了HttpServletRequest类，就用ActionRequest类替代它。

第4章 解析请求
在你同那些上传的项目一起工作前，你需要先解析请求本身。以确保这个请求确实是一个文件上传请求。FileUpload是通过调用一个静态方法来实现的。
// Check that we have a file upload request
boolean isMultipart = ServletFileUpload.isMultipartContent(request);
现在，我们已经准备好解析请求里的项目了。

4.1 最简单的例子
下面是一些简单的使用场景：
􀁺 　 上传项目只要足够小，就应该保留在内存里。
􀁺 　 较大的项目应该被写在硬盘的临时文件上。
􀁺 　 非常大的上传请求应该避免。
􀁺 　 限制项目在内存中所占的空间，限制最大的上传请求，并且设定临时文件的位置。
处理这个场景的请求很简单：
// Create a factory for disk-based file items
FileItemFactory factory = new DiskFileItemFactory();
// Create a new file upload handler
ServletFileUpload upload = new ServletFileUpload(factory);
// Parse the request
List /* FileItem */ items = upload.parseRequest(request);
这就是我们所需要的全部代码了！
解析的结果就是一个项目的List,每个项目都实现了FileItem接口。我们将在下面讨论如何处理这些项目。
4.2 训练如何控制
如果你的使用场景和上面那个简单的例子很接近，但是你又需要一点点控制，那么你可以很容易地定义upload处理器或者文件项目工厂的行为。下面这个例子显示了几个配置选项。
// Create a factory for disk-based file items
DiskFileItemFactory factory = new DiskFileItemFactory();
// Set factory constraints
factory.setSizeThreshold(yourMaxMemorySize);
factory.setRepository(yourTempDirectory);
// Create a new file upload handler
ServletFileUpload upload = new ServletFileUpload(factory);
// Set overall request size constraint
upload.setSizeMax(yourMaxRequestSize);
// Parse the request
List /* FileItem */ items = upload.parseRequest(request);
当然，每个配置方法是独立于其它任意一个的。但是如果你想一次性配置他们，你可以用parseRequest()的另一个重载方法，像这样：
// Create a factory for disk-based file items
DiskFileItemFactory factory = new DiskFileItemFactory(
yourMaxMemorySize, yourTempDirectory);
如果你还想使用更多的控制，比如存储项目到其它地方（如，数据库），那么你可以看FileUpload自定义介绍。

第5章 处理上传的项目
一旦解析完成，那么你会得到一个待处理的文件项目列表。很多的情况下，你会想用不同的方式来处理文件上传域和正常的表单域，因此，你可以这样做：
// Process the uploaded items
Iterator iter = items.iterator();
while (iter.hasNext()) {
  FileItem item = (FileItem) iter.next();
  if (item.isFormField()) {
    processFormField(item);
  } else {
    processUploadedFile(item);
  }
}
对于普通的表单域来说，你可能对项目的名称和字符型值 很感兴趣。就像你希望的那样，照下面的做：
// Process a regular form field
if (item.isFormField()) {
  String name = item.getFieldName();
  String value = item.getString();
  ...
}
对于上传文件，这里就有很多不同啦~你可能想知道更多其它的内容。下面是个例子，里面包含了不少你感兴趣的方法。
// Process a file upload
if (!item.isFormField()) {
  String fieldName = item.getFieldName();
  String fileName = item.getName();
  String contentType = item.getContentType();
  boolean isInMemory = item.isInMemory();
  long sizeInBytes = item.getSize();
  ...
}
对于上传的文件，你肯定不希望总是通过内存来访问它，除非它很小，或者你实在没有别的选择余地了。你很希望使用流来处理文件内容或者将文件保存到它的最终位置。FileUpload提供简单的方式来完成两方面的需求。
// Process a file upload
if (writeToFile) {
  File uploadedFile = new File(...);
  item.write(uploadedFile);
} else {
  InputStream uploadedStream = item.getInputStream();
  ...
  uploadedStream.close();
}
注意：在FileUpload的默认实现中wirte()方法应该值得关注，如果数据还在临时文件里没有移除，那么这个方法就会试图重命名这个文件为相应的目标文件。事实上如果重命名失败了的话，数据就仅仅被拷贝。
如果你需要访问内存中的上传数据，你可以用get()方法来获得数据的二进制数组形式。
// Process a file upload in memory
byte[] data = item.get();
...

第6章 清除资源
这一节只适用于你使用了DiskFileItem。换句话说，它只适用于你在处理上传文件之前将上传文件写入过临时文件这种情形。
像这种临时文件会被自动删除， 如果它们不再被使用（更确切地说，java.io.File的实例已经被GC掉了。 ）这是由org.apache.commons.io.FileCleaner类在后台完成的，它会启动一个收割机线程。
这个收割机线程在它不再被需要时会被停止。在servlet环境里，这是通过指定一个名叫FileCleanerCleanup的servlet上下文监听器来实现的。要做到这里，在你的web.xml增加下面的代码：
<web-app>
...
<listener>
<listener-class>
org.apache.commons.fileupload.servlet.FileCleanerCleanup
</listener-class>
</listener>
...
</web-app>
不幸的是，事情到这里还没完。如果你和下面的情况一样，那么你就只需要按照上面的做，就可以清除资源了。
你使用的是commons-io 1.3或者更晚的版本。
你是从web应用的web-inf/lib里载入commons-io的，并不是从其它位置，如Tomcat的common/lib下。
如果commons-io 1.3是从你的WEB容器的classpath里载入的，那么，下面的情况可能会出现：
建议你运行两个应用，一个叫A，一个叫B。（这两个应用可能是完全一样，只不过上下文名称不一样。）这两个应用都使用了FileCleanerCleanup。现在，如果你终止应用A，B还在运行，这时，A会终止B的收割机线程。换言之，你要十分仔细地考虑是使用FileCleanerCleanup，还是不使用。

第7章 观察上传进度
如果你希望可以上传很大的文件，这时，你可能想将上传的状态告诉用户，如已经接收了多少。
观察上传进度需要通过一个处理监听器来实现。
//Create a progress listener
ProgressListener progressListener = new ProgressListener(){
  public void update(long pBytesRead, long pContentLength, int pItems) {
    System.out.println("We are currently reading item " + pItems);
    if (pContentLength == -1) {
      System.out.println("So far, " + pBytesRead + " bytes have been read.");
    } else {
      System.out.println("So far, " + pBytesRead + " of " + pContentLength
      + " bytes have been read.");
    }
  }
};
upload.setProgressListener(progressListener);
上面这个监听器是有问题的。因为它非常频繁地被调用。这会带来性能问题。一个比较好的解决办法是，减少调用。例如，如果megabytes被改变，那么就发出一个消息。
//Create a progress listener
ProgressListener progressListener = new ProgressListener(){
  private long megaBytes = -1;
  public void update(long pBytesRead, long pContentLength, int pItems) {
    long mBytes = pBytesRead / 1000000;
    if (megaBytes == mBytes) {
      return;
    }
    megaBytes = mBytes;
    System.out.println("We are currently reading item " + pItems);
    if (pContentLength == -1) {
      System.out.println("So far, " + pBytesRead + " bytes have been read.");
    } else {
      System.out.println("So far, " + pBytesRead + " of " + pContentLength
      + " bytes have been read.");
    }
  }
};

正则表达式是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为“元字符”）。模式描述在搜索文本时要匹配的一个或多个字符串。

下面是正则表达式的一些示例：

下表包含了元字符的完整列表以及它们在正则表达式上下文中的行为：

现在，返回Java。就象前面我们所做的那样，你必须创建测试字符串，创建把正则表达式编译到Pattern对象所必需的对象，以及创建一个PatternMatcher对象：

XMLBeans是Bea公司针对XML处理的一个项目，现在已经提供免费下载和使用，目前的最新版本是1.0。

1 为什么使用XMLBeans

在XMLBeans之前，我们访问xml数据和文档有两种选择：

1. 使用DOM、SAX来访问XML数据和文档的内容

2. 使用JAXB等技术将XML映射为java类

不管你使用哪一种，你都无法完整的访问该XML数据和对象的丰富内容和Schema信息。产生的原因是因为java数据模型和XML之间不匹配造成的，所以应用中你要不就选择了可扩展性，要不就只能选择系统的强壮性。

随着XMLBeans的出现，我们不需要再采取这种折衷的措施了。XMLBeans提供了更多的特性来访问XML数据和文档：

1.   XMLBeans是基于标记流，因此可以轻松的使用指针在xml数据和文档之间导航。指针接口适用于所有xml数据和文档。

2.   如果你的xml数据和文档有一个schema的话，XMLBeans将给您生成这些XML数据和文档的java类“视图”（也就是访问这些XML数据和文档的java代码）。

3.   开发者可以使用这些java代码轻松的读／写xml数据和文档，而且被强制的执行xml schema中规定的一些约束。

4.   java类“视图”都能够忠实的表述原始xml数据和文档的内容，因为java类“视图”都是基于受保护的、最基本的xml表现。

所以使用XMLBeans来访问xml 数据和文档的好处是显而易见的：

1.   完全使用面向对象的观点来看待和处理数据和文档

2.   开发者不再需要编写大量的代码来访问XML数据和文档

3.   可以使用schema中规定的对于数据的约束条件，而不需要自己去编写实现这些约束的代码

4.   不需要解析所有的xml数据和文档而仅仅是为了访问其中的某个数据项

关于XMLBeans更详细的情况请大家访问http://dev2dev.bea.com/technologies/xmlbeans/

2 环境和工具准备

XMLBeans中的大量工作使用了Ant工具，所以再开始工作之前请下载Ant工具并使它正常运行。

XMLBeans的java实现请大家到bea的网站上下载：http://dev2dev.bea.com/technologies/xmlbeans/index.jsp

在执行过程中，还需要用访问xml的dom组件，也就是xml-apis.jar文件，可到http://xml.apache.org/xerces2-j/index.html下载。附件中的test-XMLBeans.rar文件中也有这个jar文件。

3 第一个例子

3.1    实例说明

我们这里使用一个订单的例子,他的实例文档如下:

<po:purchase-order xmlns:po=" http://vivianj.go.nease.net/easypo ">

    <po:customer>

  <po:name>Gladys Kravitz</po:name>

  <po:address>Anytown, PA</po:address>

    </po:customer>

    <po:date>2003-01-07T14:16:00-05:00</po:date>

    <po:line-item>

  <po:description>Burnham's Celestial Handbook, Vol 1</po:description>

  <po:per-unit-ounces>5</po:per-unit-ounces>

  <po:price>21.79</po:price>

  <po:quantity>2</po:quantity>

    </po:line-item>

    <po:line-item>

  <po:description>Burnham's Celestial Handbook, Vol 2</po:description>

  <po:per-unit-ounces>5</po:per-unit-ounces>

  <po:price>19.89</po:price>

  <po:quantity>2</po:quantity>

    </po:line-item>

<po:shipper>

  <po:name>ZipShip</po:name>

  <po:per-ounce-rate>0.74</po:per-ounce-rate>

    </po:shipper>

</po:purchase-order>

我们使用下面的schema来描述这个实例文档:

<xs:schema

   xmlns:xs="http://www.w3.org/2001/XMLSchema"

   xmlns:po="http://vivianj.go.nease.net/easypo"

   targetNamespace="http://vivianj.go.nease.net/easypo"

   elementFormDefault="qualified">

  <xs:element name="purchase-order">

    <xs:complexType>

      <xs:sequence>

  <xs:element name="customer" type="po:customer"/>

  <xs:element name="date" type="xs:dateTime"/>

  <xs:element name="line-item" type="po:line-item" minOccurs="0" maxOccurs="unbounded"/>

  <xs:element name="shipper" type="po:shipper" minOccurs="0" maxOccurs="1"/>

      </xs:sequence>

    </xs:complexType>

  </xs:element>

  <xs:complexType name="customer">

    <xs:sequence>

      <xs:element name="name" type="xs:string"/>

      <xs:element name="address" type="xs:string"/>

    </xs:sequence>

    <xs:attribute name="age" type="xs:int"/>

  </xs:complexType>

  <xs:complexType name="line-item">

    <xs:sequence>

      <xs:element name="description" type="xs:string"/>

      <xs:element name="per-unit-ounces" type="xs:decimal"/>

      <xs:element name="price" type="xs:decimal"/>

      <xs:element name="quantity" type="xs:integer"/>

    </xs:sequence>

  </xs:complexType>

  <xs:complexType name="shipper">

    <xs:sequence>

      <xs:element name="name" type="xs:string"/>

      <xs:element name="per-ounce-rate" type="xs:decimal"/>

    </xs:sequence>

  </xs:complexType>

</xs:schema>

现在，要访问的xml数据已经确定了，而且已经用schema来描述他了，剩下的就是使用XMLBeans来辅助生成访问XML数据的java代码了，下面的章节将详细的介绍这部分内容

3.2    ant辅助生成访问XML数据的java代码

3.2.1      外部jar文件

在使用XMLBeans生成访问XML数据的java代码时，我们需要用到xbean.jar文件，下载的XMLBeans里面有这个文件。

3.2.2      增加的taskdef

编译脚本执行时候必须增加一个XMLBean的taskdef，内容如下：

<taskdef name="xmlbean" classname="com.bea.xbean.tool.XMLBean" classpath="path/to/xbean.jar"/>

3.2.3      xmlbean

使用xmlbean标签来生成访问xml数据的java代码，简单的例子如下：

<xmlbean schema="schemas" destfile="Schemas.jar"/>

<xmlbean schema="schemas／easypo.xsd" destfile="Schemas.jar" srcgendir="." ／>

第一个例子表示为schemas下面所有的*.xsd文件生成访问代码，将所有的代码编译好后放入Schemas.jar文件中。

第二个例子表示为schemas下面所有的easypo.xsd文件生成访问代码，将所有的代码编译好后放入Schemas.jar文件中，而且将生成的。Java文件放在当前目录下。

其中的参数简单的说明如下：

xmlbean 标签表示这是要生成指定schema文件的访问代码。

Schema  属性表示要生成访问代码的xsd文件的范围，可以是一个目录，也可以

是一个文件或者使用fileset进行定义。

Destfile  属性定义了被生成的代码编译后将放在那个文件中。

Rcgendir 属性则表示生成的。Java文件将放在那个目录中。

Xmlbean标签支持的其它参数和相关的说明请参考XMLBeans的帮助文档，这里不作过多的说明。

3.2.4      实际的build.xml

<project name="MyProject" default="compile" basedir=".">

<property name="src" value="."/>

<property name="build" value="build"/>

<property name="dist"  value="dist"/>

<property name="classpath" value="./xkit/lib/xbean.jar "/>

<target name="init">

    <!-- Create the build directory structure used by compile -->

    <mkdir dir="${build}"/>

</target>

<target name="compile" depends="init">

    <!-- Compile the java code from ${src} into ${build} -->

    <taskdef name="xmlbean" classname="com.bea.xbean.tool.XMLBean" classpath="${classpath}"/>

    <xmlbean schema="schemas/easypo.xsd" classpath="${classpath}" destfile="easypo.jar" srcgendir="${src}"/>

  </target>

</project>

3.2.5      生成jar文件

现在你可以进入build.xml文件所在的目录，执行ant －f build.xml来生成所有访问该easypo.xml的代码。

执行完以后，这个目录下面会多出一个Schemas.jar文件，他包含了所有被生成和编译了的、访问xml文档的.class文件。目录下面会多出一个net目录,他的子目录下包含了所有被生成的.java文件.实际的jar文件构成请大家参考作者提供的Schemas.jar文件.

4 测试一下

4.1    测试代码

好了,现在我们来写个例子,测试一下是否可以成功的访问xml数据.完整的代码请参看

//解析xml实例文档,他的参数poFile是一个file类型的参数

//所以需要我们将3.1的实例文档保存为一个.xml文档

PurchaseOrderDocument poDoc =

      PurchaseOrderDocument.Factory.parse(poFile);

//创建一个访问该xml实例文档的接口PurchaseOrder

/**[注]  让作者感到很意外的是,bea提供的例子代码中这段的定义是这样的：

*PurchaseOrder po = poDoc.getPurchaseOrder();

*也就是说PurchaseOrder这个接口应该是一个单独的类，但是作者查看XMLBeans

*最后生成的.java文件中，这个PurchaseOrder却是作为PurchaseOrderDocument的一

*个内部类出现的

*/

PurchaseOrderDocument.PurchaseOrder po = poDoc.getPurchaseOrder();

//直接过去其中的所有lineitem子元素的所有内容,他返回一个lineitem对象的数组.

  LineItem[] lineitems = po.getLineItemArray();

  System.out.println("Purchase order has " + lineitems.length + " line items.");

  double totalAmount = 0.0;

  int numberOfItems = 0;

//直接使用对应的get方法来获取对应属性的值

  for (int j = 0; j < lineitems.length; j++)

  {

      System.out.println(" Line item: " + j);

      System.out.println(

    "   Description: " + lineitems[j].getDescription());

      System.out.println("   Quantity: " + lineitems[j].getQuantity());

      System.out.println("   Price: " + lineitems[j].getPrice());

      numberOfItems += lineitems[j].getQuantity().intValue();

      totalAmount += lineitems[j].getPrice().doubleValue() * lineitems[j].getQuantity().doubleValue();

  }

  System.out.println("Total items: " + numberOfItems);

  System.out.println("Total amount: " + totalAmount);

4.2    测试结果

运行这段代码,应该在控制台打印如下信息:

Purchase order has 3 line items.

 Line item 0

   Description: Burnham's Celestial Handbook, Vol 1

   Quantity: 2

   Price: 21.79

 Line item 1

   Description: Burnham's Celestial Handbook, Vol 2

   Quantity: 2

   Price: 19.89

Total items: 4

Total amount: 41.68

5 总结

XMLBeans是Bea公司的一个公开源代码项目，以Schema为基础建立的、访问xml的一种解决方法，提供了访问和处理xml数据和文档时既可以完全的访问xml的内容、又不丢失xml的schema信息的强大功能。使用XMLBeans可以让您用面向对象的观点来对待和处理xml数据和文档，同时又可以忠实于该xml数据对应的xml结构和schema。

本文中作者简单的介绍了XMLBeans，并且给出了一个简单的例子，详细的演示了如何配置XMLBeans，如何使用他的ant扩展辅助生成访问xml的java代码，如何编写客户端来测试该段代码是否成功执行的全过程。希望能够让大家掌握如何使用XMLBeans来简化各自的开发工作、提高自己的开发速度。XMLBeans的高级应用将在接下来的文章中介绍。

参考资料:

1. ANT的帮助 http://ant.apache.org/

2. XMLBeans的帮助 http://dev2dev.bea.com/technologies/xmlbeans/

工具下载:

1. ANT工具下载 http://archive.apache.org/dist/ant/binaries/

2. XMLBeans下载  http://dev2dev.bea.com/technologies/xmlbeans/

作者的所有工作文件： test-XMLBeans.rar

作者信息：

姓名: 肖菁

联系方式: 0731-6665772,jing.xiao@chinacreator.com

简介： 作者目前是湖南省长沙铁道学院科创计算机系统集成有限公司软件中心软件工程师，IBM developerworks／BEA dev2dev撰稿人，主要研究J2EE编程技术、Web Service技术以及他们在websphere、weblogic、apache平台上的实现，拥有IBM 的 Developing With Websphere Studio证书。欢迎大家访问作者的个人网站： vivianj.go.nease.net