全面解析Struts2框架架构及核心架包

本文还有配套的精品资源，点击获取

简介：Struts2作为基于MVC设计模式的Java Web应用程序框架，提供了一个结构化、可扩展且易于维护的开发环境。它包含核心库、插件和依赖库等，通过Action、Result、Interceptor等组件处理请求、业务逻辑和视图展示。此外，Struts2支持OGNL表达式语言、丰富的插件体系、异常处理、国际化与本地化、主题和皮肤定制以及JUnit测试支持，全面覆盖Web应用开发的各个方面。

1. Struts2框架概述

Struts2是Apache软件基金会下的一个开源MVC框架，用于创建企业级的Web应用程序。作为Java EE开发中常用的框架之一，它在2007年从Struts1进化而来，以更简洁的架构、强大的插件系统和灵活的配置为开发者提供了丰富的功能。

1.1 Struts2的发展背景与重要性

Struts2框架的诞生源自于对早期Struts1框架的改进需求。随着Web开发的演进和需求的不断变化，原有的Struts1框架因其代码复杂度和维护困难逐渐显得力不从心。Struts2通过引入注解、拦截器、OGNL等技术，大幅简化了开发流程和配置过程，提高了开发效率和项目的可维护性。其重要性在于提供了一套完备的解决方案来处理Web层的业务逻辑，实现视图与模型之间的分离，同时保持了高扩展性和灵活性。

1.2 Struts2框架的主要特点

Struts2框架的主要特点体现在以下几个方面：

• 拦截器（Interceptor）机制： 提供了一套强大的拦截器机制，用于在请求处理流程中的不同点进行干预和处理，便于实现诸如日志记录、权限校验等横切关注点。
• 灵活的配置方式： Struts2提供了XML、注解、Java配置等灵活的配置方式，让开发者根据需要选择最适合的配置方式。
• 集成OGNL（Object-Graph Navigation Language）： OGNL作为表达式语言，提供了对对象图的操作能力，用于实现数据获取、设置以及方法调用。
• 插件支持： Struts2通过插件机制允许开发者扩展其功能，几乎可以添加任何需要的插件，如文件上传、国际化、表单验证等。
• 支持RESTful架构： 通过特定的拦截器，Struts2能够支持REST风格的Web服务开发，适应现代Web开发趋势。

Struts2框架的成功不仅在于其强大的功能，也在于其活跃的社区支持和不断进化的生态系统。无论对于初学者还是有经验的开发者，Struts2都是构建Web应用的有效工具之一。接下来的章节将深入探讨Struts2的核心组件和工作机制，让我们继续深入了解这个流行的Java Web框架。

2. Struts2核心库和组件详解

2.1 核心组件介绍

Struts2框架的核心组件是整个框架工作的基础，理解这些组件的工作机制对于深入学习和应用Struts2至关重要。接下来，我们将详细介绍Action与ActionSupport组件以及ValueStack（值栈）的作用。

2.1.1 Action与ActionSupport

Action是Struts2框架处理请求的核心组件，它代表了一个请求的处理逻辑。Action类通常包含业务逻辑的实现，并且可以返回一个字符串来决定后续的视图和流程。为了更方便地使用Struts2提供的功能，Struts2框架提供了一个ActionSupport基类，该基类实现了Action接口，并提供了一系列的默认方法实现。

public class MyAction extends ActionSupport {
    private String name;
    private int age;

    @Override
    public String execute() {
        // 自定义执行逻辑
        return SUCCESS;
    }

    // Getter和Setter方法
    // ...
}

在上述的 MyAction 类中，我们继承了 ActionSupport 类，并可以重写 execute 方法来定义自己的业务逻辑。Struts2框架在处理请求时会自动调用这个方法。同时，我们还可以添加自定义的属性和相应的getter和setter方法，这些属性将在值栈中进行操作，从而实现了MVC模式中的模型部分。

2.1.2 ValueStack（值栈）的作用

ValueStack是Struts2框架中的一个核心概念，它是一个存储Action上下文信息的栈结构。在Struts2中，所有的数据都是通过值栈进行传递的，包括Action中的属性值、请求参数和Action的返回结果等。ValueStack可以帮助我们更好地组织数据，并且提供了强大的表达式语言（OGNL）支持。

public class MyAction extends ActionSupport {
    // ...

    public String execute() {
        ValueStack stack = ActionContext.getContext().getValueStack();
        // 通过ValueStack操作数据
        // ...
        return SUCCESS;
    }
}

在上面的 MyAction 类中，我们通过 ActionContext 的 getContext() 方法获取了当前Action的上下文，然后通过上下文访问ValueStack对象。这样，我们就可以在ValueStack上压入数据、弹出数据或者访问数据，非常灵活。ValueStack的使用使得Struts2的MVC模式更加清晰，操作数据更加方便。

2.2 核心库文件的组成

Struts2框架的强大功能是通过多个核心库文件共同作用的结果。了解这些库文件的功能和它们之间的依赖关系，对于掌握Struts2框架的运行机制至关重要。接下来将分析核心jar包功能以及不同jar包的依赖关系。

2.2.1 核心jar包功能

Struts2框架由多个jar包组成，每个jar包负责框架的一部分功能。以下是一些核心的jar包及其功能简介：

• struts2-core.jar : 这是Struts2框架的核心，包含了Action、Interceptor、Result等主要组件和Struts2的运行时环境。
• xwork-core.jar : 提供了Struts2使用的XWork框架的基础，XWork是一个轻量级的命令模式框架，是Struts2的核心。
• ognl.jar : 提供了对象图导航语言（OGNL）的实现，OGNL是一个功能强大的表达式语言，用于访问和操作对象的属性。
• freemarker.jar : 提供了用于生成动态Web页面的模板引擎FreeMarker。

graph LR
A(struts2-core.jar)
B(xwork-core.jar)
C(ognl.jar)
D(freemarker.jar)

A -->|依赖关系| B
A -->|依赖关系| C
A -->|依赖关系| D

上图展示了核心jar包之间的依赖关系，可以看到 struts2-core.jar 作为核心依赖其他三个jar包。

2.2.2 不同jar包的依赖关系

在实际应用中，理解这些jar包之间的依赖关系对于项目配置和解决潜在问题至关重要。从上面的图表中可以看出， struts2-core.jar 是核心，它直接或间接依赖于其他三个jar包，这意味着在项目中引入 struts2-core.jar 时，其他三个jar包也会被间接引入。

了解这些依赖关系后，开发者在遇到问题时可以更容易地定位到具体是哪个jar包的问题，也更容易根据项目需求添加或移除特定的jar包来调整项目的依赖树。

以上内容展示了Struts2框架核心组件和核心库文件的组成，接下来的章节将进一步深入探讨Action与Result的实现机制。

3. Action与Result的实现机制

在Struts2框架中，Action是处理用户请求的核心组件，而Result则定义了当Action处理完成后返回给用户的结果视图。本章节将深入探讨Action与Result的实现机制，包括Action的生命周期、内置Result类型以及Result的配置与跳转机制。

3.1 Action的生命周期

3.1.1 Action的初始化过程

Action的初始化是其生命周期中的第一步，它涉及Action实例的创建和依赖注入。在Struts2框架中，Action的初始化通常是由框架自动完成的。开发者可以通过实现一个零参数的构造函数和相应的getter和setter方法来配合Struts2框架进行依赖注入。

为了更好地理解Action的初始化过程，我们可以考虑以下的Action类：

import com.opensymphony.xwork2.ActionSupport;

public class SampleAction extends ActionSupport {
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
    public String execute() {
        return SUCCESS;
    }
}

在上述代码中，Struts2框架在处理请求时会创建一个 SampleAction 的实例，并使用反射机制调用其无参数构造函数。随后，框架会通过setter方法注入属性值，例如将HTTP请求中的参数设置到 message 属性中。

3.1.2 Action的执行逻辑

Action的执行逻辑由 execute 方法定义。当Action初始化完成后，Struts2框架调用 execute 方法处理业务逻辑。 execute 方法应当返回一个字符串结果，通常这些字符串是与 struts.xml 中定义的result标签的name属性相对应的。

在 SampleAction 类中，我们定义了 execute 方法，当该方法执行完成后，通常会返回 SUCCESS 、 ERROR 、 INPUT 、 NO_METHOD 等值，这些值将对应于 struts.xml 中定义的result。Struts2框架根据返回值找到相应的result，然后返回给用户。

public String execute() {
    // 假设这里是业务逻辑处理代码
    return SUCCESS;
}

3.2 Result类型及使用

3.2.1 内置Result类型解析

Struts2框架提供了多种内置Result类型，使得开发者能够以多种方式向用户展示处理结果。常见的Result类型包括：

• dispatcher ：转发请求到指定的JSP页面。
• redirect ：重定向到指定的URL地址。
• chain ：将当前的Action请求转发到另一个Action。
• stream ：将响应作为输入流返回给客户端。
• plaintext ：返回纯文本格式的结果。

每种Result类型都有其特定的用途，开发者可以根据需求选择合适的Result类型。

3.2.2 Result配置与跳转机制

在 struts.xml 配置文件中，开发者需要配置result，以定义Action执行完毕后视图的呈现方式。下面是一个典型的result配置示例：

<action name="sampleAction" class="com.example.SampleAction">
    <result name="success" type="dispatcher">/success.jsp</result>
    <result name="error">/error.jsp</result>
</action>

在上述配置中， <action> 标签指定了Action的名称和对应的类， <result> 标签定义了不同的返回结果对应的视图。当 SampleAction 的 execute 方法返回 success 时，用户会看到 success.jsp 页面；如果返回 error ，则会显示 error.jsp 页面。

3.2.3 Result配置与跳转机制的进一步解析

对于 dispatcher 和 redirect 这两种常见的Result类型，它们在跳转机制上有着根本的区别。 dispatcher 类型进行的是服务器内部跳转，它通过服务器转发请求到指定页面。而 redirect 则进行的是客户端重定向，意味着浏览器的地址栏会改变，发起一个全新的请求。

在实际应用中，选择正确的跳转机制对系统性能和用户体验都有很大影响。例如，如果需要传递大量的数据，通常会选择 dispatcher ，因为它不会向客户端发送数据，而是保持在服务器端转发。而 redirect 则适合那些不需要保持服务器状态的场景。

<result name="success" type="dispatcher">
    <!-- 内部转发到success.jsp -->
    /WEB-INF/views/success.jsp
</result>
<result name="redirectResult" type="redirect">
    <!-- 重定向到外部URL -->
    ***
</result>

3.2.4 实际应用中的Result类型选择

在选择Result类型时，应考虑如下因素：

• 数据传递的需求 ：是否需要保持状态或者需要向客户端传递数据。
• 用户交互需求 ：是否需要保持用户在当前页面流中，或者需要让用户感知到页面跳转。
• 性能影响 ：不同的Result类型对服务器资源的占用和网络传输的需求是不同的。

例如，若需要在用户提交表单后将信息保存到数据库，并向用户显示一个成功页面，可能会选择 dispatcher 。而如果用户在完成一个购买流程后需要跳转到支付页面，使用 redirect 更为合适，因为支付页面应该是一个独立的请求过程。

通过精心配置和正确使用Result类型，可以有效地管理Web应用的导航流程，提升用户体验和系统性能。

4. Interceptor拦截器功能深入

拦截器是Struts2框架的一个重要特性，它类似于过滤器，但拦截器为Struts2的动作提供了一种更细粒度的控制。拦截器可以拦截用户的请求并进行预处理或后处理，使得开发者可以创建可重用的功能模块，比如日志记录、权限验证等。

4.1 拦截器的链式执行机制

拦截器的链式执行机制是Struts2框架中的一大特色。它允许用户配置一系列的拦截器，并在每个拦截器中处理用户请求，然后将控制权传递给下一个拦截器或最终的动作（Action）。

4.1.1 拦截器的注册与配置

拦截器在Struts2中是通过配置文件进行注册的。默认情况下，所有拦截器都在struts-default.xml中预定义，用户也可以在自己的struts.xml配置文件中添加或覆盖默认拦截器。

在struts.xml中注册拦截器的配置样例如下：

<interceptors>
    <interceptor name="customInterceptor" class="com.example.CustomInterceptor"/>
    <interceptor-stack name="customStack">
        <interceptor-ref name="defaultStack"/>
        <interceptor-ref name="customInterceptor"/>
    </interceptor-stack>
</interceptors>

<action name="exampleAction" class="com.example.ExampleAction">
    <interceptor-ref name="customStack"/>
    <!-- 其他配置 -->
</action>

在此配置中，定义了一个名为 customInterceptor 的拦截器，以及一个拦截器栈 customStack ，后者引用了默认的拦截器栈 defaultStack 并添加了自定义拦截器。动作 exampleAction 使用了这个自定义的拦截器栈。

4.1.2 拦截器的调用顺序和流程

在Struts2中，拦截器是按照栈的形式组织的。当用户发起请求时，Struts2会创建拦截器栈的实例，并按照注册的顺序执行栈中的拦截器。一旦所有的拦截器执行完毕，请求最终将传递到目标动作。

下面的mermaid流程图展示了拦截器调用的顺序和流程：

graph TD;
    A[请求发起] --> B{是否配置拦截器};
    B -- 是 --> C[执行拦截器1];
    C --> D[执行拦截器2];
    D --> E[...];
    E --> F[执行拦截器N];
    F --> G[请求处理动作];
    G --> H[返回响应];
    H --> I[请求完成];
    B -- 否 --> G;

这个流程图说明了如果配置了拦截器栈，请求将依次通过每个拦截器，并在通过所有拦截器后到达处理动作，随后返回响应。如果动作被配置为不使用任何拦截器，请求将直接到达动作处理。

4.2 自定义拦截器的创建与应用

自定义拦截器可以实现用户特定的需求，如验证用户登录状态、记录请求处理时间等。

4.2.1 实现自定义拦截器的步骤

创建自定义拦截器需要实现 com.opensymphony.xwork2.interceptor.Interceptor 接口或继承 com.opensymphony.xwork2.interceptor.AbstractInterceptor 类。以下是创建一个简单自定义拦截器的步骤和代码样例：

package com.example.interceptor;

import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;

public class CustomInterceptor extends AbstractInterceptor {

    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        // 在动作执行前的逻辑处理
        String result = invocation.invoke();
        // 在动作执行后的逻辑处理
        return result;
    }
}

在这个拦截器中，重写了 intercept 方法，在动作执行前后添加了自定义逻辑。

4.2.2 拦截器在实际项目中的应用案例

假设我们需要在每个动作执行前验证用户是否登录。首先，我们创建一个 AuthInterceptor 拦截器，代码如下：

public class AuthInterceptor extends AbstractInterceptor {
    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        ActionContext ctx = invocation.getInvocationContext();
        Map<String, Object> session = ctx.getSession();

        // 检查用户是否登录
        User user = (User) session.get("user");
        if (user == null || !user.isLoggedIn()) {
            return "login"; // 返回登录页面
        }

        // 用户已登录，继续执行动作
        return invocation.invoke();
    }
}

然后在struts.xml中配置拦截器：

<interceptors>
    <interceptor name="authInterceptor" class="com.example.interceptor.AuthInterceptor"/>
    <!-- 其他拦截器配置 -->
</interceptors>

<default-interceptor-ref name="authInterceptor"/>

<action name="securedAction" class="com.example.SecuredAction">
    <!-- 动作配置 -->
</action>

在上述配置中， authInterceptor 作为默认拦截器注册，这意味着所有动作在执行前都会通过这个拦截器进行验证。 securedAction 是需要用户登录后才能访问的动作。

通过这种模式，我们能确保只有认证的用户才能访问特定的动作，为我们的应用添加了一层安全保护。

5. 配置文件的作用与类型

5.1 struts.xml配置详解

在Struts2框架中， struts.xml 是最重要的配置文件，负责定义Action的映射关系、result类型以及各种拦截器配置等。它允许开发者通过XML的形式，细致地控制Struts2的运行行为。

5.1.1 配置文件结构与元素解析

struts.xml 文件通常遵循标准的XML格式，它包含一系列的根元素和子元素。根元素是 <struts> ，在其中可以定义多个 <package> 元素，而 <package> 元素内部可以定义 <action> 元素、 <interceptor-ref> 元素等。

在 <package> 元素内部， <action> 元素定义了一个具体的Action映射，包括其执行的方法、返回的result类型等。而 <interceptor-ref> 元素则用于引用拦截器，它可以在Action执行前后插入自定义的逻辑。

<struts>
    <package name="default" extends="struts-default">
        <action name="helloWorld" class="com.example.HelloWorldAction">
            <result name="success">/success.jsp</result>
            <result name="error">/error.jsp</result>
        </action>
        <interceptor-ref name="defaultStack"/>
        <!-- 其他配置 -->
    </package>
</struts>

5.1.2 配置文件中的namespace和package的作用

namespace 是 struts.xml 中一个非常重要的概念。它类似于URL中的路径，用于将一组 <action> 映射分组管理。 namespace 可以帮助开发者组织和区分应用程序中的不同部分，例如，可以通过不同的 namespace 来分别管理用户模块、订单模块等。

package 用于定义一组相关的Action和拦截器。它不仅可以包含多个 <action> 元素，还可以包含 <interceptor-ref> 元素。通过 <package> 可以实现拦截器的复用，增强配置的灵活性和可维护性。

<package name="user" extends="struts-default" namespace="/user">
    <!-- user模块的Action配置 -->
</package>

<package name="admin" extends="struts-default" namespace="/admin">
    <!-- admin模块的Action配置 -->
</package>

5.2 struts.properties及其他配置文件

struts.properties 是另一个重要的配置文件，它允许开发者设置一些Struts2框架的运行时属性。此文件中的配置项通常以键值对的形式出现，其作用范围包括：配置常量、拦截器参数、日志级别等。

5.2.1 struts.properties的作用与设置

struts.properties 文件通常用于对Struts2框架的行为进行微调。例如，开发者可以使用它来配置全局常量、日志级别、国际化资源路径等。

# 设置日志级别为DEBUG
struts.logLevel=DEBUG

# 指定国际化资源文件的路径
struts.custom.i18n.resources=myResources

5.2.2 其他配置文件如struts-defaults.xml简介

除了 struts.xml 和 struts.properties 之外，Struts2还提供了一些其他的配置文件，用于存放默认配置或框架级的配置。例如， struts-defaults.xml 文件包含了Struts2框架默认的拦截器栈配置。这些文件通常由Struts2框架内部使用，开发者可以根据需要引用或覆盖其中的设置。

开发者可以通过阅读官方文档来了解更多关于 struts-defaults.xml 和 struts-plugin.xml 等文件的详细信息，并根据项目的实际需求进行合理的配置。

<!-- 一个struts-defaults.xml文件的例子 -->
<struts>
    <package name="struts-default" extends="struts-core" abstract="true">
        <interceptors>
            <!-- 默认拦截器配置 -->
        </interceptors>
        <global-results>
            <!-- 默认的全局结果配置 -->
        </global-results>
    </package>
</struts>

通过上述配置，开发者能够针对不同的需求，细致地调整Struts2框架的行为。这种灵活性和可配置性是Struts2框架强大功能的一个重要体现。

6. OGNL在Struts2中的应用

6.1 OGNL表达式基础

6.1.1 OGNL表达式的语法规则

OGNL，全称为Object-Graph Navigation Language，是一种功能强大的表达式语言，用于获取和设置Java对象的属性。在Struts2框架中，OGNL扮演了非常重要的角色，因为它与ActionContext交互来动态地访问和操作数据。

表达式的基本语法包括直接访问对象的属性、调用方法和操作集合。以下是一些基本规则：

• 直接访问属性： person.name 或 person.getName()
• 访问数组或集合中的元素： list[0]
• 访问静态属性： #constantName
• 调用静态方法： #staticMethod()
• 使用ognl:操作符访问上下文中的属性： ognl:getProperty(context,'person.name')
• 使用ognl:操作符执行操作：`ognl:valueStack()

6.1.2 OGNL与ActionContext的交互

ActionContext是OGNL在Struts2中使用的核心上下文。它提供了访问应用程序上下文数据的简便方法。在Struts2中，ActionContext包含了Action对象、值栈、参数映射和其他一些有用的上下文信息。OGNL使得这些信息能够被轻松地访问和操作。

在ActionContext中，最常用的对象是值栈（ValueStack）。值栈通过OGNL提供了一种便捷的方式来访问和操作存储在栈中的Action对象和其他对象。OGNL表达式可以轻松地获取值栈中的数据或者将数据推送到值栈中。

6.2 OGNL与Struts2标签库的集成

6.2.1 在JSP中使用OGNL

Struts2的标签库与OGNL紧密集成，允许开发者在JSP页面上直接使用OGNL表达式。这种集成简化了数据的展示和操作，使得在视图层访问和修改后端数据变得非常容易。

例如，要在JSP页面上显示一个名为 user 的JavaBean的 name 属性，可以使用以下标签：

<s:property value="user.name" />

这个标签使用OGNL表达式 user.name 来获取 user 对象的 name 属性值，并将其展示在页面上。

6.2.2 OGNL在表单验证中的应用

OGNL不仅用于数据展示，还可以用来执行表单验证逻辑。在Struts2的验证框架中，验证规则和逻辑可以通过OGNL表达式进行编写。

验证规则通常在 struts.xml 配置文件中或者在Action类中使用注解定义。例如，要验证一个表单中的年龄字段必须大于18，可以在 struts.xml 中定义如下规则：

<field name="age">
    <field-validator type="int">
        <param name="min">18</param>
        <message>Age must be greater than 18.</message>
    </field-validator>
</field>

在这个规则中， min 参数使用OGNL表达式来指定验证条件。

在代码中也可以使用OGNL进行动态验证。例如，在Action的 validate() 方法中，可以使用OGNL来动态获取需要比较的值，完成复杂的验证逻辑。

代码块与逻辑分析

下面的代码展示了如何在Action类中使用OGNL表达式来进行动态验证：

public class UserAction extends ActionSupport {
    private int age;
    private int minAge;

    // 其他getter和setter方法...

    public void validate() {
        if (age < minAge) {
            addFieldError("age", getText("age.error"));
        }
    }

    public String execute() {
        // Action执行逻辑...
        return SUCCESS;
    }
}

在这个例子中， validate() 方法使用OGNL表达式来访问ActionContext中的属性。如果 age 小于 minAge ，则添加一个字段验证错误。

小结

通过本节的学习，我们了解了OGNL表达式在Struts2中的应用，包括它在访问数据、表单验证等方面的功能。OGNL与ActionContext的交互，使得数据访问更加简洁和直接。在JSP页面中，OGNL提供了强大的数据处理能力，使得页面开发更加灵活和高效。通过具体的代码示例，我们展示了如何在实际的Action类中实现这些功能。在下一章节，我们将继续探讨Struts2的其他高级特性，进一步加深对框架的理解和应用。

7. Struts2插件体系及其对功能的扩展

7.1 插件体系架构

7.1.1 插件的作用与优势

Struts2框架的一大特色在于其灵活的插件体系，这允许开发者以一种模块化的方式扩展框架的功能。插件作用与优势主要体现在以下几个方面：

• 模块化扩展 ：插件作为一种独立的模块，可以单独开发和维护，这使得功能扩展和升级变得更加容易。
• 代码解耦 ：插件将额外的功能封装在内，减少了主应用代码的复杂度，降低了代码之间的耦合。
• 功能增强 ：插件可以提供许多核心框架未包含的功能，如数据校验、国际化、文件上传等。
• 动态加载 ：Struts2允许插件动态加载，这意味着在不重启服务器的情况下添加或移除功能。

7.1.2 Struts2插件的注册与卸载

Struts2插件的注册与卸载主要通过配置文件完成。开发者需要按照以下步骤操作：

• 注册插件 ：在 struts.xml 配置文件中，使用 <package> 元素的 <plug-in> 子元素来声明插件，插件类名作为属性传入。
• 卸载插件 ：通过 <plug-in> 元素的 destroy-method 属性指定一个方法，当插件需要被卸载时，Struts2会调用这个方法。

示例代码 ：

<package name="default" extends="struts-default">
    <action name="example" class="ExampleAction">
        <result name="success">/success.jsp</result>
    </action>
    <!-- 注册插件 -->
    <plug-in class="org.apache.struts2.plugin.MyPlugin"/>
</package>

7.2 常用插件及其功能介绍

7.2.1 文件上传下载插件

文件上传和下载是Web应用中常见的需求，Struts2提供了一个文件上传的插件，它基于Apache Commons FileUpload组件。这个插件的主要功能包括：

• 支持多文件上传。
• 文件大小和类型的校验。
• 文件上传进度的跟踪。

使用示例 ：

<action name="uploadFile" class="com.example.UploadAction">
    <interceptor-ref name="defaultStack"/>
    <interceptor-ref name="fileUpload">
        <param name="allowedTypes">image/jpeg,image/png</param>
    </interceptor-ref>
    <result name="success">/upload_success.jsp</result>
</action>

7.2.2 国际化插件i18n和表单验证插件

国际化（i18n）和表单验证是两个非常重要的功能，它们分别用于实现应用的多语言支持和前端表单的数据校验。

• 国际化插件i18n ：通过配置资源包，可以根据用户的地域设置不同语言的提示信息。
• 表单验证插件 ：提供了一套在Action中进行数据校验的机制，可以使用注解或XML配置进行规则定义。

国际化配置示例 ：

<action name="internationalize" class="com.example.InternationalizeAction">
    <interceptor-ref name="defaultStack"/>
    <interceptor-ref name="i18n">
        <param name="locale">en_US</param>
    </interceptor-ref>
    <result name="success">/internationalize.jsp</result>
</action>

表单验证配置示例 ：

<action name="formValidation" class="com.example.FormValidationAction">
    <interceptor-ref name="defaultStack"/>
    <interceptor-ref name="validation">
        <param name="excludeMethods">input,back,cancel</param>
    </interceptor-ref>
    <result name="input">/form_input.jsp</result>
    <result name="success">/form_success.jsp</result>
</action>

通过上述配置，开发者可以利用Struts2的国际化插件i18n和表单验证插件，实现Web应用的国际化和前端数据验证功能。

请注意，虽然第七章已经详细介绍了Struts2插件体系及其功能扩展，但Struts2的更多插件和配置细节可以在官方文档中找到进一步的信息。对开发者来说，了解并熟悉这些插件可以大大提升开发效率，同时也有助于创建更加健壮和功能丰富的Web应用。

本文还有配套的精品资源，点击获取

简介：Struts2作为基于MVC设计模式的Java Web应用程序框架，提供了一个结构化、可扩展且易于维护的开发环境。它包含核心库、插件和依赖库等，通过Action、Result、Interceptor等组件处理请求、业务逻辑和视图展示。此外，Struts2支持OGNL表达式语言、丰富的插件体系、异常处理、国际化与本地化、主题和皮肤定制以及JUnit测试支持，全面覆盖Web应用开发的各个方面。

本文还有配套的精品资源，点击获取