使用 Easy Struts for Eclipse开发 Struts

本文向您介绍了如何在 Eclipse IDE 中使用 Easy Struts 插件开发 Struts 应用程序。本文首先对 Easy Struts 及其安装配置步骤进行了简介，并通过一个循序渐进的例子介绍了如何构建一个基本的 Struts 应用程序。本文还介绍了增强 Struts 应用程序的各种方法，例如连接数据库，对应用程序进行模块化，内容的国际化和本地化，异常处理和创建自定义插件等等。最后，您将学习如何将自己的 Struts 应用程序部署到 Tomcat Web 服务器上。

　　由于 Easy Struts 插件可以管理所有的复杂配置文件，因此您可以将精力集中在程序逻辑的开发上。现在让我们先来看一下 Easy Struts 中可以帮助您构建一个完整的应用程序的 10 个功能：

　　1．Add Easy Struts support。向项目的 classpath 中添加所有必需的 Struts 库，并创建配置文件和默认的资源属性文件。
　　2．Easy Form。创建一个具有表单属性的 JSP 文件，以及一个具有表单属性的 getter 方法和 setter 方法的 Form bean，并向配置文件中添加一个 Form bean 的定义。
　　3．Easy Action。创建一个 Action 类，并向配置文件中添加一个操作映射的定义。
　　4．Easy Action associated with a form。创建一个具有表单属性的 JSP 文件，一个具有 getter 方法和 setter 方法的 Form bean 类，以及一个 Action 类；并向配置文件中添加一个 Form bean 的定义和一个操作映射的定义。
　　5．Easy Forward。创建局部转发和全局转发，它们定义了控制应该转向何处。
　　6．Easy Exception。处理异常。
　　7．Easy Message resources。创建资源属性文件，这对于内容的国际化和本地化特别重要。
　　8．Easy Plug-in。创建插件。
　　9．Easy Datasource。将应用程序连接到一个数据源上。
　　10．Easy Module。模块化应用程序。
 
　　在本文中，我们将介绍这 10 个功能中的 8 个（我们将不会介绍功能 2 和 3）。在开始开发 Struts 应用程序之前，您应该首先安装好所有必需的程序和插件，并要了解有关 Java 编程、HTML、JSP 脚本以及 XML 和 XSLT 的基本知识。

　　安装和配置准备

　　您需要安装 Eclipse 2.1、Struts 1.1、Tomcat Web 服务器和 Easy Struts，同时还要安装 Sysdeo Tomcat plug-ins for Eclipse、MySQL 数据库服务器以及 JDBC driver for MySQL。Eclipse 是一个 IDE 开发环境。Struts 1.1 提供了运行 Struts 应用程序所需要的库。Tomcat 是宿主应用程序的 Web 容器。Sysdeo Tomcat 插件可以让开发人员在 Eclipse 环境中启动或停止 Tomcat Web 服务器。JDBC driver for MySQL 可以将 JDBC 调用转换成 MySQL 所使用的网络协议。安装好这些软件之后，还需要为 Eclipse 配置两个插件。

　　安装

　　1. 从 Eclipse 的 Web 站点上下载 Eclipse v2.1。您可以通过将其解压到任何一个选定的目录（这个目录在本文中称为 eclipse_home）中来安装它。
　　2. 从 Apache 的 Web 站点上下载 Struts 1.1。您可以通过将其解压到任何一个选定的目录（这个目录在本文中称为 struts_home）来安装它。
　　3. 从 Apache 的 Web 站点上下载 Tomcat Web 服务器。您可以通过将其解压到任何一个选定的目录（这个目录在本文中称为 tomcat_home）中来安装它。本文假设 Tomcat 的版本是 v4.1.18。
　　4. 从 Sysdeo 的 Web 站点上下载最新的 Tomcat for Eclipse 插件。您可以通过将其解压到 eclipse_home/eclipse/plugins 目录中来安装它。本文假设 Tomcat for Eclipse 插件的版本是 v2.2。
　　5. 从 SourceForge 上下载 Easy Struts for Eclipse 插件 v0.6.4。您可以通过将其解压到 eclipse_home/eclipse/plugins 目录中来安装它。
　　6. 从 Sun 的 Web 站点上下载 J2SE SDK。您可以将其安装到任何一个选定的目录（这个目录在本文中称为 java_home）中。本文假设 J2SE SDK 的版本是 v1.4.2。
　　7. 从 MySQL 的 Web 站点上下载 MySQL 数据库。您可以将其安装到任何一个选定的目录中。
　　8. 从 MySQL 的 Web 站点上下载 JDBC driver for MySQL。您应该先解压下载的文件包，并将 mysql-connector-java-x.x.xx-stable/mysql-connector-java-x.x.xx-stable-bin.jar 拷贝到您的项目工作空间中。后面还需要回到这个步骤。本文假设 JDBC driver for MySQL 的版本是 v3.0。

　　配置

　　配置 Sysdeo Tomcat 插件

　　要配置 Sysdeo Tomcat 插件，执行以下步骤：

　　启动 Eclipse。

　　1. 配置 Tomcat 插件。要实现这个功能，请单击“Window”菜单，然后选择“Preferences”菜单项，然后在弹出的菜单中选择“Tomcat”。然后执行以下步骤：
　　　□ 将“Tomcat version”设置成 Tomcat 的版本号。
　　　□ 将“Tomcat home”设置成 tomcat_home/jakarta-tomcat-4.1.18。
　　　□ 将“Perspective to switch when Tomcat is started”设置成 Java。
　　　□ 在“Tomcat”选项的子选项“JVM Settings” -> “Classpath”中，添加 Jar/Zip for tools.jar，该值应该是 java_home/lib/。这用于编译 JSP 文件。
　　2. 为项目的 classpath 引用设置 classpath 变量 TOMCAT_HOME。要完成这一任务，请在与步骤 2 相同的弹出菜单中选择“Java”选项，然后选择“Classpath Variables”子选项，并添加一个新的变量“TOMCAT_HOME”，其路径是 tomcat_home/jakarta-tomcat-4.1.18。
　　3. 确保“Tomcat”菜单和 3 个工具栏按钮可用。到现在为止，我们应该在 Java 视图中可以看到一个“Tomcat”菜单和 3 个 Tomcat 工具栏按钮（如图 1 所示）。如果您没有看到这些内容，回到“Window”菜单中，选择“Customize Perspective...”项，打开选项树，选中“Other”项并选中“Tomcat”子选项。
　　4. 确保 Sysdeo Tomcat 插件可以正常工作。要验证这一点，请使用菜单或工具条来启动/停止 Tomcat。

图 1. Tomcat 工具栏按钮

　　配置 Easy Struts 插件

　　要配置 Easy Struts 插件，请参考 图 2 的内容，并执行以下步骤：

　　1. 选择一个 Struts 版本。要完成这步操作，请单击“Window”菜单，选择“Preference”项，选择“Easy Struts”选项，并选择“Struts 1.1”选项卡。
　　2. 添加 JARs。应该为 struts_home/jakarta-struts-1.1/lib 目录中的所有的 .jar 文件都添加“Add JARs”。
　　3. 添加 TLDs。接下来，为 struts_home/ jakarta-struts-1.1/lib 目录中的所有 .tld 文件添加“Add TLDs”。

图 2. 配置 Easy Struts 插件

　　开发 Struts 应用程序

　　在本节中，我们将介绍使用 Easy Struts 插件构建 Struts 应用程序的基本步骤。首先，您将创建一个 Tomcat 项目。然后，您将添加 Easy Struts 对 Tomcat 项目的支持。接下来，您可以体验一下“Easy Action associated with a form”的功能。之后，您将对前一个步骤中自动生成的源代码进行必要的修改。再之后，您可以测试一下应用程序在 Tomcat Web 服务器上的运行情况。最后，您可以体验一下“Easy Forward”功能。

　　创建 Tomcat 项目

　　要创建一个 Tomcat 项目，回到“File”菜单，选择“New”项，并在子菜单中选择“Project”。然后执行以下步骤：

　　1. 进入“Java”选项，选择“Tomcat Project”并单击“Next”（参见图 3）。
　　2. 填上项目名，并单击“Next”（参见图 4）。
　　3. 选中“Can update server.xml file”。系统会自动更新 Tomcat Web 服务器的 server.xml 文件。现在单击“Finish”就可以完成任务了（参见图 5）。

　　创建 Tomcat 项目的结果如 图 6 所示。

图 3. 创建 Tomcat 项目 - 步骤 1

图 4. 创建 Tomcat 项目 - 步骤 2

图 5. 创建 Tomcat 项目 - 步骤 3

图 6. 创建 Tomcat 项目 - 最终结果

　　添加 Easy Struts 支持

　　要添加 Easy Struts 对 Tomcat 项目的支持，执行以下两个步骤：

　　1. 单击“New”工具栏按钮，在“Java”选项下面选择“Easy Struts”自选项，选择“Add Easy Struts support”并单击“Next”，转入下一个步骤（请参看 图 7 -- 在本文的后文中我们将这个视图称为 Easy Struts 功能视图）。
　　2. 设置如 图 8 所示的配置。确保选中“Copy Struts binary”和“Copy Struts TLD”。

　　添加 Easy Struts 支持的结果如 图 9 所示。

图 7. Easy Struts 功能视图

图 8. 添加 Easy Struts 支持

图 9. 添加 Easy Struts 支持 - 最终结果

　　图 7 显示了 Easy Struts 所提供的 10 个功能。我们已经看过了“Add Easy Struts Support”的功能。在本文的其余部分中，我们将介绍一下剩下的 7 个功能（“Easy Action” 和 “Easy Form”功能不介绍)。在本节的后续部分中，我们将使用“Easy Action associated with a form”功能和“Easy Forward”功能来构建一个简单却又完整的 Struts 应用程序。下一节将介绍“Easy Message resources”、“Easy Plug In”、“Easy Datasource”、“Easy Exception”和“Easy Module”功能。

　　使用 Easy Action Associated with a Form 功能

　　回到 Easy Struts 功能视图，选择“Easy Action associated with a form”，并执行以下步骤来配置表单：

　　1. 在 Use case 中输入内容；Form 名和 Form 类型都会根据系统的 Use case 自动生成。您可以手工修改 Form 名和 Form 类型（参见 图 10）。
　　2. 在 Form 属性部分中单击“Add”；使用如 图 11 所示的视图添加表单属性。例如，我们按照图中所示的一样视图添加一个文本输入域：该域名为“tel”，值为“tel”，类型为 int。我们将“tel”的初值设置为 0。在设置“Type”时，我们可以直接输入，也可以使用“Browse”功能来选择。对于“JSP input type”的设置，我们也是既可以直接输入，也可以从下拉列表中选择。Struts 系统会在 Form bean 类中为每个表单属性生成一对getter 方法和setter 方法。因此，对于一个选择列表来说，您应该只创建一个 <html:select> 即可，而不用创建所有的 <html:option>。
　　3. 由于您正在开发一个 Web 应用程序，因此请选中前两个检查框。
　　4. 单击“Next”继续。

图 10. 配置表单

图 11. 关系的图形化表示

　　到现在为止，您应该会看到一些非常类似于 图 12 的内容。默认情况下，输入的值是“/form/owner.jsp”，这意味着 JSP 文件被放在“easyStruts/form”文件夹中。您可以手工修改 JSP 文件的位置，或者 preference 的设置。要修改 preference 的设置，进入“Window”菜单，选择“Preferences”，单击“Easy Struts”选项，选择“Style”选项卡，并将“JSP form location”设置为空。例如，在本文中，我们倾向于将这些 JSP 文件直接保存在 easyStruts （项目名）文件夹中。因此，请将其修改为“/owner.jsp”，如 图 12 所示。

　　图 12 中所显示的操作映射的属性如下：

　　□ Path。所提交请求的相对路径。路径名必须以“/”开头而且唯一。
　　□ Type。这个 ActionMapping 正在描述的 Action 类的名字。
　　□ Attribute。可以访问这个 Form bean 的请求范围或会话范围的属性名，条件是名字与这个 bean 指定的名字不同。
　　□ Scope。规定与这个映射相关的 Form bean 的值应该可以保存多少位。
　　□ input。规定如果碰到验证错误时控制流程应该返回到输入表单的相对路径。
　　□ Validate。如果这个属性被设置为 true，就会对与这个映射关联的表单调用 ActionForm.validate() 方法。
　　□ Parameter。可用于向由这个映射选择的 Action 传递其他信息。

图 12. 配置操作

　　单击“Next”，您应该可以看到类似于如 图 13 所示的内容。图 13 中所显示的是操作映射属性，如下：

　　□ Forward。指定要处理这个请求的 servlet 或 JSP 资源的相对路径。ActionMapping 可以使用 findForward() 将控制流程转换到这个 servlet 或 JSP 资源上。
　　□ Exception。与这个映射相关的 ExceptionHandlers。

　　此处的转发和异常都是本地的，稍后我们会讨论全局转发和全局异常。

图 13. 配置转发

　　在单击“Finish”之后（参见图 14），系统会在 easyStruts/WEB-INF/src/ 目录中生成 com.asprise.struts.form.OwnerForm.java 和 com.asprise.struts.action.OwnerAction.java。同时还会生成另外一个文件：easyStruts/owner.jsp。在接下来的几节中，您将对这三个文件进行一些修改，从而完成整个表单，添加用户输入的验证方法并处理验证错误。

图 14. 添加转发

　　修改 ActionForm 类

　　将 ActionForm.java 中的所有“Integer”修改为“int”，这是因为您刚才创建的表单属性“tel”的类型是 java.lang.Integer。然后编写 validate() 方法的代码，对用户输入的表单属性进行验证。validate() 方法的完整代码如 清单 1 所示。

　　ActionError（“error.noEmail”）中的“error.noEmail”是资源属性文件中定义的一个关键字，它等价于“<li><font color=red>Enter your email</font> ”。在资源属性文件中，可以使用 <html> 代码。ActionErrors 中 add(java.lang.String property, ActionError error) 方法的参数 property 是一个表单属性名。这个 ActionError 只能与一个指定的表单属性相关。例如，如果 email 地址为空，或者只包含空格字符，那么在对表单进行验证时就会显示“Enter your email”消息。如果在 email 地址中没有“@”字符，那么就会显示“Correct your email”消息，这是在资源属性文件中使用“error.wrongEmail”关键字定义的。这两个错误都只与表单属性“email”有关（参见清单 1）。我们稍后再回来介绍。

清单 1. OwnerForm.java

package com.asprise.struts.form;

import javax.servlet.http.HttpServletRequest;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionError;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;

public class OwnerForm extends ActionForm {

   private String email;
   private String greet = "Mr.";
   private String address;
   private int tel = 0;
   private String name;

   public ActionErrors validate(
      ActionMapping mapping,
      HttpServletRequest request) {

      ActionErrors errors = new ActionErrors();
      if (greet == null || greet.trim().equals("")) {
         errors.add("greet", new ActionError("error.greet"));
      }
      if (name == null || name.trim().equals("")) {
         errors.add("name", new ActionError("error.name"));
      }
      if (address == null || address.trim().equals("")) {
         errors.add("address", new ActionError("error.address"));
      }
      if (email == null || email.trim().equals("")) {
         errors.add("email", new ActionError("error.noEmail"));
      }
      else if (email.indexOf("@")==-1) {
         errors.add("email", new ActionError("error.wrongEmail"));
      }
      if (tel==0) {
         errors.add("tel", new ActionError("error.tel"));
      }
      return errors;
      }
      ...

   public String getEmail() {
      return email;
   }

   public void setEmail(String email) {
      this.email = email;
   }
   ...
}

　　在资源属性文件中可以使用 <html> 代码。资源属性文件的内容是一些键-值对（参见清单 2）。在源代码文件中可以调用这些关键字。在每个资源属性文件中系统都需要 errors.header 和 errors.footer 这两个关键字。

清单 2. ApplicationResources.properties

errors.header=<h4>Validation Error(s)</h4><ul>
errors.footer=</ul><hr>

error.greet=<li>Choose your greet
error.name=<li>Enter your name
error.address=<li>Enter your address
error.tel=<li>Enter your contact number
error.wrongEmail=<li>Correct your email
error.noEmail=<li>Enter your email

　　修改 Action 类

　　OwnerAction 类会在局部转发路径“success”中简单地显示一条诸如“Thank you, Miss Nancy Chen”之类的消息。请修改 OwenerAction 类的 execute() 方法来实现您的逻辑，（每个 action 类都必须实现 execute() 方法）。参见清单 3，它会将控制流程转向 success.jsp。

清单 3. OwnerAction.java

public class OwnerAction extends Action {

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

      OwnerForm ownerForm = (OwnerForm) form;
     
      String greet = ownerForm.getGreet();
      String name = ownerForm.getName();
      request.setAttribute("name", name);
      request.setAttribute("greet", greet);

      // Forward control to the specified success target

      return (mapping.findForward("success"));
      }
}

　　修改 JSP 文件

　　首先，为 <html:select> 添加 <html:option>，完成表单（参见清单 4）。然后在表单后面添加一个 <html:errors />，这用来演示一个与属性为“proerty”的 <html:error> 不同的行为。例如，<html:errors property="name"> 只会反映与表单属性“name”相关的用户输入的验证。可以使用 ActionErrors 类的 add(String property, ActionError error) 方法为一个表单属性关联一些错误。<html:errors /> 则会反映这个表单中所有的验证错误。这些错误会在调用 <html:error> 的地方显示。

清单 4. owner.jsp

<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean"%>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html"%>
<html>
   <head>
      <meta
         name = "Generator"
         content = "Easy Struts Xslt generator for Eclipse (http://easystruts.sf.net).">
      <title>Struts Form for ownerForm</title>
   </head>
   <body>
      <html:form action="/owner">
         greet : <html:select property="greet">
                    <html:option value=""></html:option>
                    <html:option value="Mr.">Mr.</html:option>
                    <html:option value="Miss">Miss</html:option>
                    <html:option value="Mrs.">Mrs.</html:option>
                 </html:select><html:errors property="greet"/>
          name : <html:text property="name"/><html:errors property="name"/></br>
          address : <html:text property="address"/><html:errors property="address"/></br>
          email : <html:text property="email"/><html:errors property="email"/></br>
          tel : <html:text property="tel"/><html:errors property="tel"/></br>
         <html:submit/><html:cancel/>
      </html:form>
     <html:errors />
   <body>
</html>

　　现在，代码 success.jsp 会显示一条诸如“Thank you, Miss Nancy Chen”之类的消息。其中“Miss”是所有者的问候，而“Nancy Chen”是所有者的名字。最终的文件如 清单 5 所示。

清单 5. success.jsp

<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean"%>
<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>

<logic:present name="name" scope="request">
Thank you,
   <logic:present name="greet" scope="request">
      <bean:write name="greet" scope="request"/>
   </logic:present>
   <bean:write name="name" scope="request"/>
</logic:present>

　　<logic:present> 是一个 Struts logic 标签。当逻辑标签具有属性“name”时，就应该检查是否存在这个指定名的 JSP bean。关于 <logic:present> 的属性完整列表和 Struts logic 标签的完整列表，请参阅 Struts 用户指南。

　　<bean:write> 是一个 Struts bean 标签。它被用来将指定的 bean 属性的值传递给当前的 JspWriter。当 bean 标签具有属性“name”和属性“property”时，就是指其属性被访问以获取由“property”所指定的值的 bean 的属性名。 如果没有指定“property”属性，那么就会传递这个 bean 本身的值。关于 <logic:present> 属性以及 Struts logic 标签的完整列表，请参阅 Struts 用户指南。

　　检查 struts-config.xml

　　当您在 Eclipse 环境中单击“struts-config.xml”时，就会在一个图形用户界面中显示 struts-config.xml，如 图 15 所示。这样可以允许开发人员方便地编辑大部分 Easy Struts 功能。也可以通过单击“source”选项卡来查看 struts-config.xml 的源代码。

图 15. struts-config.xml

　　测试应用程序

　　单击 Tomcat 工具栏按钮，重新启动 Tomcat 服务器。然后在 URL 地址栏中输入“http://127.0.0.1:8080/easyStruts/owner.jsp”。现在屏幕上就会显示 图 16 。验证结果如 图 17 所示。注意有无属性“property”时 <html:errors> 的不同行为。如果有“property”属性，系统只会返回与该属性有关的错误。如果没有属性 “property”，那么系统就会返回该表单中的所有错误。当所有的输入都正确无误时，系统会将控制流程转到 success.jsp 上，这样会显示一条消息：“Thank you, Miss Nancy Chen”（参见图 18）。

图 16. owner.jsp

图 17. Form 验证错误

图 18. 成功

　　使用 Easy Forward

　　Struts 的配置提供了两种 ActionForwards，分别是全局转发和局部转发。全局的 ActionForwards 对于整个应用程序中的任何 Action 对象都是可见的。局部 ActionForwards 只对哪些在从 ActionMapping 中调用的 Action 对象可用，这些对象就是局部 ActionForwards 所关联的对象。从上一节中，您已经看到了如何在“Easy Action associated with a form”的过程中创建一个局部转发。在本节中，您将学习如何使用“Easy Forward”创建局部转发或全局转发。

　　进入 Easy Struts 功能视图，并单击“Easy Forward”。这样做的结果是应该可以看到类似于如 图 19 所示的内容。如果您保留“Visibility”为空不变，那么最终的转发就是全局的。如果单击“Browse”按钮并选择“/owner”，如 图 20 所示，那么最终的转发就是局部转发。不管转发是全局的还是局部的，在 Action 类中都以 mapping.findForward("failure") 的形式引用。

　　在“Easy Action associated with a form”一节中，我们已经讨论了“name”、“Redirect”和“Context relative”属性，如 图 19 所示。

图 19. Easy Forward - 全局

图 20. Easy Forward - 局部

　　增强应用程序功能

　　在上一节中，我们体验了 Easy Struts 的 3 个功能。在本节，您将编写自己的 XSLT 文件代码，以统一定制 JSP 文件的风格，并使用其他功能对内容进行国际化/本地化、连接到数据源、处理自定义异常、对应用程序进行模块化和创建自定义插件。

　　使用 XSLT 文件定制 JSP 文件的风格

　　可以通过编写 .xsl 文件并配置 Easy Struts 的参数来按照需要的格式生成 JSP 文件。要进行参数配置，进入“Window”菜单中，选择“Preferences”项，选择“Easy Struts”选项，并单击“XSLT stylesheet”选项卡，为“Jsp file stylesheet”单击“Browse”，添加自己的 .xsl 文件。

　　例如，如 清单 6 所示的代码是我们的 .xsl 文件。对于每个表单属性来说，它都生成“property”和“value”属性。例如，如果将一个名为“name”的文本输入区初值设置为“nancy”，那么在 JSP 文件中生成的代码行就是 name: <html:text property="name" value="nancy"></html:text>。

清单 6. myJsp.xsl

<?xml version="1.0" encoding="ISO-8859-1" ?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output method="text" />
<!-- jsp element -->
<xsl:template match="bean">
<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean"%>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html"%>
<html>
  <head>
    <xsl:value-of select="meta"/>
    <title>Struts Form for <xsl:value-of select="form-name"/></title>
  </head>
  <body>
    <html:form action="<xsl:value-of select="path"/>>
      <xsl:apply-templates select="attribute"></xsl:apply-templates>
      <html:submit/><html:cancel/>
    <html:form>
  </body>
</html>
</xsl:template>

<!-- attribute element -->
<xsl:template match="attribute">
  <xsl:text></xsl:text>
  <xsl:value-of select="label"/>
  <html:<xsl:value-of select="tag"/>
  <xsl:if test="tag!='option'"> property="<xsl:value-of select="name"/></xsl:if> value=<xsl:value-of select="initializer"/>
  </html:<xsl:value-of select="tag"/>
</xsl:template>

</xsl:stylesheet>

　　使用 Easy Message Resource 对内容进行本地化

　　可以通过创建本地化的资源属性文件对应用程序进行本地化。要创建一个新的资源属性文件，进入 Easy Struts 功能视图，选择“Easy Message Resource”。按照如 图 21 所示进行配置，这样将创建一个中文消息资源。注意资源属性文件名必须是 ApplicationResources_xx_XX.properties。小写的 xx 表示本地语言，它是一个 ISO-639 语言编代码，为两个字母；大写的 XX 表示本地国家，它是一个 ISO-3166 国家代码，为两个字母。

　　注意： 关于 ISO-639 语言代码的完整列表，请访问 Unicode.org 上的 languages page。关于 ISO-3166 国家代码的完整列表，请访问 Unicode.org 上的 countries page 。

图 21. 创建中文消息资源

　　资源属性文件很容易编辑。您可以使用记事本来编辑中文资源属性文件。ApplicationResources_zh_CN.properties 应该被保存为 Unicode (UTF-8) 编码。然后，将本地语言设置为 Chinese，将位置设置为 China （在 Windows 上，可以使用控制面板中的区域和语言选项进行设置）。重新启动 Tomcat 以启用修改过的设置，并转到 http://127.0.0.1:8080/easyStruts/owner.jsp 上。现在验证错误就是用中文显示的了，如 图 22 所示。

图 22. 中文的验证错误

　　使用 Easy Datasource 连接到数据库

　　在本节中，您将把 Web 应用程序连接到一个 MySQL 数据库上。要实现这种功能，进入 Easy Struts 功能视图，选择“Easy Datasource”，并按照 图 23 所示的一样进行配置。注意应该将 JDBC driver 放到 eclipse_home/eclipse/workspace/easyStruts/WEB-INF/lib 目录中。

图 23. 配置 MySQL 数据库

　　接下来，启动 MySQL 服务器，并按照如 清单 7 所示的方式创建数据库“crm”和表“owner”。

清单 7. owner 表

# Database : 'crm'
# Table structure for table 'owner'
#

CREATE TABLE 'owner' (
  'id' int(6) NOT NULL default '0',
  'greet' varchar(5) NOT NULL default '',
  'name' varchar(50) NOT NULL default '',
  'email' varchar(50) NOT NULL default '',
  'address' varchar(100) NOT NULL default '',
  'tel' int(10) NOT NULL default '0',
  PRIMARY KEY  ('id')
) TYPE=MyISAM;

　　接下来，修改 OwnerAction 类中的 execute() 方法，使其连接到数据库上（参见清单 8）。如您所见，Easy Datasource 就是在这里使用这些 key 属性。“org.apache.struts.action.DATA_SOURCE”是数据源使用的关键字。注意我们捕获了 SQLException 异常并将其重新抛出。在下一节中，您将对异常处理程序进行编码，以便处理 SQLException 异常。

清单 8. OwnerAction.java - 数据库连接

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

   OwnerForm ownerForm = (OwnerForm) form;
   String greet = ownerForm.getGreet();
   String name = ownerForm.getName();
   request.setAttribute("name", name);
   request.setAttribute("greet", greet);
   String address = ownerForm.getAddress();
   String email = ownerForm.getEmail();
   int tel = ownerForm.getTel();

   Connection conn = null;
   Statement stmt = null;
   ResultSet rs = null;

   DataSource dataSource = (DataSource)servlet.getServletContext().getAttribute(
      "org.apache.struts.action.DATA_SOURCE");
      try {
         conn = dataSource.getConnection();
         stmt = conn.createStatement();
         int id = 0;
         rs = stmt.executeQuery("select max(id) as counter from owner");
         while(rs.next()){
            id = rs.getInt("counter");
         }
         id += 1;
         stmt.executeUpdate("insert into owner values(
            "+id+", '"+greet+"', '"+name+"', '"+email+"', '"+address+"', "+tel+")");
         rs.close();
         stmt.close();
         conn.close();
      }
      catch(SQLException e){
         throw new SQLException("database error");
      }
      // Forward control to the specified success target
      return (mapping.findForward("success"));
}

　　您应该重新启动 Tomcat 服务器，让其在启动时就连接到数据源上，并转到 http://127.0.0.1:8080/easyStruts/owner.jsp 页面上。如果所有的输入都正确，那么就会向“owner”表中插入一条记录，并将控制转到 success.jsp 页面。您可以对数据库进行检查，确认是否在表“owner”中新插入了一条记录。

　　使用 Easy Exception 处理异常

　　正如上一节中提到的一样，您可以编写自己的异常处理程序来处理 SQLException 异常。首先，进入 Easy Struts 功能视图，选择 Easy Exception 对异常进行声明。使用如 图 24 所示的配置。资源包名中存放了这个异常的消息资源，这是在 bundle 属性中指定的。这个异常属性指明了当发生这个异常时被调用来处理这个异常的类。这个关键字是在消息资源包中定义的。当异常发生时，控制流程就被重定向到在 path 属性中给定的文件上。scope 属性告诉 Struts ActionErrors（在处理异常时被创建）应该被保存多长时间（会话或请求）。type 属性指定了这个异常处理程序会截获的异常类型。

图 24. 配置异常

　　单击“Finish”之后，异常就被声明了。然后就应该编写 MyExceptionHandler.java 的代码（参见清单 9）。它对 ExceptionHandler 类进行了扩展，与 Action 类很类似，同时还实现了 execute() 方法，并返回一个 ActionForward 对象。正如您所见，Easy Exception 的“path” 属性可以使用 ExceptionConfig 类的 getPath() 方法获得。您可以使用 ExceptionConfig 类的 getKey() 方法获得这个 key 属性。

清单 9. MyExceptionHandler.java

package com.asprise.struts.exception;

import javax.servlet.*;
import javax.servlet.http.*;

import org.apache.struts.action.*;
import org.apache.struts.config.*;

public class MyExceptionHandler extends ExceptionHandler {
   public ActionForward execute(
      Exception ex,
      ExceptionConfig ae,
      ActionMapping mapping,
      ActionForm formInstance,
      HttpServletRequest request,
      HttpServletResponse response)
   throws ServletException {
      request.setAttribute("myException",ex);
      request.setAttribute("myForm",formInstance);
      request.setAttribute("myKey",ae.getKey());
      return new ActionForward(ae.getPath());
   }
}

　　在异常声明中，如果发生一个 SQLException 异常，那么控制流程就会被重定向到 exception.jsp 文件。我们的 exception.jsp 会显示默认的资源属性文件中关键字为“error.database”的消息，以及异常被抛出时的异常类型和异常消息。您可以在 MyExceptionHandler 中获取这个异常关键字。您也可以将这个关键字提供给 <bean:message> 标签使用，如 清单 10 所示。

清单 10. exception.jsp

<%@ page import="java.sql.SQLException" %>
<%@ page import="com.asprise.struts.form.*" %>
<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean"%>

<%
   OwnerForm myForm = (OwnerForm)request.getAttribute("myForm");
   if (myForm != null) {
      out.println("<font color=red>Sorry, "+myForm.getGreet());
      out.println(" "+myForm.getName()+"</font>");
   }
%>
<ul><bean:message key="<%=request.getAttribute(/"myKey/").toString()%>" />
<%
   Object obj = request.getAttribute("myException");
   if (obj != null) {
      Throwable ex = (Throwable)obj;
      out.println("<li><b>Type:</b>"+ex.toString());
      out.println("<li><b>Message:</b>"+ex.getMessage());
   }
%>

　　定义“error.database=<h3>An Exception Handled by MyExceptionHandler:</h3>”。当发生一个 SQLException 异常时，您应该会看到类似于图 25 所示的内容。

图 25. 处理异常 - 测试结果

　　使用 Easy Module 对应用程序进行模块化

　　在本节中，我们将创建一个名为“newModule”的新模块。要实现这个功能，进入 Easy Struts 功能视图，选择“Easy Module”，并在 Module name 中输入“newModule”，如 图 26 所示。

图 26. 配置模块

　　重新启动 Eclipse，以启用新的模块。如果在启动 Web 应用程序时出现这样一个错误： org.xml.sax.SAXParseException: The content of element type "servlet" must match "(icon?,servlet-name,display-name?,description?,(servlet-class|jsp-file),init-param*,load-on-startup?,run-as?,security-role-ref*)"，通过将新的模块配置部分直接移动到 web.xml 中的一个默认模块下面，您可以来解决这个问题。

　　有两种方法可以切换到新模块上。首先，您可以在 struts-config.xml 中创建一个新的全局或局部转发“success”（参见清单 11）。然后可以使用 mapping.findForward("success") 切换到这个新模块上来。

清单 11. 转发

<forward name="success"
   contextRelative="true"
   path="/newModule/index.do"
   redirect="true"/>

　　其次，创建一个如下所示的操作，其类型是一个 SwitchAction 操作：

 <action path="/switchTo" type="org.apache.struts.actions.SwitchAction" validate="false" />

　　然后在 struts-config-newModule.xml 中创建如 清单 12 所示的操作映射。

清单 12. 操作映射

<action-mappings>
   <action path="/index" type="com.asprise.struts.newmodule.action.IndexAction">
      <forward name="success" path="/index.jsp"/>
   </action>
</action-mappings>

　　接下来，编写 easyStruts/newModule/index.jsp 的代码。index.jsp 只会显示一条消息“You are in module: newModule”。

　　现在，启动 Tomcat 服务器，并输入 http://127.0.0.1:8080/easyStruts/switchTo.do?prefix=/newModule&page=/index.do。结果如 图 27 所示。如果您想切换回默认的模块，只需输入 http://127.0.0.1:8080/easyStruts/switchTo.do?prefix=&page=/owner.jsp 即可。

图 27. 在模块间进行切换

　　注意： 您可以在除“Add Easy Struts support”之外的所有 Easy Struts 功能中指定模块名。

　　使用 Easy Plug-in 创建定制插件

　　在本节中，您将学习 Easy Struts 的最后一个功能 -- Easy Plug-in。 Plug-in Action 的一个常见用法是在 Web 应用程序在启动时，配置或装载特定应用程序的数据。自定义插件实现了 Plug-in 接口。这个接口的实现需要一个零参数的构造函数，供 ActionServlet 使用，从而确保插件可以正确创建。接口中定义的两个方法分别是 init() 和 destroy()，这两个方法分别在启动和关闭应用程序时被调用。您必须实现这两个方法。

　　要创建一个插件，进入 Easy Struts 功能视图，选择 Easy Plugin，在 Plugin class 中输入内容，并为添加一些属性。我们要添加 proxy 和 port 属性，如 图 28 所示。

图 28. 配置插件

　　接下来，编写 MyPlugin 类的代码，如 清单 13 所示。这段代码实现了 Plugin 类。当启动 Web 应用程序时，会显示一条消息说“MyPlugin starting”，并设置系统的 proxy 和 port 属性。当关闭应用程序时，就会显示一条“MyPlugin Stopping”消息。

清单 13. MyPlugin.java

package com.asprise.struts.plugin;

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

public class MyPlugin implements PlugIn{
   public String proxy;
   public String port;

   public MyPlugin(){
   }

   public void init(ActionServlet servlet, ModuleConfig config){
      System.err.print("********* MyPlugin Starting *******");
      System.setProperty("https.proxyHost", getProxy());
      System.setProperty("https.proxyPort", getPort());
      servlet.getServletContext().setAttribute("proxy", getProxy());
      servlet.getServletContext().setAttribute("port", getPort());
   }
      public void destroy(){
         System.err.print("********* MyPlugin Stopping *******");
      }
      public void setProxy(String prox){
         proxy = prox;
      }
      public String getProxy(){
         return this.proxy;
      }
      public void setPort(String por){
         port = por;
      }
      public String getPort(){
         return this.port;
      }
}

　　在这个 JSP 或其他 Java 文件的源代码中，可以使用 getServletContext().getAttribute("proxy") 来获取 proxy 的值。

　　部署应用程序

　　要将 Struts 应用程序部署到客户端上，可以简单地将应用程序导出为一个 WAR 文件，并将其分发到您的客户端上，让它们把这个 WAR 文件放到自己 Web 服务器的“webapps” 目录中即可。下面是将应用程序导出为 WAR 文件的步骤：

　　1. 进入“Project”菜单，选择“Properties”菜单，选择“Tomcat”选项，并单击“Export to WAR settings”选项卡。
　　2. 单击“WAR file for export”边上的“Browse”，将其设置为您选定的文件夹 /easyStruts.war，并保存设置。
　　3. 然后进入 project 弹出菜单，选择“Tomcat project”，并在子菜单中单击“Export to the WAR file sets in project properties”。
　　4. 在显示“Operation successful”消息之后，您可以转到第 2 步中指定的位置获取 WAR 文件。

　　结束语

　　在本文中，我们介绍了 Easy Struts 在开发在 Tomcat Web 服务器上运行的 Struts 应用程序方面的功能。您已经学习了如何处理表单验证，如何创建局部和全局的转 发和异常，同时还知道了如何进行异常处理，如何连接数据源，内容的国际化和本 地化，对应用程序进行模块化，创建自定义插件，以及将应用程序部署到客户端等知识。