Struts开源框架中英文对照外文翻译文献

中英文对照外文翻译文献

(文档含英文原文和中文翻译)

Best practices for Struts development

Struts: A brief introduction

Struts, an open source framework you can use to build Web applications, is based on the popular Model-View-Controller (MVC2) design paradigm. The framework is built upon standard technologies like Java Servlets, JavaBeans, ResourceBundles, and XML, and it provides flexible and extensible

components. Struts implements the Controller layer in the form of ActionServlet and recommends building the View layer using JSP tag libraries. Struts also provides a wrapper around the

Model layer through Action classes. Figure 1 illustrates the Struts framework based on the

Model-View-Controller design.

Figure 1. Struts and MVC

Overview of Struts components

First, we'll explain the Struts components in the context of best practices and the role each one plays in your Web application development.

Action

Every Action of your application extends

Struts' org.apache.struts.action.Action. These Action classes provide an interface to the application's Model layer, acting as a wrapper around the business logic.

Each Action class must provide its case-specific implementation to the perform() method. The perform() method always returns a value of type ActionForward. ActionForm

Every ActionForm of your application extends

Struts' org.apache.struts.action.ActionForm. ActionForm s are simple JavaBeans that encapsulate and validate request parameters. To validate your request data, your ActionForm's validate() method must give a case-specific implementation. ActionForm s serve as a carrier of request data to the Action class. A JSP object combines with a respective ActionForm to form your application's View layer, where almost every form field of the JSP object maps to an attribute of the corresponding ActionForm. JSP custom tag libraries

The JSP custom tag libraries are a collection of actions presented as tags. This is a powerful feature of the JSP Specification 1.1; it allows you to separate presentation from other application tiers. The libraries are easy to use and you can read them in XML-like fashion. You can easily maintain the JSP components by minimizing the use of Java scriptlets in them. The JSP tags that Struts provides include HTML, logic, and bean tags.

ActionErrors

You use ActionError s to support exception handling. An ActionError traps and propagates an application exception to the View layer. Each one is a collection

of ActionError instances. ActionError s encapsulate error messages, while

the in the Presentation layer renders all error messages in

the ActionError collection.

Best Practice 1. Reuse data across multiple ActionForms

Now that you are familiar with the Struts components, we will continue by showing you ways to get the most out of the framework. First, Struts recommends that you associate every JSP object with

an ActionForm, which encapsulates data represented in the screen. You access the form data in the JSP object using accessory methods found in ActionForm. Listing 1 shows the conventional use of ActionForm tag in the View layer.

Listing 1. Using ActionForm in JSP

The ActionForm called "BP1AForm" includes the attribute attrib1, as well as its getter and setter methods. In the configuration file struts-config.xml, the action "/bp1" maps to bp1AForm using the name attribute. This facilitates data display in the JSP.

To implement this best practice, Struts recommends you do two things:

1. Create a JavaBean (BP1BForm) with attributes that form an attribute subset

in BP1AForm, along with the attributes' getter and setter methods.

2. Replace the attributes in BP1AForm with the bean BP1BForm by associating the bean

with BP1AForm. Now you can access this attribute subset

in BP1AForm through BP1BForm. Listing 2 shows you how.

Listing 2. Accessing form attributes in JSP

type="com.ibm.dw.webarch.struts.BP1BForm" />

Best Practice 2. Use Action class to handle requests

Typically when using the Struts framework, for every action the JSP component requests your application to execute, the application must extend

Struts' org.apache.struts.action.Action to create an Action class. This individual Action class interfaces with the application's Model layer while processing the request.

To implement this practice, Struts recommends you follow these steps:

1. Create an Action class, say BP2Action, by

extending org.apache.struts.action.Action.

2. Create all other Action classes in your Web application by extending BP2Action.

3. In BP2Action, create a method performTask(), as in public

abstract ActionForward performTask(ActionMapping

mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws IOException,

ServletException.

4. In BP2Action add one or more generic methods to the application, for

example serverSideValidate(). You can decide on the method's access

modifier by considering the following factors:

o If all Action classes must implement this method, make it abstract.

o If some Action classes will provide a case-specific implementation, declare the method protected and give it a default implementation.

5. In BP2Action, declare method perform() as final. Invoke the above generic

method, which must always be called before processing the request. Now call the

method performTask() created in step 3.

6. In every Action class extending BP2Action, add

method performTask() with a case-specific implementation.

Advantages

This practice has two main advantages. First, it helps you avoid redundant code in

every Action class of your Web application. Second, it gives the application more control over generic tasks by centralizing the behavior in one Action class.

Best Practice 3. Use ActionForm to work on session data

In a Struts-based Web application,

each ActionForm extends org.apache.struts.action.ActionForm. These ActionForm s encapsulate page data and provide a validation framework to validate request parameters.

Most Web applications maintain data in session to make them available throughout the application. This best practice addresses this Web application feature. It allows

methods toSession() and fromSession() to move session data to and from the form data. Thus, it addresses session data maintenance in a Web application.

To adhere to this practice, follow these steps:

1. Create an abstract class named BP3Form by

extending org.apache.struts.action.ActionForm.

2. In BP3Form, add methods with access modifiers as in public abstract void

toSession(SessionData sessionData) and void

fromSession(SessionData sessionData).

3. In every ActionForm, extend BP3Form and implement the abstract methods in

which the form data is transported to and from the session.

4. The corresponding Action class may determine the order in which these methods are

called. For example, you could invoke method toSession() on

the ActionForm just before actionForward is determined.

When to use this practice

This practice is most useful when session data is maintained as a single object and/or every page manipulates or uses session data.

Best Practice 4. Handle exceptions effectively

Conventionally, when an application exception occurs in an Action class, the exception is first logged. Then the class creates an ActionError and stores it in the appropriate scope.

This Action class then forwards control to the appropriate ActionForward. Listing 3 shows how Action class handles exceptions.

Listing 3. Exception handling in an Action class

try {

//Code in Action class

}

catch (ApplicationException e) {

//log exception

ActionErrors actionErrors = new ActionErrors();

ActionError actionError = new ActionError(e.getErrorCode());

actionErrors.add(ActionErrors.GLOBAL_ERROR, actionError);

saveErrors(request, actionErrors);

}

While conventional exception handling procedures save exception information in

every Action class, best practice 4 aims to avoid redundant code while handling exceptions.

To use this practice, Struts recommends following these steps:

1. Create an Action class, say BP4Action, by

extending org.apache.struts.action.Action.

2. Create all other Action classes in your Web application by extending BP4Action.

3. In BP4Action, declare variable ActionErrors actionErrors = new

ActionErrors();.

4. In BP4Action, create a method performTask() as in public

abstract ActionForward performTask(ActionMapping

mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response, ActionErrors

actionErrors) throws IOException, ServletException.

5. In BP4Action, declare method perform() as final. Then invoke generic methods,

which must always be called before processing the request. Now you can call the

method performTask() created in the previous step.

6. While implementing method performTask() in every Action class (by

extending BP4Action), handle application exceptions as shown in Listing 4.

Listing 4. Using ActionErrors effectively

try {

//Code in Action class

}

catch(ApplicationException appException) {

//Log exception

//Add error to actionErrors

actionErrors.add(ActionErrors.GLOBAL_ERROR,

new ActionError(appException.getErrorCode()));

}

In BP4Action, after invoking the method performTask(), save

the ActionErrors using saveErrors(request, errors).

Advantages

This practice's main advantage is that it avoids code redundancy in every Action class that handles ActionErrors.

In conclusion

Building an easily maintainable Web application can be one of the most challenging tasks for a development team. Using a mature framework like Struts helps you implement the infrastructure code normally associated with building an application. The Struts framework provides a set of standard interfaces for plugging business logic into the application, a consistent mechanism across development teams for performing tasks such as user data validation, screen navigation, and so forth, as well as a

set of custom tag libraries to simplify developing screens.

These four best practices are important for you to extract more from the framework's features. You, as

a developer, can benefit from these lessons to increase your code modularity and application reusability, plus minimize code redundancy. These are all critical to building an extensible We

b application.

译文:

Struts 开发的最佳实践

Struts：简介

Struts 是一种开源框架，可用来构建 Web 应用程序，它基于流行的Model-View-Controller (MVC2) 设计范型。该框架构建在一些标准的技术之上，比如 Java Servlets、JavaBeans、ResourceBundles 和 XML，并且可提供灵活和可扩展的组件。Struts 以ActionServlet 的形式实现了Controller 层，并建议使用 JSP 标记库构建 View 层。Struts 通

过Action 类提供了围绕 Model 层的包装器。图 1 展示了基于

Model-View-Controller 设计的 Struts 框架。

图 1. Struts 和 MVC

Struts 组件概览

首先，我们在最佳实践上下文中解释 Struts 组件，以及它们在 Web 应用程序开发中所起的作用。

Action

应用程序的每个Action 都会扩展 Struts

的org.apache.struts.action.Action 类。这些Action 类为应用程序的 Model 层提供了一个接口，充当围绕业务逻辑的包装器。每

个Action 类都必须向perform() 方法提供其特定于用例的实现。perform() 方法经常返回类型ActionForward 的一个值。

ActionForm

应用程序的ActionForm 扩展了 Struts

的org.apache.struts.action.ActionForm 类。ActionForm 是一些封装和验证请求参数的简单 JavaBean。要验证请求数据，

ActionForm 的validate() 方法必须给出一个特定于该情况的实现。ActionForm 作为运载工具，向Action 类提供请求数据。一个 JSP 对象与各自的ActionForm 对象相结合，构成应用程序的 View 层。在该层，几乎 JSP 对象的每个表单字段都映射到相应的ActionForm 的属性。JSP 定制标记库

JSP 定制标记库是用标记表示的一组行为的集合。这是 JSP Specification 1.1 的一个强大特性；它将其他应用程序层的表示区别了开来。这些库易于使用，而且可以以一种类似 XML 的方式来读取。只要尽量少地在其中使用 Java scriptlet，就可以轻松维护 JSP 组件。Struts 提供的 JSP 标记包括 HTML、逻辑和 bean 标记。

ActionErrors

可以使用ActionError 来支持异常处理。ActionError 捕捉应用程序异常，并将其传送给 View 层。每个异常都是一个ActionError实例的集合。ActionError 可以封装错误消息，而 Presentation 层中

的 可以呈现ActionError 集合内的所有错误消息。

最佳实践 1. 跨多个 ActionForm 重用数据

熟悉了 Struts 组件之后，就可以继续学习如何充分利用这一框架。首先，Struts 建议将每个 JSP 对象与一个ActionForm 相关联，后者可以封装屏幕上显示的数据。可以通过ActionForm 内的附加方法来访问 JSP 对象内的表单数据。清单 1 展示了ActionForm 标记在 View 层中的传统方法。

清单 1. 使用 ActionForm

这个ActionForm 被称为“BP1AForm”，它包括属性attrib1 及其getter 和 setter 方法。在配置文件struts-config.xml 中，行为“/bp1” 通过name 属性映射到bp1AForm。这有助于在 JSP 中显示数据。

要实现这一最佳实践，Struts 建议您进行以下两个操作：

1.创建一个 JavaBean（BP1BForm），且其属性是BP1AForm 属性的子

集，还要创建这些属性的 getter 和 setter 方法。

2.通过将这个 bean 与BP1AForm 关联，用 bean BP1BForm 的属

性替代BP1AForm 中的属性。现在就可以通过BP1BForm 访问

BP1AForm 中的属性子集了。清单 2 展示了访问的方式。

清单 2. 访问 JSP 中的表单属性

type="com.ibm.dw.webarch.struts.BP1BForm" />

最佳实践 2. 使用 Action 类处理请求

通常，在使用这个 Struts 框架时，对于 JSP 组件请求应用程序执行的每个动作，应用程序都必须扩展 Struts 的

org.apache.struts.action.Action 以创建Action 类。在处理请求时，单个的Action 类与应用程序的 Model 层连接。

要实现这一最佳实践，Struts 建议您遵循以下步骤：

1.通过扩展org.apache.struts.action.Action 创建一

个Action 类，比如BP2Action。

2.通过扩展BP2Action 在 Web 应用程序中创建所有其

他Action 类。

3.在BP2Action 类中创建一个方法performTask()，就像在公共抽

象类ActionForward performTask(ActionMapping mapping,

ActionForm form, HttpServletRequest request,

HttpServletResponse response) throws IOException,

ServletException 中一样。

4.在BP2Action 类中向应用程序添加一个或多个泛型方法，比

如serverSideValidate()。考虑以下因素后决定方法的访问修饰

符：

o如果所有Action 类都必须实现此方法，则让其为抽象。

o如果某些Action 类提供一个特定的实现，则将此方法声明为受保护，并给它一个默认实现。

5.在BP2Action 类中，将方法perform() 声明为 final。调用上

述的泛型方法（通常在处理请求前调用该方法）。现在调用步骤

3 中创建的方法performTask()。

6.在每个扩展BP2Action 的Action 类，添加具有特定实现的方

法performTask()。

优势

这一实践有两个主要优势。首先，它避免了 Web 应用程序中每

个Action 类的冗余代码。其次，通过将Action 类的行为集中在一起，使应用程序能够更多地控制通用的任务。

最佳实践 3. 使用 ActionForm 处理会话数据

在一个基于 Struts 的 Web 应用程序中，每个ActionForm 都扩

展org.apache.struts.action.ActionForm 类。这些ActionForm 封装页面数据，并提供一个验证框架来验证请求参数。

大多数 Web 应用程序都在会话中保持数据，使其在整个应用程序过程中可用。这种最佳实践实现了这种 Web 应用程序特性。它允许方

法toSession() 和fromSession() 将会话数据移动到表单数据或从表单数据移回。因此，它实现了在 Web 应用程序中保持会话数据。

要遵循一最佳实践，执行以下步骤：

1.通过扩展org.apache.struts.action.ActionForm 创建一个名

为BP3Form 的抽象类。

2.在BP3Form 类中，添加具有访问修饰语的方法，就像在公共抽象

类void toSession(SessionData sessionData) 和void

fromSession(SessionData sessionData) 中一样。

3.在每个ActionForm 类中，扩展BP3Form 并实现这些抽象方法

（表单数据通过它们传递到会话或从会话传回）。

4.相应的Action 类可以决定这些方法的调用顺序。例如，可以在决

定actionForward 之前调用ActionForm 上的方法

toSession()。

何时使用这一实践

这一实践最适用于：会话数据是单一对象和/或每个页操作或使用会话数据。

最佳实践 4. 有效处理异常

传统地，当在Action 类中发生应用程序异常时，异常首先被写入日志。然后此类创建一个ActionError 并在合适的作用域中存储它。然

后Action 类再将控制转交给合适的ActionForward。清单 3 展示

了Action 类是如何处理异常的。

清单 3. Action 类中的异常处理

try {

//Code in Action class

}

catch (ApplicationException e) {

//log exception

ActionErrors actionErrors = new ActionErrors();

ActionError actionError = new ActionError(e.getErrorCode());

actionErrors.add(ActionErrors.GLOBAL_ERROR, actionError);

saveErrors(request, actionErrors);

}

传统的异常处理过程在每个Action 类中保存异常信息，而最佳实践 4 则在处理异常时避免冗余代码。

要使用这一最佳实践，Struts 建议您遵循以下步骤：

1.通过扩展org.apache.struts.action.Action 创建一

个Action 类，比如BP4Action。

2.通过扩展BP4Action 在 Web 应用程序中创建所有其

他Action 类。

3.在BP4Action 中声明变量ActionErrors actionErrors = new

ActionErrors();。

4.在BP4Action 中创建方法performTask()，就像在公共抽象

类ActionForward performTask(ActionMapping mapping,

ActionForm form, HttpServletRequest request,

HttpServletResponse response, ActionErrors actionErrors)

throws IOException, ServletException 中一样。

5.在BP4Action 中将方法perform() 声明为 final。然后调用泛

型方法（这些方法总是在处理请求前调用）。现在调用在前一个步骤

中创建的performTask()。

6.在每个Action 类中实现方法performTask() 的同时（通过扩

展BP4Action），像清单 4 那样处理应用程序异常。

清单 4. 有效使用 ActionErrors

try {

//Code in Action class