在应用启动时需要装入应用初始化数据到context 中。

动作要领

创建一个类，实现org.apache.struts.action.PlugIn接口，并且在struts-config.xml文件中指定plug-in元素。下面的XML 片断展示了一个plug-in 声明以及一个嵌套的set-property元素来设置定制属性：

<plug-in className="com.oreilly.strutsckbk.CustomPlugin" >

  <set-property property="customData"

                   value="Hello from the plugin"/>

</plug-in>

动作变化

Struts提供了一个PlugIn接口，你可以用它来创建在应用启动时初始化的定制服务。PlugIn接口的Java源代码示于Example 2-1. (为了清晰起见，去除了JavaDoc 文档)

Example 2-1. Struts PlugIn 接口

package org.apache.struts.action;

import javax.servlet.ServletException;
import org.apache.struts.config.ModuleConfig;

public interface PlugIn {

    public void destroy( );

    public void init(ActionServlet servlet, ModuleConfig config)
        throws ServletException;
}

为了实现一个plug-in，只需要实现这个接口并且在struts-config.xml文件中声明这个plug-in 实现。有两个方法必须被实现：即init()和destroy( ), 它们在插件的生命周期中被调用。Struts 在启动ActionServlet时实例化plug-in 之后调用init( )。Struts则在ActionServlet被销毁时调用destroy()方法，通常是在一个用服务器停止时。首先，这个 plug-in 特征似乎是很单纯和有限的。然而，通过使用Struts的另外一个特征，即set-property元素，你可以将特殊的信息传递到plug-in中。这种能力增强了这些类的灵活性。

对给定plug-in的所有set-property元素都将在调用plug-in的init( )方法之前进行处理。这允许plug-in 在init( )方法中使用属性的值。

Struts 将对ActionServlet和plug-in的ModuleConfig的引用作为引数传递给init( )方法。ActionServlet允许访问ServletContext来进行应用范围的对象存储。ActionServlet还可以允许你访问更多高级的容器管理的J2EE 组件，比如数据源和消息队列。ModuleConfig允许你访问定义plug-in 的模块的Struts配置。

为了更具体一些，请考虑一个简单的，但仍然相关的例子。你需要定义一个plug-in，它可以使你决定应用何时启动，以及它启动和运行了多长时间。你可以使用下面所示的类跟踪和报告你的应用的运行时间。

Example 2-2. Application uptime tracker 对象

package com.oreilly.strutsckbk;

import java.util.Date;

public class TimeTracker {

  private long startUpTimeMillis;
  private Date startedOn;

  public TimeTracker( ) {
     startUpTimeMillis = System.currentTimeMillis( );
     startedOn = new Date( );
   }

  public long getUptime( ) {
    return System.currentTimeMillis( ) - startUpTimeMillis;
  }

  public Date getStartedOn( ) {
    return startedOn;
  }
}

创建一个PlugIn接口的实现，比如Example 2-3所示，它实例化了TimeTracker。plug-in 通过plug-in 属性的值将TimeTracker实例保存在ServletContext中。你可以使用这个值来从Servlet上下文中获取TimeTracker实例。虽然这个值是硬编码的，使用属性也提供了更大的灵活性。

Example 2-3. Time tracker plugin

package com.oreilly.strutsckbk;

import javax.servlet.ServletException;

import org.apache.struts.action.ActionServlet;
import org.apache.struts.action.PlugIn;
import org.apache.struts.config.ModuleConfig;

public class TimeTrackerPlugin implements PlugIn {

    private String contextKey;
   
   public void setContextKey(String key) {
       this.contextKey = key;
   }
   
   public void init(ActionServlet servlet, ModuleConfig conf)
         throws ServletException {
      servlet.getServletContext( ).setAttribute(contextKey, new TimeTracker( ));
   }

   public void destroy( ) {
    }
}

现在你已经有了为plug-in 创建的类，你可以通过在struts-config.xml中加入plug-in元素来将其集成到Struts 应用中。

<plug-in className="com.oreilly.strutsckbk.TimeTrackerPlugin">
    <set-property property="contextKey" value="timeTracker"/>
</plug-in>

plug-in 在servlet 上下文中存储了time tracker对象。可以访问TimeTracker来显示关于应用启动运行时间的信息，下面是相关的JSP 片断：

<h4>Continuously running since 
    <bean:write name="timeTracker" 
            property="startedOn" 
              format="MM/dd/yyyy HH:mm"/> for
    <bean:write name="timeTracker" 
            property="uptime"/> milliseconds!
</h4>

你可以使用一个servlet 来载入像Struts plug-in之类的初始化数据。具有load-on-startup初始化参数的servlet，应将其设置为较低的数值，比如1, 一保证它们在应用启动时载入。容器在实例化Servlet之后将调用servlet的init( )方法。但是Struts plug-in 方式由多个优点。首先，大多数Struts 应用在其初始化设置后不需要修改web.xml文件。必须在web.xml中声明额外的Servlet意味着要维护额外的文件。其次，如果需要PlugIn接口提供对特定Struts信息的访问。最后，因为plug-in 的生命周期紧随ActionServlet的生命周期，所以可以保证在你的Struts应用所需时数据有效。

相关招式

第2.8式展示了set-property元素的另一种用法。Struts 文档中关于plug-in 的信息可以访问http://jakarta.apache.org/struts/userGuide/building_controller.html#plugin_classes.

你也可以使用一个Servlet 上下文listener 来载入初始化数据。

struts.devMode
          Whether Struts is in development mode or not
           是否为struts开发模式
struts.dispatcher.parametersWorkaround
          Whether to use a Servlet request parameter workaround necessary for some versions of WebLogic
            （某些版本的weblogic专用）是否使用一个servlet请求参数工作区（PARAMETERSWORKAROUND）
struts.enable.DynamicMethodInvocation
          Allows one to disable dynamic method invocation from the URL
            允许动态方法调用
struts.freemarker.manager.classname
          The org.apache.struts2.views.freemarker.FreemarkerManager implementation class
           org.apache.struts2.views.freemarker.FreemarkerManager接口名
struts.i18n.encoding
          The encoding to use for localization messages
           国际化信息内码
struts.i18n.reload
          Whether the localization messages should automatically be reloaded
           是否国际化信息自动加载
struts.locale
          The default locale for the Struts application
           默认的国际化地区信息
struts.mapper.class
          The org.apache.struts2.dispatcher.mapper.ActionMapper implementation class
            org.apache.struts2.dispatcher.mapper.ActionMapper接口
struts.multipart.maxSize
          The maximize size of a multipart request (file upload)
           multipart请求信息的最大尺寸（文件上传用）
struts.multipart.parser
          The org.apache.struts2.dispatcher.multipart.MultiPartRequest parser implementation for a multipart request (file upload)
          专为multipart请求信息使用的org.apache.struts2.dispatcher.multipart.MultiPartRequest解析器接口（文件上传用）

struts.multipart.saveDir
          The directory to use for storing uploaded files
           设置存储上传文件的目录夹
struts.objectFactory
          The com.opensymphony.xwork2.ObjectFactory implementation class
           com.opensymphony.xwork2.ObjectFactory接口（spring）
struts.objectFactory.spring.autoWire
          Whether Spring should autoWire or not
           是否自动绑定Spring
struts.objectFactory.spring.useClassCache
          Whether Spring should use its class cache or not
           是否spring应该使用自身的cache
struts.objectTypeDeterminer
          The com.opensymphony.xwork2.util.ObjectTypeDeterminer implementation class
            com.opensymphony.xwork2.util.ObjectTypeDeterminer接口
struts.serve.static.browserCache
          If static content served by the Struts filter should set browser caching header properties or not
           是否struts过滤器中提供的静态内容应该被浏览器缓存在头部属性中
struts.serve.static
          Whether the Struts filter should serve static content or not
           是否struts过滤器应该提供静态内容
struts.tag.altSyntax
          Whether to use the alterative syntax for the tags or not
           是否可以用替代的语法替代tags
struts.ui.templateDir
          The directory containing UI templates
           UI templates的目录夹
struts.ui.theme
          The default UI template theme
           默认的UI template主题
struts.url.http.port
          The HTTP port used by Struts URLs
           设置http端口
struts.url.https.port
          The HTTPS port used by Struts URLs
           设置https端口
struts.url.includeParams
          The default includeParams method to generate Struts URLs
          在url中产生 默认的includeParams

struts.velocity.configfile
          The Velocity configuration file path
           velocity配置文件路径
struts.velocity.contexts
          List of Velocity context names
           velocity的context列表

struts.velocity.manager.classname
          org.apache.struts2.views.velocity.VelocityManager implementation class
           org.apache.struts2.views.velocity.VelocityManager接口名
struts.velocity.toolboxlocation
          The location of the Velocity toolbox
           velocity工具盒的位置
struts.xslt.nocache
          Whether or not XSLT templates should not be cached
           是否XSLT模版应该被缓存 
本文转自福州IT信息网(http://www.fzic.net),详细出处参考：http://www.fzic.net/SrcShow.asp?Src_ID=990

在Struts2中，radio标签可以使用一个list来输出一组radio按钮，
        <s:radio name="sex"　list="#{'male','female'}"　label="%{getText('app.label.sex')}" />
但是如何设置其中一个被默认选中。

查阅了struts2的文档，发现radio标签有一个value属性是用于对radio的进行预选的：　http://struts.apache.org/2.x/docs/radio.html
value： Preset the value of input element.
于是，进行了试验，<s:radio name="sex"　list="#{'male','female'}"　label="%{getText('app.label.sex')}" value="male" />
结果失败了。male的值并没有被选中，经过反复研究，终于得到了正确的结果：
<s:radio name="sex"　list="#{'male','female'}"　label="%{getText('app.label.sex')}" value="'male'" />
看到其中的区别了吗，就是多了两个单引号。
我认为这是因为value属性的特性引起的。如果male没有加引号，那么struts2会去值的堆栈中寻找变量名为male的值，结果找不到。
加上单引号后，struts2（应该是ognl）把'male'认为是一个简单的字符串。

这样，radio就能够正确地匹配到值，使指定的值默认被选中

　　Struts2提供了一种可插拔方式来管理插件，安装Struts2的JSON插件与安装普通插件并没有太大的区别，一样只需要将Struts2插件的JAR文件复制到Web应用的WEB-INF/lib路径下即可。

　　安装JSON插件按如下步骤进行：

　　(1)登陆http://code.google.com/p/jsonplugin/downloads/list站点，下载Struts2的JSON插件的最新版本，当前最新版本是0.7，我们可以下载该版本的JSON插件。

　　(2)将下载到的jsonplugin-0.7.jar文件复制到Web应用的WEB-INF路径下，即可完成JSON插件的安装。

　　实现Actio逻辑

　　假设wo,en输入页面中包含了三个表单域，这三个表单域对于三个请求参数，因此应该使用Action来封装这三个请求参数。三个表单域的name分别为field1、field2和field3。

　　处理该请求的Action类代码如下：　　

public class JSONExample 　　{ 　　//封装请求参数的三个属性 　　private String field1; 　　private transient String field2; 　　private String field3; 　　//封装处理结果的属性 　　private int[] ints = {10, 20}; 　　private Map map = new HashMap(); 　　private String customName = "custom"; 　　//三个请求参数对应的setter和getter方法 　　public String getField1() 　　{ 　　return field1; 　　} 　　public void setField1(String field1) 　　{ 　　this.field1 = field1; 　　} 　　//此处省略了field1和field2两个字段的setter和getter方法 　　... 　　//封装处理结果的属性的setter和getter方法 　　public int[] getInts() 　　{ 　　return ints; 　　} 　　public void setInts(int[] ints) 　　{ 　　this.ints = ints; 　　} 　　public Map getMap() 　　{ 　　return map; 　　} 　　public void setMap(Map map) 　　{ 　　this.map = map; 　　} 　　//使用注释语法来改变该属性序列化后的属性名 　　@JSON(name="newName") 　　public String getCustomName() 　　{ 　　return this.customName; 　　} 　　public String execute() 　　{ 　　map.put("name", "yeeku"); 　　return Action.SUCCESS; 　　} 　　}

　　在上面代码中，使用了JSON注释，注释时指定了name域，name域指定Action属性被序列化成JSON对象的属性名。除此之外，JSON注释还支持如下几个域：

      serialize：设置是否序列化该属性

　　deserialize：设置是否反序列化该属性。

　　format：设置用于格式化输出、解析日期表单域的格式。例如"yyyy-MM-dd'T'HH:mm:ss"。

　　配置该Action与配置普通Action存在小小的区别，应该为该Action配置类型为json的Result。而这个Result无需配置任何视图资源。

　　配置该Action的struts.xml文件代码如下：　

＜?xml version="1.0" encoding="GBK"?＞ ＜!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd"＞ ＜struts＞ ＜constant name="struts.i18n.encoding" value="UTF-8"/＞ ＜package name="example" extends="json-default"＞ ＜action name="JSONExample" class="lee.JSONExample"＞ ＜result type="json"/＞ ＜/action＞ ＜/package＞ ＜/struts＞

　　在上面配置文件中有两个值得注意的地方：

　　第一个地方是配置struts.i18n.encoding常量时，不再是使用GBK编码，而是UTF-8编码，这是因为Ajax的POST请求都是以UTF-8的方式进行编码的。

　　第二个地方是配置包时，自己的包继承了json-default包，而不再继承默认的default包，这是因为只有在该包下才有json类型的Result。

The Struts 2 Tags can be divided into two types:

• Struts Generic Tags
  The struts generic tags are used to control the execution flow when pages are rendered. Another use of struts generic tags are data extraction.
  Further Generic Tags are classified into Control Tags and Data Tags. 
  Control Tags: The Control Tags are used for flow control, such if, else and iterate.
  Here are the list of Control Tags:
  * if
  * elseIf
  * else
  * append
  * generator
  * iterator
  * merge
  * sort
  * subset
  Data Tags: The Data Tags are used for data manipulation or creation, such as bean, push, and i18n.
  Here are the list of Data Tags:
  * a
  * action
  * bean
  * date
  * debug
  * i18n
  * include
  * param
  * push
  * set
  * text
  * url
  * property
     
• Struts UI tags
  Struts UI Tags are mainly designed to use the data from your action/value stack or from Data Tags. These tags are used to display the data on the HTML page. The UI tags are driven by templates and themes. 
  Struts UI Tags are of two types Form Tags and Non - Form tags.
  Form Tags are as follows:
  * autocompleter
  * checkbox
  * checkboxlist
  * combobox
  * datetimepicker
  * doubleselect
  * head
  * file
  * form
  * hidden
  * label
  * optiontransferselect
  * optgroup
  * password
  * radio
  * reset
  * select
  * submit
  * textarea
  * textfield
  * token
  * updownselect
  
  Non-Form UI Tags are:
  * actionerror
  * actionmessage
  * component
  * div
  * fielderror
  * table
  * tabbedPanel
  * tree
  * treenode
  

The main difference between Struts Generic Tags and Struts UI Tags are:

• The generic tags simply output some content directly from the tag while the UI tags uses templates and often group the output together with theme

来源：struts2开发组 翻译：tianxinet（胖猴）

Action 类:
• Struts1要求Action类继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action类可以实现一个Action接口，也可实现其他接口，使可选和定制的服务成为可能。Struts2提供一个ActionSupport基类去实现 常用的接口。Action接口不是必须的，任何有execute标识的POJO对象都可以用作Struts2的Action对象。

线程模式:
• Struts1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
• Struts2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）

Servlet 依赖:
• Struts1 Action 依赖于Servlet API ,因为当一个Action被调用时HttpServletRequest 和 HttpServletResponse 被传递给execute方法。
• Struts 2 Action不依赖于容器，允许Action脱离容器单独被测试。如果需要，Struts2 Action仍然可以访问初始的request和response。但是，其他的元素减少或者消除了直接访问HttpServetRequest 和 HttpServletResponse的必要性。

可测性:
• 测试Struts1 Action的一个主要问题是execute方法暴露了servlet API（这使得测试要依赖于容器）。一个第三方扩展－－Struts TestCase－－提供了一套Struts1的模拟对象（来进行测试）。
• Struts 2 Action可以通过初始化、设置属性、调用方法来测试，“依赖注入”支持也使测试更容易。

捕获输入:
• Struts1 使用ActionForm对象捕获输入。所有的ActionForm必须继承一个基类。因为其他JavaBean不能用作ActionForm，开发者经常创建多余的类捕获输入。动态Bean（DynaBeans）可以作为创建传统ActionForm的选择，但是，开发者可能是在重新描述(创建)已经存在的JavaBean（仍然会导致有冗余的javabean）。
• Struts 2直接使用Action属性作为输入属性，消除了对第二个输入对象的需求。输入属性可能是有自己(子)属性的rich对象类型。Action属性能够通过web页面上的taglibs访问。Struts2也支持ActionForm模式。rich对象类型，包括业务对象，能够用作输入/输出对象。这种ModelDriven 特性简化了taglib对POJO输入对象的引用。

表达式语言：
• Struts1 整合了JSTL，因此使用JSTL EL。这种EL有基本对象图遍历，但是对集合和索引属性的支持很弱。
• Struts2可以使用JSTL，但是也支持一个更强大和灵活的表达式语言－－"Object Graph Notation Language" (OGNL).

绑定值到页面（view）:
• Struts 1使用标准JSP机制把对象绑定到页面中来访问。
• Struts 2 使用 "ValueStack"技术，使taglib能够访问值而不需要把你的页面（view）和对象绑定起来。ValueStack策略允许通过一系列名称相同但类型不同的属性重用页面（view）。
　
类型转换：
• Struts 1 ActionForm 属性通常都是String类型。Struts1使用Commons-Beanutils进行类型转换。每个类一个转换器，对每一个实例来说是不可配置的。
• Struts2 使用OGNL进行类型转换。提供基本和常用对象的转换器。

校验：
• Struts 1支持在ActionForm的validate方法中手动校验，或者通过Commons Validator的扩展来校验。同一个类可以有不同的校验内容，但不能校验子对象。
• Struts2支持通过validate方法和XWork校验框架来进行校验。XWork校验框架使用为属性类类型定义的校验和内容校验，来支持chain校验子属性

Action执行的控制：
• Struts1支持每一个模块有单独的Request Processors（生命周期），但是模块中的所有Action必须共享相同的生命周期。
• Struts2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期。堆栈能够根据需要和不同的Action一起使用。

1. 一个请求产生并经由框架处理 - 框架根据请求匹配相应的配置，如使用哪些拦截器，action 类和结果。
2. 请求通过一系列的拦截器 - 拦截器，和拦截器组经配置后，能处理不同等级的请求，它们为请求提供了各种预处理，切面处理。这和Struts的使用 Jakarta Commons Chain 构件的 RequestProcessor类很相似。
3. 调用 Action - 产生一个新的action对象实例，并提供请求所调用的处理逻辑的方法。Struts2 可以在配置action时为请求分配其指定的方法。我们在第二部文章中将对这步骤进行进一步讨论;
4. 调用产生的结果 - 获取通过action的方法处理后返回来的结果，匹配其result class并调用产生的实例。有种情况是在UI模板去生成HTML时才去处理这些结果。如果在这种情况下，在Struts2 模板中的tags能直接返回到 action 中，取结果来呈现界面。　
5. 请求再次经过一系列的拦截器处理后返回 - 请求反顺序通过与原来进入时的拦截器链, 当然，你也可以配置在这个过程中减少或增加拦截器处理．
6. 请求返回到用户 - 最后一步是由 control 返回到servlet。通常是生成HTML返回到user, 但你也可以指定返回的HTTP头或HTTP重定向。

最明显的就是Struts2是pull-MVC 架构，就是可以直接从Action中获取所需要的数据，而不是像Struts那样必须把 beans 存到page, request,或者session中才能获取。

<form name="form1" method="post" action="<%=request.getContextPath()%>/fileUpload.do?method=upload" enctype="multipart/form-data">
  <table width="43%" border="1" align="center">
    <tr>
      <td colspan="2"><div align="center">上传周报</div></td>
    </tr>
    <tr>
      <td width="22%">文件名称</td>
      <td width="78%"><input type="text" name="fileName"></td>
    </tr>
    <tr>
      <td width="22%">选择文件</td>
      <td width="78%"><input type="file" name="docfile"/></td>
    </tr>
    <tr>
      <td width="22%">文件描述</td>
      <td><input type="textarea" name="fileDescription"/></td>
    </tr>
    <tr>
      <td colspan="2" align="center"><input type="submit" name="Submit" value="上传"><input type="reset" name="Submit2" value="重置"></td>
    </tr>
  </table>

  String filename = "";
  String filePath = "";
  try {
   is = (InputStream) docfile.getInputStream();// 把文件读入
   bis = new BufferedInputStream(is);

   filePath ="E:/upload/";// 取当前系统路径
   File rootfile = new File(filePath);
   if (!rootfile.exists()) {
    rootfile.mkdirs();
   }
   String name= new String(docfile.getFileName().getBytes("UTF-8"),"gb2312");
   filename = new Date().getTime()+request.getSession().getId()+fileName+".doc";
  fos = new FileOutputStream(filePath + filename);// 建立一个上传文件的输出流
   bos = new BufferedOutputStream(fos);
   int bytesRead = 0;
   byte[] buffer = new byte[2 * 1024];
   while ((bytesRead = bis.read(buffer)) != -1) {
    bos.write(buffer, 0, bytesRead);// 将文件写入服务器
   }
   FileUpload fileUpload=new FileUpload();
   fileUpload.setFileName(fileName);
   fileUpload.setFilePath(filePath+filename);
   fileUpload.setFileDescription(fileDescription);
   this.getSiteBusiness().getFileLoadService().save(fileUpload);
   return mapping.findForward("uploadsucess");
  }catch (Exception e) {
   e.printStackTrace();
   return mapping.getInputForward();
  } finally {
   if (bos != null) {
    try {
     bos.close();
    } catch (IOException e) {
     System.err.print(e);
     return mapping.getInputForward();
    }
   }
   if (bis != null) {
    try {
     bis.close();
    } catch (IOException e) {
     System.err.print(e);
     return mapping.getInputForward();
    }
   }
  }

 }

您肯定已经听说过控制反转 (IOC) 设计模式，因为很长一段时间以来一直在流传关于它的信息。如果您在任何功能中使用过 Spring 框架，那么您就知道其原理的作用。在本文中，我利用这一原理把一个 Struts 应用程序注入 Spring 框架，您将亲身体会到 IOC 模式的强大。

将一个 Struts 应用程序整合进 Spring 框架具有多方面的优点。首先，Spring 是为解决一些关于 JEE 的真实世界问题而设计的，比如复杂性、低性能和可测试性，等等。第二，Spring 框架包含一个 AOP 实现，允许您将面向方面技术应用于面向对象的代码。第三，一些人可能会说 Spring 框架只有处理 Struts 比 Struts 处理自己好。但是这是观点问题，我演示三种将 Struts 应用程序整合到 Spring 框架的方法后，具体由您自己决定使用哪一种。

我所演示的方法都是执行起来相对简单的，但是它们却具有明显不同的优点。我为每一种方法创建了一个独立而可用的例子，这样您就可以完全理解每种方法。

为什么 Spring 这么了不起？

Spring 的创立者 Rod Johnson 以一种批判的眼光看待 Java™ 企业软件开发，并且提议很多企业难题都能够通过战略地使用 IOC 模式（也称作依赖注入）来解决。当 Rod 和一个具有奉献精神的开放源码开发者团队将这个理论应用于实践时，结果就产生了 Spring 框架。简言之，Spring 是一个轻型的容器，利用它可以使用一个外部 XML 配置文件方便地将对象连接在一起。每个对象都可以通过显示一个 JavaBean 属性收到一个到依赖对象的引用，留给您的简单任务就只是在一个 XML 配置文件中把它们连接好。

IOC 和 Spring IOC 是一种使应用程序逻辑外在化的设计模式，所以它是被注入而不是被写入客户机代码中。将 IOC 与接口编程应用结合，就像 Spring 框架那样，产生了一种架构，这种架构能够减少客户机对特定实现逻辑的依赖。请参阅 参考资料 了解更多关于 IOC 和 Spring 的信息。

依赖注入是一个强大的特性，但是 Spring 框架能够提供更多特性。Spring 支持可插拔的事务管理器，可以给您的事务处理提供更广泛的选择范围。它集成了领先的持久性框架，并且提供一个一致的异常层次结构。Spring 还提供了一种使用面向方面代码代替正常的面向对象代码的简单机制。

Spring AOP 允许您使用拦截器 在一个或多个执行点上拦截应用程序逻辑。加强应用程序在拦截器中的日志记录逻辑会产生一个更可读的、实用的代码基础，所以拦截器广泛用于日志记录。您很快就会看到，为了处理横切关注点，Spring AOP 发布了它自己的拦截器，您也可以编写您自己的拦截器。

整合 Struts 和 Spring

与 Struts 相似，Spring 可以作为一个 MVC 实现。这两种框架都具有自己的优点和缺点，尽管大部分人同意 Struts 在 MVC 方面仍然是最好的。很多开发团队已经学会在时间紧迫的时候利用 Struts 作为构造高品质软件的基础。Struts 具有如此大的推动力，以至于开发团队宁愿整合 Spring 框架的特性，而不愿意转换成 Spring MVC。没必要进行转换对您来说是一个好消息。Spring 架构允许您将 Struts 作为 Web 框架连接到基于 Spring 的业务和持久层。最后的结果就是现在一切条件都具备了。

在接下来的小窍门中，您将会了解到三种将 Struts MVC 整合到 Spring 框架的方法。我将揭示每种方法的缺陷并且对比它们的优点。 一旦您了解到所有三种方法的作用，我将会向您展示一个令人兴奋的应用程序，这个程序使用的是这三种方法中我最喜欢的一种。

三个小窍门

接下来的每种整合技术（或者窍门）都有自己的优点和特点。我偏爱其中的一种，但是我知道这三种都能够加深您对 Struts 和 Spring 的理解。在处理各种不同情况的时候，这将给您提供一个广阔的选择范围。方法如下：

• 使用 Spring 的 ActionSupport 类整合 Structs
• 使用 Spring 的 DelegatingRequestProcessor 覆盖 Struts 的 RequestProcessor
• 将 Struts Action 管理委托给 Spring 框架

装载应用程序环境

无论您使用哪种技术，都需要使用 Spring 的 ContextLoaderPlugin 为 Struts 的 ActionServlet 装载 Spring 应用程序环境。就像添加任何其他插件一样，简单地向您的 struts-config.xml 文件添加该插件，如下所示：

<plug-in className=
  "org.springframework.web.struts.ContextLoaderPlugIn">
    <set-property property=
      "contextConfigLocation" value="/WEB-INF/beans.xml"/>
 </plug-in>

窍门 1. 使用 Spring 的 ActionSupport

手动创建一个 Spring 环境是一种整合 Struts 和 Spring 的最直观的方式。为了使它变得更简单，Spring 提供了一些帮助。为了方便地获得 Spring 环境，org.springframework.web.struts.ActionSupport 类提供了一个 getWebApplicationContext() 方法。您所做的只是从 Spring 的 ActionSupport 而不是 Struts Action 类扩展您的动作，如清单 1 所示：

package ca.nexcel.books.actions;

import Java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.ActionError;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.DynaActionForm;
import org.springframework.context.ApplicationContext;
import org.springframework.web.struts.ActionSupport;

import ca.nexcel.books.beans.Book;
import ca.nexcel.books.business.BookService;

public class SearchSubmit extends ActionSupport {   |(1)


  public ActionForward execute(
    ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request,
    HttpServletResponse response)
    throws IOException, ServletException {

    DynaActionForm searchForm = (DynaActionForm) form;
    String isbn = (String) searchForm.get("isbn");
		
    //the old fashion way
    //BookService bookService = new BookServiceImpl();
		
    ApplicationContext ctx = 
      getWebApplicationContext();    |(2)
    BookService bookService = 
      (BookService) ctx.getBean("bookService");   |(3)
        
  Book book = bookService.read(isbn.trim());

    if (null == book) {
      ActionErrors errors = new ActionErrors();
      errors.add(ActionErrors.GLOBAL_ERROR,new ActionError
        ("message.notfound"));
      saveErrors(request, errors);
      return mapping.findForward("failure") ;
  }

    request.setAttribute("book", book);
    return mapping.findForward("success");
  }
}

让我们快速思考一下这里到底发生了什么。在 (1) 处，我通过从 Spring 的 ActionSupport 类而不是 Struts 的 Action 类进行扩展，创建了一个新的 Action。在 (2) 处，我使用 getWebApplicationContext() 方法获得一个 ApplicationContext。为了获得业务服务，我使用在 (2) 处获得的环境在 (3) 处查找一个 Spring bean。

这种技术很简单并且易于理解。不幸的是，它将 Struts 动作与 Spring 框架耦合在一起。如果您想替换掉 Spring，那么您必须重写代码。并且，由于 Struts 动作不在 Spring 的控制之下，所以它不能获得 Spring AOP 的优势。当使用多重独立的 Spring 环境时，这种技术可能有用，但是在大多数情况下，这种方法不如另外两种方法合适。

窍门 2. 覆盖 RequestProcessor

将 Spring 从 Struts 动作中分离是一个更巧妙的设计选择。分离的一种方法是使用 org.springframework.web.struts.DelegatingRequestProcessor 类来覆盖 Struts 的 RequestProcessor 处理程序，如清单 2 所示：

清单 2. 通过 Spring 的 DelegatingRequestProcessor 进行整合

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE struts-config PUBLIC
          "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN"
          "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">

<struts-config>
 <form-beans>
    <form-bean name="searchForm" 
      type="org.apache.struts.validator.DynaValidatorForm">
               <form-property name="isbn"    type="Java.lang.String"/>
    </form-bean>
  
  </form-beans>

 <global-forwards type="org.apache.struts.action.ActionForward">
     <forward   name="welcome"                path="/welcome.do"/>
     <forward   name="searchEntry"            path="/searchEntry.do"/>
     <forward   name="searchSubmit"           path="/searchSubmit.do"/>
 </global-forwards>

 <action-mappings>
    <action    path="/welcome" forward="/WEB-INF/pages/welcome.htm"/>
    <action    path="/searchEntry" forward="/WEB-INF/pages/search.jsp"/>
    <action    path="/searchSubmit" 
               type="ca.nexcel.books.actions.SearchSubmit"
               input="/searchEntry.do"
               validate="true"
               name="searchForm">
              <forward name="success" path="/WEB-INF/pages/detail.jsp"/>
              <forward name="failure" path="/WEB-INF/pages/search.jsp"/>
    </action>  

 </action-mappings>

 <message-resources parameter="ApplicationResources"/>

 <controller processorClass="org.springframework.web.struts.
   DelegatingRequestProcessor"/> |(1)

 <plug-in className="org.apache.struts.validator.ValidatorPlugIn">
    <set-property property="pathnames" 
      value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"/>
 </plug-in>


 <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
    <set-property property="csntextConfigLocation" value="/WEB-INF/beans.xml"/>
 </plug-in>
 
</struts-config>

我利用了 <controller> 标记来用 DelegatingRequestProcessor 覆盖默认的 Struts RequestProcessor。下一步是在我的 Spring 配置文件中注册该动作，如清单 3 所示：

清单 3. 在 Spring 配置文件中注册一个动作

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" 
  "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
  <bean id="bookService" class="ca.nexcel.books.business.BookServiceImpl"/>

  <bean name="/searchSubmit" 
    class="ca.nexcel.books.actions.SearchSubmit"> |(1)
     <property name="bookService">
        <ref bean="bookService"/>
     </property>
  </bean>
</beans>

注意：在 (1) 处，我使用名称属性注册了一个 bean，以匹配 struts-config 动作映射名称。SearchSubmit 动作揭示了一个 JavaBean 属性，允许 Spring 在运行时填充属性，如清单 4 所示：

清单 4. 具有 JavaBean 属性的 Struts 动作

package ca.nexcel.books.actions;

import Java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionError;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.DynaActionForm;

import ca.nexcel.books.beans.Book;
import ca.nexcel.books.business.BookService;

public class SearchSubmit extends Action {
	
  private BookService bookService;
  public BookService getBookService() {
    return bookService;
  }

  public void setBookService(BookService bookService) { | (1)
    this.bookService = bookService; 
  } 

  public ActionForward execute(
    ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request,
    HttpServletResponse response)
    throws IOException, ServletException {

    DynaActionForm searchForm = (DynaActionForm) form;
    String isbn = (String) searchForm.get("isbn");
		
  Book book = getBookService().read(isbn.trim());  |(2)

    if (null == book) {
      ActionErrors errors = new ActionErrors();
      errors.add(ActionErrors.GLOBAL_ERROR,new ActionError("message.notfound"));
      saveErrors(request, errors);
      return mapping.findForward("failure") ;
  }

      request.setAttribute("book", book);
      return mapping.findForward("success");
  }

}

在清单 4 中，您可以了解到如何创建 Struts 动作。在 (1) 处，我创建了一个 JavaBean 属性。DelegatingRequestProcessor自动地配置这种属性。这种设计使 Struts 动作并不知道它正被 Spring 管理，并且使您能够利用 Sping 的动作管理框架的所有优点。由于您的 Struts 动作注意不到 Spring 的存在，所以您不需要重写您的 Struts 代码就可以使用其他控制反转容器来替换掉 Spring。

DelegatingRequestProcessor 方法的确比第一种方法好，但是仍然存在一些问题。如果您使用一个不同的 RequestProcessor，则需要手动整合 Spring 的 DelegatingRequestProcessor。添加的代码会造成维护的麻烦并且将来会降低您的应用程序的灵活性。此外，还有过一些使用一系列命令来代替 Struts RequestProcessor 的传闻。 这种改变将会对这种解决方法的使用寿命造成负面的影响。

窍门 3. 将动作管理委托给 Spring

一个更好的解决方法是将 Strut 动作管理委托给 Spring。您可以通过在 struts-config 动作映射中注册一个代理来实现。代理负责在 Spring 环境中查找 Struts 动作。由于动作在 Spring 的控制之下，所以它可以填充动作的 JavaBean 属性，并为应用诸如 Spring 的 AOP 拦截器之类的特性带来了可能。

清单 5 中的 Action 类与清单 4 中的相同。但是 struts-config 有一些不同：

清单 5. Spring 整合的委托方法

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE struts-config PUBLIC
          "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN"
          "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">

<struts-config>
 <form-beans>
    <form-bean name="searchForm" 
      type="org.apache.struts.validator.DynaValidatorForm">
               <form-property name="isbn"    type="Java.lang.String"/>
    </form-bean>
  
  </form-beans>

 <global-forwards type="org.apache.struts.action.ActionForward">
     <forward   name="welcome"                path="/welcome.do"/>
     <forward   name="searchEntry"            path="/searchEntry.do"/>
     <forward   name="searchSubmit"           path="/searchSubmit.do"/>
 </global-forwards>

 <action-mappings>
    <action    path="/welcome" forward="/WEB-INF/pages/welcome.htm"/>
    <action    path="/searchEntry" forward="/WEB-INF/pages/search.jsp"/>
    <action    path="/searchSubmit" 
             type="org.springframework.web.struts.DelegatingActionProxy" |(1)
             input="/searchEntry.do"
             validate="true"
             name="searchForm">
             <forward name="success" path="/WEB-INF/pages/detail.jsp"/>
             <forward name="failure" path="/WEB-INF/pages/search.jsp"/>
    </action>  

 </action-mappings>

 <message-resources parameter="ApplicationResources"/>


 <plug-in className="org.apache.struts.validator.ValidatorPlugIn">
    <set-property 
    property="pathnames" 
    value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"/>
 </plug-in>


 <plug-in 
    className="org.springframework.web.struts.ContextLoaderPlugIn">
    <set-property property="contextConfigLocation" value="/WEB-INF/beans.xml"/>
 </plug-in>

 
</struts-config>

清单 5 是一个典型的 struts-config.xml 文件，只有一个小小的差别。它注册 Spring 代理类的名称，而不是声明动作的类名，如（1）处所示。DelegatingActionProxy 类使用动作映射名称查找 Spring 环境中的动作。这就是我们使用 ContextLoaderPlugIn 声明的环境。

将一个 Struts 动作注册为一个 Spring bean 是非常直观的，如清单 6 所示。我利用动作映射使用 <bean> 标记的名称属性（在这个例子中是 "/searchSubmit"）简单地创建了一个 bean。这个动作的 JavaBean 属性像任何 Spring bean 一样被填充：

清单 6. 在 Spring 环境中注册一个 Struts 动作

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" 
 "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
  <bean id="bookService" class="ca.nexcel.books.business.BookServiceImpl"/>

  <bean name="/searchSubmit"   
        class="ca.nexcel.books.actions.SearchSubmit">
     <property name="bookService">
        <ref bean="bookService"/>
     </property>
  </bean>

</beans>

动作委托的优点

动作委托解决方法是这三种方法中最好的。Struts 动作不了解 Spring，不对代码作任何改变就可用于非 Spring 应用程序中。RequestProcessor 的改变不会影响它，并且它可以利用 Spring AOP 特性的优点。

动作委托的优点不止如此。一旦让 Spring 控制您的 Struts 动作，您就可以使用 Spring 给动作补充更强的活力。例如，没有 Spring 的话，所有的 Struts 动作都必须是线程安全的。如果您设置 <bean> 标记的 singleton 属性为“false”，那么不管用何种方法，您的应用程序都将在每一个请求上有一个新生成的动作对象。您可能不需要这种特性，但是把它放在您的工具箱中也很好。您也可以利用 Spring 的生命周期方法。例如，当实例化 Struts 动作时，<bean> 标记的 init-method 属性被用于运行一个方法。类似地，在从容器中删除 bean 之前，destroy-method 属性执行一个方法。这些方法是管理昂贵对象的好办法，它们以一种与 Servlet 生命周期相同的方式进行管理。

拦截 Struts

前面提到过，通过将 Struts 动作委托给 Spring 框架而整合 Struts 和 Spring 的一个主要的优点是：您可以将 Spring 的 AOP 拦截器应用于您的 Struts 动作。通过将 Spring 拦截器应用于 Struts 动作，您可以用最小的代价处理横切关注点。

虽然 Spring 提供很多内置拦截器，但是我将向您展示如何创建自己的拦截器并把它应用于一个 Struts 动作。为了使用拦截器，您需要做三件事：

1. 创建拦截器。
2. 注册拦截器。
3. 声明在何处拦截代码。

这看起来非常简单的几句话却非常强大。例如，在清单 7 中，我为 Struts 动作创建了一个日志记录拦截器。 这个拦截器在每个方法调用之前打印一句话：

清单 7. 一个简单的日志记录拦截器

package ca.nexcel.books.interceptors;

import org.springframework.aop.MethodBeforeAdvice;

import Java.lang.reflect.Method;

public class LoggingInterceptor implements MethodBeforeAdvice {

   public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("logging before!");
    }
}

这个拦截器非常简单。before() 方法在拦截点中每个方法之前运行。在本例中，它打印出一句话，其实它可以做您想做的任何事。下一步就是在 Spring 配置文件中注册这个拦截器，如清单 8 所示：

清单 8. 在 Spring 配置文件中注册拦截器

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" 
  "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
  <bean id="bookService" class="ca.nexcel.books.business.BookServiceImpl"/>

  <bean name="/searchSubmit" 
        class="ca.nexcel.books.actions.SearchSubmit">
     <property name="bookService">
        <ref bean="bookService"/>
     </property>
  </bean>

  <!--  Interceptors --> 
  <bean name="logger"    
    class="ca.nexcel.books.interceptors.LoggingInterceptor"/> |(1)

  <!-- AutoProxies -->
  <bean name="loggingAutoProxy" 
        class="org.springframework.aop.framework.autoproxy.
          BeanNameAutoProxyCreator"> |(2)
    <property name="beanNames">
          <value>/searchSubmit</valuesgt; |(3)
    </property>
    <property name="interceptorNames">
        <list>
          <value>logger</value> |(4)
        </list>
    </property>
   </bean>

</beans>

您可能已经注意到了，清单 8 扩展了 清单6 中所示的应用程序以包含一个拦截器。具体细节如下：

• 在 (1) 处，我注册了这个拦截器。
• 在 (2) 处，我创建了一个 bean 名称自动代理，它描述如何应用拦截器。还有其他的方法定义拦截点，但是这种方法常见而简便。
• 在 (3) 处，我将 Struts 动作注册为将被拦截的 bean。如果您想要拦截其他的 Struts 动作，则只需要在 "beanNames" 下面创建附加的 <value> 标记。
• 在 (4) 处，当拦截发生时，我执行了在 (1) 处创建的拦截器 bean 的名称。这里列出的所有拦截器都应用于“beanNames”。

就是这样。就像这个例子所展示的，将您的 Struts 动作置于 Spring 框架的控制之下，为处理您的 Struts 应用程序提供了一系列全新的选择。在本例中，使用动作委托可以轻松地利用 Spring 拦截器提高 Struts 应用程序中的日志记录能力。

结束语

在本文中，您已经学习了将 Struts 动作整合到 Spring 框架中的三种窍门。使用 Spring 的 ActionSupport 来整合 Struts（第一种窍门中就是这样做的）简单而快捷，但是会将 Struts 动作与 Spring 框架耦合在一起。如果您需要将应用程序移植到一个不同的框架，则需要重写代码。第二种解决方法通过委托 RequestProcessor 巧妙地解开代码的耦合，但是它的可扩展性不强，并且当 Struts 的 RequestProcessor 变成一系列命令时，这种方法就持续不了很长时间。第三种方法是这三种方法中最好的：将 Struts 动作委托给 Spring 框架可以使代码解耦，从而使您可以在您的 Struts 应用程序中利用 Spring 的特性（比如日志记录拦截器）。

三种 Struts-Spring 整合窍门中的每一种都被实现成一个完整可用的应用程序。

import Java.io.IOException;
import Java.io.PrintWriter;
import Java.util.Iterator;
import Java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DispatchAction;
import org.apache.struts.validator.DynaValidatorForm;

import com.rain.bean.KindDao;

/**
 * MyEclipse Struts
 * Creation date: 09-13-2006
 *
 * XDoclet definition:
 * @struts.action parameter="method"
 */
public class KindAction extends DispatchAction {
 /*
  * Generated Methods
  */

 /**
  * Method execute
  * @param mapping
  * @param form
  * @param request
  * @param response
  * @return ActionForward
  */
 public ActionForward search(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response) {
  DynaValidatorForm kindForm = (DynaValidatorForm)form;
  KindDao dao=new KindDao();
  int kindid=Integer.parseInt(kindForm.getString("kindid"));
  List list=dao.findAllKind(kindid);
  Iterator it=list.iterator();
  if(it.hasNext()){
   PrintWriter out;
   try {
    response.setContentType("text/xml;charset=UTF-8");
    response.setHeader("Cache-Control", "no-cache");
    out = response.getWriter();

    out.println("<response>");
    while(it.hasNext()){
     String name=it.next().toString();
     out.println("<kind>"+name+"</kind>");
    }
    out.println("</response>");
    it=null;
    out.close();
   } catch (IOException e) {
    // TODO 自动生成 catch 块
    e.printStackTrace();
   }
   
  }else{
   response.setStatus(HttpServletResponse.SC_NO_CONTENT);
  }
  // TODO Auto-generated method stub
  return null;
 }
}

</head>
<body>
 <form name="RegistForm">
 <table height="328" align="center" cellpadding="0" cellspacing="0" style="border:2px #666666 solid; ">
 
 <tr>
  <td colspan="2" height="30" bgcolor="#666666" align="center" style="border-bottom:1px #666666 solid;"><font color="#FFFFFF"><b>用&nbsp;户&nbsp;注&nbsp;册</b></font></td>
 </tr>
 <tr>
  <td width="147" height="35" align="right">用&nbsp;户&nbsp;名：</td>
  <td width="368"><input type="text" name="UserName" id="username" maxlength="15" size="13" onblur="checkUsername(this.value);">&nbsp;&nbsp;<font color="#ff0000">*</font>&nbsp;&nbsp;<span id="usernameview"></span></td>
 </tr>
 <tr>
  <td height="35" align="right">密&nbsp;&nbsp;&nbsp;&nbsp;码：</td>
  <td><input type="password" name="Password" id="password1" maxlength="15" size="15" onblur="checkPassword(this.value);">&nbsp;&nbsp;<font color="#ff0000">*</font><span id="pwdview"></span></td>
 </tr>
 <tr>
  <td height="35" align="right">密码校验：</td>
  <td><input type="password" name="Password2" id="password2" maxlength="15" size="15" onblur="checkPassword2(this.value);">&nbsp;&nbsp;<font color="#ff0000">*</font>&nbsp;&nbsp;<span id="pwd2view"></span></td>
 </tr>
 <tr>
  <td height="35" align="right">真实姓名：</td>
  <td><input type="text" name="realname" id="realname" size="10" maxlength="10" onblur="checkRealName(this.value);">&nbsp;&nbsp;<font color="#ff0000">*</font><span id="realnameview"></span></td>
 </tr>
 <tr>
  <td height="35" align="right">性&nbsp;&nbsp;&nbsp;&nbsp;别：</td>
  <td><select name="sex" id="sex">
  <option value="m">男</option>
  <option value="w">女</option></select>&nbsp;&nbsp;<font color="#ff0000">*</font></td>
 </tr>
 <tr>
  <td height="35" align="right">联系电话：</td>
  <td><input type="text" name="tel" id="tel" maxlength="12" size="13" >&nbsp;&nbsp;<font color="#ff0000">*</font></td>
 </tr>
 <tr>
  <td height="35" align="right">手&nbsp;&nbsp;&nbsp;&nbsp;机：</td>
  <td><input type="text" name="mobile" id="mobile" maxlength="12" size="13">&nbsp;&nbsp;<font color="#ff0000">*</font></td>
 </tr>
 <tr>
  <td height="35" align="right">E - mail：</td>
  <td><input type="text" name="email" id="email" size="25" onChange="checkEmail();">&nbsp;&nbsp;<font color="#ff0000">*</font></td>
 </tr>
 <tr>
  <td height="86" align="right">个人简介：</td>
  <td><textarea cols="30" rows="4" class="text" name="memo" style="overflow:auto; border:1px #666666 solid; color:#3399FF;"></textarea>&nbsp;&nbsp;<font color="#ff0000">*</font></td>
 </tr>
 <tr>
  <td height="10" colspan="2"></td>
 </tr>
 <tr>
  <td height="30" colspan="2" align="center" style="border-top:1px #666666 solid; "><input onClick="javascript:addUser();" style="background-color:#666666; color:#FFFFFF; border:0; text-align:center; width:60px;" type="button" name="add" value="A D D">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<input style="background-color:#666666; color:#FFFFFF; border:0; width:60px;" type="reset" name="reset" value="R E T"></td>
 </tr>
 
 </table>
 </form>
</body>
</html>

/*
 * Generated by MyEclipse Struts
 * Template path: templates/java/JavaClass.vtl
 */
package com.rain.struts.action;

import Java.io.IOException;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DispatchAction;
import org.apache.struts.validator.DynaValidatorForm;

import com.rain.bean.Regist;

/**
 * MyEclipse Struts
 * Creation date: 09-12-2006
 *
 * XDoclet definition:
 * @struts.action parameter="method" validate="true"
 */
public class LoginAction extends DispatchAction {
 

 /**
  * Method execute
  * @param mapping
  * @param form
  * @param request
  * @param response
  * @return ActionForward
  */
 public ActionForward checkUserName(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response) {
  Regist regist=new Regist();
  DynaValidatorForm loginForm = (DynaValidatorForm)form;
  String username=loginForm.getString("UserName");
  System.out.println(username);
  boolean flag=regist.findByName(username);
  System.out.println("test");
  if(flag)
  {
   try {
    response.getWriter().write("sorry!");
   } catch (IOException e) {
    // TODO 自动生成 catch 块
    e.printStackTrace();
   }
  }else
  {
   try {
    response.getWriter().write("luck!");
   } catch (IOException e) {
    // TODO 自动生成 catch 块
    e.printStackTrace();
   }
  }
    
  return null;
 }
}

            var row, cell, txtNode;
            for (var i = 0; i < size; i++) {
                var nextNode = the_names[i].firstChild.data;
                row = document.createElement("tr");
                cell = document.createElement("td");
               
                cell.onmouseout = function() {this.className='mouseOver';};
                cell.onmouseover = function() {this.className='mouseOut';};
                cell.setAttribute("bgcolor", "#FFFAFA");
                cell.setAttribute("border", "0");
                cell.onclick = function() { populateName(this); } ;                            

                txtNode = document.createTextNode(nextNode);
                cell.appendChild(txtNode);
                row.appendChild(cell);
                nameTableBody.appendChild(row);
               
            }
        }

        function setOffsets() {
            var end = inputField.offsetWidth;
            var left = calculateOffsetLeft(inputField);
            var top = calculateOffsetTop(inputField) + inputField.offsetHeight;

            completeDiv.style.border = "black 1px solid";
            completeDiv.style.left = left + "px";
            completeDiv.style.top = top + "px";
            nameTable.style.width = end + "px";
        }
       
        function calculateOffsetLeft(field) {
          return calculateOffset(field, "offsetLeft");
        }

        function calculateOffsetTop(field) {
          return calculateOffset(field, "offsetTop");
        }

        function calculateOffset(field, attr) {
          var offset = 0;
          while(field) {
            offset += field[attr];
            field = field.offsetParent;
          }
          return offset;
        }

        function populateName(cell) {
            inputField.value = cell.firstChild.nodeValue;
            clearNames();
        }
  function clearNames() {
     var ind = nameTableBody.childNodes.length;
     for (var i = ind - 1; i >= 0 ; i--) {
       nameTableBody.removeChild(nameTableBody.childNodes[i]);
     }
    completeDiv.style.border = "none";
  }
  </script>
  </head>
 
  <body>
    <h3>Ajax Auto Complete Example</h3>
    请输入名称：<input type="text" name="title" id="title" size="30" width="100" height="20" onkeyup="findNames();">
    <div style="position:absolute;" id="popup">
        <table id="name_table" bgcolor="#FFFAFA" border="0" cellspacing="0" cellpadding="0"/>           
            <tbody id="name_table_body"></tbody>
        </table>
    </div>
  </body>
</html>

Action源代码
/*
 * Generated by MyEclipse Struts
 * Template path: templates/java/JavaClass.vtl
 */
package com.rain.struts.action;

import Java.io.IOException;
import Java.io.PrintWriter;
import Java.io.UnsupportedEncodingException;
import Java.util.Iterator;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DispatchAction;
import org.apache.struts.validator.DynaValidatorForm;

import com.rain.bean.ArticleDao;

/**
 * MyEclipse Struts
 * Creation date: 09-12-2006
 *
 * XDoclet definition:
 * @struts.action parameter="method"
 */
public class ArticleAction extends DispatchAction {
 /*
  * Generated Methods
  */

 /**
  * Method execute
  * @param mapping
  * @param form
  * @param request
  * @param response
  * @return ActionForward
  */
 public ActionForward search(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response) {
  DynaValidatorForm articleForm = (DynaValidatorForm)form;
  String title;
  try {
   title = new String(request.getParameter("title").getBytes("ISO8859_1"),"UTF-8");
   System.out.println(title);
   ArticleDao dao=new ArticleDao();
   
   Iterator it=dao.findAllName(title).iterator();
   
   if(it.hasNext()){
    PrintWriter out;
    try {
     
     response.setContentType("text/xml;charset=UTF-8");
     response.setHeader("Cache-Control", "no-cache");
     out = response.getWriter();
     out.println("<response>");
     while(it.hasNext()){
      String name=it.next().toString();
      out.println("<title>"+name+"</title>");
     }
     out.println("</response>");
     it=null;
     out.close();
    } catch (IOException e) {
     // TODO 自动生成 catch 块
     e.printStackTrace();
    }
    
   }else{
    response.setStatus(HttpServletResponse.SC_NO_CONTENT);
   }
  } catch (UnsupportedEncodingException e1) {
   // TODO 自动生成 catch 块
   e1.printStackTrace();
  }
  
  
  return null;
 }
}

import Java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.rain.HibernateSessionFactory;

/**
 *
 */
public class ArticleDao {

 public List findAllName(String title){
  System.out.println("11");
  String hql="select art.title from Article art where art.title like '"+title+"%'";
     List list=null;
     try{
     
      Session session=HibernateSessionFactory.getCurrentSession();

         Transaction tx=session.beginTransaction();
          Query query=session.createQuery(hql);
           
            list=query.list();
            tx.commit();
            session.close();
     }catch(Exception e){
      System.out.println(e.getMessage());
      e.printStackTrace();
     }
       
        return list;
 }
}