Struts2框架实践：入门到精通的小例子

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

简介：Struts2是一个基于MVC模式的Java Web应用框架，本实例将深入探讨其核心特性如拦截器、国际化支持、重复登录防范、Token机制，以及与myEclipse集成、Action/Result、配置文件(struts.xml)和JSP视图技术的使用。通过实践这些关键知识点，开发者将提升在构建和维护Java Web应用方面的能力。

1. Struts2框架入门

1.1 Struts2框架简介

Struts2是一个用于构建Web应用程序的开源框架，它允许开发人员将Web层的逻辑与表示层分离。Struts2是Apache软件基金会下的一个子项目，其核心是一个强大的过滤器和拦截器的API，提供了一个灵活的MVC（Model-View-Controller）架构的实现。开发者可以通过它快速创建动态的Web页面，利用诸如标签库和各种内置的拦截器来提高开发效率。

1.2 Struts2框架工作原理

Struts2框架的运作基于一个核心组件： Action 。当用户发起一个请求时，该请求被框架捕获并传递给相应的 Action 处理。 Action 将业务逻辑处理完毕后，返回一个结果（Result），这个结果决定了下一个视图（View）的显示或者页面的跳转。通过这种方式，Struts2实现了MVC架构中控制器与视图的解耦。

1.3 Struts2与Servlet的关系

Struts2框架并不是取代Servlet的工具，而是建立在Servlet API之上的一个高级封装。它为处理HTTP请求和响应提供了更高级的概念，比如使用Action和Result来代替直接编写Servlet代码。开发者可以用更少的代码来实现相同的功能，从而专注于业务逻辑的开发，而不是底层的细节处理。

通过本章的学习，我们已经对Struts2框架有了一个基础的认识。接下来的章节中，我们将深入了解如何在Struts2中使用拦截器、实现国际化支持，以及如何防止重复登录和页面刷新导致的问题。每一项技术都是构建高质量Web应用不可或缺的一部分。

2. 拦截器（Interceptors）的使用

2.1 拦截器的概念与作用

2.1.1 拦截器的基本概念

拦截器是一种用于在请求处理链中的特定位置拦截请求和响应的组件。在Struts2框架中，拦截器用于执行一系列预定义的检查或操作，比如表单验证、日志记录、权限检查等，这些功能在多个动作（Action）中可能需要重复使用。使用拦截器可以减少代码的冗余，提高代码的复用性和模块化。

在Struts2中，拦截器位于Action之前，在请求到达Action之前提供了一种机制来修改请求，以及在Action执行之后修改响应。它们在执行Action之前后顺序调用，从而形成了一个拦截器链。

2.1.2 拦截器与过滤器的区别

拦截器和过滤器（Filters）都是用来拦截请求的组件，但它们在处理请求的生命周期以及使用方式上存在差异。在Java EE规范中，过滤器是使用标准的Servlet API实现的，而拦截器通常是框架特有的。

• 执行时机 ：过滤器在Servlet生命周期的早期被调用，即在请求被转发到Servlet之前；而拦截器可以在Action执行前后进行操作。
• 功能范围 ：过滤器的作用范围更广，可以处理所有类型的请求；拦截器则专门用于处理特定框架的请求。
• 配置方式 ：过滤器通过web.xml进行配置；拦截器则是在Struts2的配置文件（struts.xml）中进行配置。
• 复用性 ：拦截器可以更加方便地进行复用，因为它们可以针对特定的Action进行配置。

2.2 实现自定义拦截器

2.2.1 创建拦截器类

要创建一个自定义拦截器，需要实现Struts2提供的 Interceptor 接口，重写 intercept 方法，该方法的签名如下：

public String intercept(ActionInvocation invocation) throws Exception;

该方法返回一个 String 类型的值，表示接下来要执行的动作或转发的目标视图。下面是一个简单的拦截器实现示例：

public class SampleInterceptor implements Interceptor {
    private static final long serialVersionUID = 1L;

    @Override
    public void init() {
        // 初始化代码
    }

    @Override
    public void destroy() {
        // 清理资源
    }

    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        System.out.println("Before invoking action...");
        // 其他预处理逻辑
        // 继续执行后续的拦截器和Action
        String result = invocation.invoke();
        System.out.println("After invoking action...");
        // 其他后处理逻辑
        return result;
    }
}

2.2.2 在struts.xml中配置拦截器

配置拦截器需要在 struts.xml 中声明拦截器，并将其注册到拦截器栈中。以下是如何进行配置的示例：

<interceptors>
    <interceptor name="sampleInterceptor" class="com.example拦截器.SampleInterceptor"/>
    <!-- 其他拦截器定义 -->

    <interceptor-stack name="myStack">
        <interceptor-ref name="defaultStack"/>
        <interceptor-ref name="sampleInterceptor"/>
        <!-- 可以添加更多的拦截器 -->
    </interceptor-stack>
</interceptors>

<action name="sampleAction" class="com.example的动作.SampleAction">
    <interceptor-ref name="myStack"/>
    <!-- 其他Action配置 -->
</action>

在这个例子中，我们定义了一个名为 sampleInterceptor 的拦截器，并且创建了一个拦截器栈 myStack ，其中包含了默认的拦截器栈 defaultStack 和我们的自定义拦截器 sampleInterceptor 。

2.3 拦截器链的使用和配置

2.3.1 拦截器链的工作原理

拦截器链的工作原理是基于预定义顺序，拦截器在Action执行前后依次执行它们的逻辑。拦截器可以决定是否继续调用链中的下一个拦截器，或者直接返回结果到客户端。这样，一个复杂的请求处理逻辑可以通过多个拦截器来协同完成，从而实现高度的可配置性和可扩展性。

2.3.2 如何配置拦截器链

在 struts.xml 中配置拦截器栈并将其应用到Action是使用拦截器链的典型方式。除了静态配置外，还可以在运行时动态地修改拦截器栈。拦截器的配置顺序通常决定了它们的执行顺序。

<action name="sampleAction" class="com.example的动作.SampleAction">
    <interceptor-ref name="myStack"/>
    <interceptor-ref name="timer"/>
    <!-- 其他拦截器引用 -->
</action>

在上面的配置中， sampleAction 动作将会使用 myStack 拦截器栈，并且额外引用了 timer 拦截器，它通常用于性能监控。

拦截器栈可以被多个Action共享，这提高了代码的复用性。在实际应用中，我们通常会有一些常用的拦截器栈，并根据不同的Action需求引用相应的拦截器栈。

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

上述配置将 commonStack 设为默认拦截器栈，这样没有指定拦截器栈的Action都会使用 commonStack 。

| 拦截器名称 | 作用描述 | | ---------------- | --------------------------------------------------- | | sampleInterceptor| 在动作执行前后打印日志信息。 | | timer | 监控Action执行的时间。 | | ... | ... |

通过合理配置和使用拦截器，可以提高Web应用的效率和性能，增强代码的可维护性和复用性。随着对拦截器使用的深入，开发者可以进一步探索更高级的拦截器应用场景，比如动态拦截器配置、拦截器的扩展和拦截器之间的通信等。

3. 国际化（Internationalization, i18n）的支持与实践

3.1 国际化的基本原理

国际化（Internationalization），通常简称为i18n，指的是软件产品或系统在设计时，可以支持不同语言和文化环境的用户使用。它确保用户界面的语言和内容能够适应用户的地区设置。

3.1.1 语言和文化相关资源的管理

国际化的核心在于对语言和文化相关资源的管理。这些资源通常包括文本字符串、日期和时间的格式、数字和货币的表示等。软件产品需要从外部资源文件中加载这些数据，这样在不同的文化环境中就可以使用相应的本地化资源文件。

要实现这一点，通常需要以下步骤：

• 抽取所有用户界面的字符串到资源文件中。
• 根据不同的语言和文化环境，为每种语言创建相应的资源文件。
• 使用API调用资源文件中的数据，而不是硬编码在应用程序中。
• 提供用户界面的动态语言切换功能。

3.1.2 国际化与本地化的关系

国际化关注的是软件的“国际适应性”，而本地化（Localization），简称l10n，关注的是软件的“地区适应性”。国际化是基础，它为本地化铺平了道路。一旦产品实现了国际化，就更容易对其进行本地化，添加新的语言和文化支持。

3.1.3 代码块展示及解释

以Java中资源文件的使用为例，创建一个简单的国际化资源文件（ Messages.properties ）：

welcome.message=Welcome

在Java代码中，使用该资源文件：

import java.text.MessageFormat;
import java.util.Locale;
import java.util.ResourceBundle;

public class I18nExample {
    public static void main(String[] args) {
        // 设置当前区域为美国
        Locale usLocale = new Locale("en", "US");
        ResourceBundle messages = ResourceBundle.getBundle("Messages", usLocale);
        System.out.println(messages.getString("welcome.message"));
        // 设置当前区域为中国
        Locale chinaLocale = new Locale("zh", "CN");
        messages = ResourceBundle.getBundle("Messages", chinaLocale);
        System.out.println(messages.getString("welcome.message"));
    }
}

在上面的代码中，我们使用 ResourceBundle.getBundle 方法获取对应地区的资源文件，并通过 getString 方法获取具体资源。输出将会显示不同区域设置下的欢迎信息。

3.1.4 表格展示支持的语言和地区

下表展示了常见的支持语言和地区：

| 语言代码 | 地区代码 | 描述 | |---------|---------|------------------| | en | US | 美国英语 | | zh | CN | 中国大陆简体中文 | | fr | FR | 法国法语 | | es | ES | 西班牙西班牙语 | | de | DE | 德国德语 |

3.2 实现Struts2项目的国际化

3.2.1 配置资源文件

在Struts2项目中，国际化配置通常涉及 strutsMessages.properties 、 strutsMessages_en_US.properties 、 strutsMessages_zh_CN.properties 等资源文件的创建和使用。这些文件应该放置在项目的 resources 目录下。

3.2.2 指定资源文件的加载顺序

在 struts.xml 文件中，可以通过 <constant> 标签指定资源文件的加载顺序：

<constant name="struts.custom.i18n.resources" value="strutsMessages" />

上述配置表示Struts2将首先查找 strutsMessages.properties 文件，然后根据用户的语言和地区设置查找相应的 strutsMessages_<language>_<country>.properties 文件。

3.3 动态切换语言支持

3.3.1 利用拦截器实现语言切换

可以创建一个拦截器，监听用户的语言切换请求，并保存用户选择的语言到会话（Session）中。

public class LanguageInterceptor implements Interceptor {
    public void intercept(ActionInvocation invocation) throws Exception {
        ActionContext context = invocation.getInvocationContext();
        HttpServletRequest request = (HttpServletRequest) context.get(ServletActionContext.HTTP_REQUEST);
        HttpServletResponse response = (HttpServletResponse) context.get(ServletActionContext.HTTP_RESPONSE);

        String language = request.getParameter("language");
        if (language != null) {
            // 将选中的语言保存到会话中
            context.getSession().put("language", language);
        } else {
            // 从会话中获取之前保存的语言
            language = (String) context.getSession().get("language");
        }
        // 根据获取的语言设置Locale
        Locale locale = new Locale(language);
        request.getSession().setAttribute("javax.servlet.jsp.jstl.fmt.locale.session", locale);

        invocation.invoke(); // 继续执行链中的下一个拦截器或Action
    }
}

3.3.2 实现多语言版本的动态切换

在JSP页面中，可以使用JSTL的fmt标签库实现动态切换语言版本。这通常通过下拉菜单选择语言实现：

<c:select name="language" onchange="this.form.submit();">
    <c:forEach items="${availableLanguages}" var="lang">
        <option value="${lang}" ${lang == language ? 'selected' : ''}>
            ${lang}
        </option>
    </c:forEach>
</c:select>

上述代码展示了如何在页面上提供语言选择功能，用户选择不同的语言选项后，页面会自动提交，并触发 LanguageInterceptor 拦截器保存语言设置。

通过上述方法，Struts2项目可以支持多语言环境，使用户能够根据自己的喜好和需要选择不同的语言。这种动态切换机制不仅提高了用户体验，还扩展了产品的国际化适应性。

以上内容提供了对Struts2框架国际化原理和实践的深入探讨，包括基本原理、配置方法、动态语言切换的实现等。通过这些内容，开发者可以学会如何在Struts2项目中实现国际化，支持多语言环境，提升应用的国际化水平。

4. 防止重复登录（Preventing Duplicate Login）

重复登录是指用户在未经授权的情况下多次成功登录系统，这可能会导致用户会话冲突，以及数据状态不一致等问题。在这一章，我们将深入探讨重复登录问题的产生，并介绍几种实现防止重复登录的策略。

4.1 重复登录问题的产生

4.1.1 重复登录的危害分析

重复登录问题的危害主要体现在两个方面：

• 会话冲突 ：在Web应用中，用户的每一次请求都会携带一个唯一的会话标识（如session ID）。如果用户在未退出的情况下重新登录，系统会创建一个新的会话。这将导致两个会话同时存在，可能会引起用户的操作互相干扰，甚至数据操作的冲突。
• 安全风险 ：恶意用户可以利用重复登录问题，通过打开多个浏览器窗口或标签页，不断尝试登录，以此来对系统进行攻击，消耗系统资源，甚至可能对系统安全性造成严重威胁。

4.1.2 防止重复登录的重要性

在构建Web应用时，实现防止重复登录机制至关重要，它可以有效保障应用的会话安全，维护用户数据的一致性和安全性。具体表现在：

• 保障用户数据一致性 ：防止用户在不同会话中的操作产生冲突，确保用户数据操作的准确性和一致性。
• 提升系统安全性 ：减少重复登录带来的安全隐患，通过限制同一用户在不同会话中的登录尝试，增加系统的安全防护层。

4.2 实现防止重复登录的策略

4.2.1 会话跟踪机制

会话跟踪机制是防止重复登录的基础，它能够追踪用户在系统中的活动状态。在Web应用中，实现会话跟踪的常见方法有：

• 基于Cookie ：通过在客户端存储一个唯一的session ID，服务器端通过解析Cookie来识别用户的会话。
• 基于URL重写 ：在每次请求的URL后面附加session ID，服务器端通过读取URL参数来识别用户会话。

4.2.2 基于拦截器实现登录验证

为了防止用户重复登录，可以采用拦截器来检测用户的登录状态。具体步骤包括：

• 创建拦截器类 ：创建一个实现了 com.opensymphony.xwork2.interceptor.Interceptor 接口的拦截器类。

• 编写拦截逻辑 ：在拦截器的 intercept 方法中，检查当前请求的用户是否已经在会话中。如果已经存在登录会话，则返回错误信息或者重定向到登录页面。

• 配置拦截器 ：在 struts.xml 文件中定义拦截器，并在相应的action中引用拦截器，以确保每次请求都会经过拦截器的检查。

以下是一个简单的自定义拦截器示例：

<action name="login" class="com.example.LoginAction">
    <interceptor-ref name="defaultStack"/>
    <interceptor-ref name="myCustomLoginInterceptor"/>
    <result name="success">/main.jsp</result>
</action>

public class MyCustomLoginInterceptor implements Interceptor {
    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        // 检查用户登录状态
        if (isUserLoggedIn(invocation)) {
            // 如果用户已登录，则返回错误信息
            return "userAlreadyLoggedIn";
        }
        // 否则，继续执行action
        return invocation.invoke();
    }
}

4.3 应用Token机制

4.3.1 Token机制的原理

Token机制是一种广泛应用于防止重复提交和防止重复登录的技术。Token可以理解为一种令牌或者密钥，它在用户认证之后生成，并在后续的每次请求中携带，以验证用户身份。

Token机制的基本原理包括：

• 安全性 ：Token通常包含随机数、时间戳和签名，可以有效防止伪造和重放攻击。
• 无状态性 ：Token的生成、验证不需要在服务端保存状态信息，减轻了服务器的压力，提高了系统的可扩展性。

4.3.2 Token在防止重复登录中的应用

在防止重复登录的场景中，Token机制可以这样应用：

• 登录时生成Token ：用户登录成功后，生成一个Token并返回给客户端，同时在服务端的缓存中记录该Token与用户会话的关联信息。

• 每次请求携带Token ：在用户的后续请求中，携带之前生成的Token，并在服务器端进行验证。

• Token验证 ：服务器端接收到请求后，首先验证Token的有效性，如果Token有效且没有过期，则继续处理请求；如果Token无效或已过期，则认为是重复登录尝试，返回错误或拒绝请求。

Token机制能有效解决重复登录问题，并且对于前后端分离的应用架构尤为重要，可以有效提升系统的安全性和用户体验。在实际应用中，Token机制还可以与HTTP Header结合，通过 Authorization 字段传递Token，从而在不破坏RESTful架构原则的同时实现安全验证。

// Token生成示例代码
public String generateToken() {
    String token = UUID.randomUUID().toString();
    // 可以将token和用户会话信息关联起来，并记录到缓存中
    cache.put(token, userSessionInfo);
    return token;
}

// Token验证示例代码
public boolean validateToken(String token) {
    // 从缓存中查找Token对应的会话信息
    UserSessionInfo info = cache.get(token);
    if (info != null && !isTokenExpired(info.getTimestamp())) {
        // Token有效，返回true
        return true;
    }
    // Token无效或已过期，返回false
    return false;
}

本章节通过分析重复登录问题的产生及其危害，介绍了会话跟踪和基于拦截器的登录验证机制，以及Token机制的原理及其应用。这些方法能够有效帮助开发者构建安全可靠的Web应用。在实际开发过程中，应根据不同的应用场景和需求，选择合适的防止重复登录策略。

5. Token机制防刷新技术

5.1 页面刷新导致的问题

5.1.1 刷新引起的数据重复提交问题

当用户在Web应用中执行某个操作，例如填写表单并提交后，点击浏览器的刷新按钮，页面会重新加载。这会导致用户之前已经提交的数据被重复提交，可能会引起数据处理错误或数据冗余。例如，在一个电商网站上，用户提交了订单，如果页面刷新，可能会导致同一订单被重复下单。

5.1.2 刷新对系统安全的影响

除了数据重复提交外，页面刷新还可能对系统的安全性造成威胁。如果Web应用没有妥善处理，恶意用户可能会通过刷新页面不断尝试提交数据或捕获敏感信息，甚至利用漏洞发起攻击。因此，防止通过刷新页面发起的重复攻击，是Web开发中一个重要的安全考虑。

5.2 Token机制的原理与实现

5.2.1 Token在Web应用中的作用

Token机制通常被用于Web应用中防止恶意用户通过刷新页面发起的重复请求。Token可以理解为一个访问令牌，它由服务器生成后发送给客户端。客户端在每次请求时都需要携带这个Token，服务器通过验证Token来确定请求的合法性。Token机制能够有效防止CSRF（Cross-Site Request Forgery，跨站请求伪造）攻击。

5.2.2 利用Struts2实现Token机制

在Struts2框架中，可以通过拦截器和过滤器来实现Token机制。一个常见的做法是在用户进行操作前，在服务器端生成一个Token，并将其存储在用户的会话（Session）中。同时，将这个Token作为隐藏字段嵌入到表单中。当用户提交表单时，Token会随请求一起发送到服务器。服务器接收到请求后，再对Token进行验证。

以下是一个简单的Token验证拦截器示例代码：

public class TokenInterceptor extends AbstractInterceptor {

    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        String token = (String) invocation.getInvocationContext().getSession().get("token");
        Map<String, Object> params = invocation.getInvocationContext().getParameters();
        String requestToken = (String) params.get("token");

        if (token == null || !token.equals(requestToken)) {
            return "invalid.token";
        }

        return invocation.invoke();
    }
}

在上面的代码中，拦截器首先尝试从会话中获取Token，然后从请求参数中获取传入的Token，最后将两者进行比较。如果Token不匹配，返回一个错误页面，否则继续执行Action调用。

5.3 集成Token机制的防刷新实践

5.3.1 Token在Struts2中的配置与使用

要集成Token机制，首先需要在Struts2中配置拦截器，并在Struts2的配置文件中声明Token拦截器。这里可以创建一个Token验证拦截器，并在 struts.xml 中进行如下配置：

<interceptors>
    <interceptor name="token" class="com.example.interceptor.TokenInterceptor"/>
    <interceptor-stack name="tokenStack">
        <interceptor-ref name="defaultStack"/>
        <interceptor-ref name="token"/>
    </interceptor-stack>
</interceptors>

<action name="myAction" class="com.example.action.MyAction">
    <interceptor-ref name="tokenStack"/>
    <result name="success">/success.jsp</result>
    <result name="invalid.token">/error.jsp</result>
</action>

在上面的配置中，我们定义了一个名为 token 的拦截器，并将其加入到拦截器栈 tokenStack 中。然后，在 myAction 的执行流程中引用了 tokenStack ，确保每次请求都会经过Token验证。

5.3.2 避免Token机制带来的用户体验问题

虽然Token机制可以有效防止恶意请求，但如果使用不当，也可能影响用户体验。例如，如果Token没有在用户会话结束时移除，那么用户在会话结束后仍然可以提交表单，造成Token验证失败。为了避免这种情况，应该在用户退出登录或会话超时时清除会话中的Token。

此外，在用户执行操作时，如填写表单，Token机制可能会导致用户在操作过程中意外刷新页面而引发的错误提示，影响用户的操作流程。解决这个问题，可以通过在客户端使用JavaScript技术预先检测刷新操作，并在必要时给出提示。

以上就是Token机制在防止页面刷新导致的数据重复提交和安全问题中的应用。正确地实现和集成Token机制，可以有效提高Web应用的安全性和健壮性。

6. myEclipse与Struts2的集成

6.1 myEclipse集成Struts2的优势

6.1.1 myEclipse作为开发工具的特点

myEclipse是Eclipse的一个商业版本，提供了大量的插件来丰富Eclipse的功能。myEclipse为开发者提供了更加便捷和高效的开发体验。它特别针对Java EE开发提供了完善的支持，包含了一系列的工具用于开发、调试和部署复杂的应用程序。其内置的Struts2框架插件，可以加速开发流程，减少了重复配置的需要，从而让开发者可以更专注于业务逻辑的实现。

6.1.2 myEclipse对Struts2项目的支持

myEclipse集成了对Struts2框架的深层支持。这包括但不限于： - Struts2项目的快速搭建 ：利用向导，可以一键生成Struts2项目的基础结构和配置文件。 - 视图层代码的生成 ：对于Struts2的Action和Result配置，myEclipse可以自动生成大量样板代码，减少编码的工作量。 - 图形化的Struts2配置编辑 ：在myEclipse中，可以图形化地编辑struts.xml配置文件，这不仅使得配置更加直观，也更容易维护和调试。

6.2 myEclipse中Struts2项目的搭建

6.2.1 新建Struts2项目

新建Struts2项目的步骤在myEclipse中被简化，可以通过向导快速完成。以下是详细步骤： 1. 打开myEclipse，选择“File” > “New” > “Web Project”。 2. 在弹出的向导窗口中，填写项目的名称和基本配置，然后勾选“Struts2”框架选项。 3. 按照向导提示完成项目结构的创建，myEclipse会自动配置好项目依赖和基本的Struts2框架结构。

6.2.2 配置Struts2环境

配置Struts2环境是项目运行前的重要步骤。在myEclipse中，这包括： 1. 设置struts.xml文件 ：确保struts.xml文件被添加到项目的正确位置，并且包含必要的Action映射。 2. 添加依赖库 ：将Struts2框架所需的jar包添加到项目的类路径中，这通常可以通过myEclipse的构建路径配置完成。 3. 配置web.xml ：将Struts2的监听器和过滤器配置添加到web.xml文件中，这一步myEclipse同样可以自动生成必要的代码。 4. 启动服务器运行项目 ：配置完成之后，通过myEclipse内置的服务器（如Tomcat）运行项目进行测试。

6.3 myEclipse对Struts2开发的便利性

6.3.1 视图层代码的快速生成

myEclipse可以快速生成Struts2项目的视图层代码。例如，创建ActionForm和JSP页面可以通过点击菜单项或使用快捷键轻松完成。myEclipse的代码生成器还允许开发者自定义生成代码的模板，以符合特定的编码规范或个人偏好。

6.3.2 struts.xml文件的图形化编辑

struts.xml是Struts2框架的核心配置文件，编辑它对项目的运行至关重要。在myEclipse中，可以通过图形化的编辑器来进行配置，它提供了一个可视化的界面，允许开发者通过拖放组件来管理Action映射和拦截器配置。myEclipse会自动验证配置文件的正确性，并在出错时提供提示，这大大减少了配置错误的可能性。

6.3.3 开发者的高效调试环境

除了代码的快速生成和配置文件的图形化编辑外，myEclipse还提供了强大的调试工具，这些工具可以帮助开发者快速定位和解决代码中的问题。myEclipse的调试环境支持断点、步进、变量观察等多种调试方法，提高了开发效率，缩短了开发周期。

6.3.4 优化的代码编写体验

myEclipse针对Struts2框架进行了优化，包括自动补全、代码提示和实时错误检测等功能。开发者在编写代码时可以得到即时的反馈，比如输入代码后，myEclipse会弹出提示来显示可用的Action方法和参数，这使得编码过程更加流畅和高效。

// 示例代码：Struts2 Action类
public class ExampleAction extends ActionSupport {
    private String message;

    public String getMessage() {
        return message;
    }

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

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

在上述代码块中，我们创建了一个名为 ExampleAction 的Struts2 Action类，它继承自 ActionSupport 基类，并包含了 execute 方法。 setters 和 getters 方法对于在JSP页面中访问和修改这些属性是必需的。myEclipse可以为这样的Action类自动生成模板代码，极大地方便了开发者的编码工作。

<!-- 示例代码：struts.xml配置 -->
<struts>
    <package name="default" extends="struts-default">
        <action name="exampleAction" class="com.example.ExampleAction">
            <result name="success">/success.jsp</result>
        </action>
    </package>
</struts>

在配置文件 struts.xml 中，我们定义了 exampleAction 与 ExampleAction 类的映射关系，并指定了执行成功时返回的页面。myEclipse内置的编辑器可以图形化地完成这样的配置，使得开发者能够直观地看到配置项之间的关系。

在上述章节中，我们详细介绍了myEclipse与Struts2集成的优势、项目搭建步骤、开发便利性及具体操作实践，展示了myEclipse如何简化和加速Struts2项目的开发。从项目搭建到代码编写，再到配置文件的管理，myEclipse提供了一系列的工具和服务，不仅提高了开发效率，而且保证了项目质量。通过这些集成工具，开发人员可以更专注于业务逻辑的实现，而不是框架的配置和管理。

7. Action与Result的交互

Action作为Struts2框架中的核心组件，主要负责处理用户的请求逻辑。而Result则决定了用户请求处理完毕后页面的响应行为，如页面跳转、数据展示等。了解Action与Result的交互机制，对于开发动态交互式Web应用程序至关重要。

7.1 Action与Result的概念

7.1.1 Action的角色和作用

在Struts2框架中，Action扮演了控制层的角色，连接视图（View）和模型（Model），负责接收用户的输入，处理业务逻辑，并返回操作结果。Action可以看作是一个容器，它可以包含多个业务方法，每个方法对应一个业务操作。

Action的类通常继承自 ActionSupport 类，这个基类提供了许多便利的方法，如数据校验、国际化消息等。当Action类的某个方法被调用时，Struts2框架会自动进行依赖注入，将值栈中的数据设置到Action类的属性中。

7.1.2 Result的作用和类型

Result是Action执行完毕后返回的结果，它定义了Action执行成功或失败后跳转的视图资源。Struts2框架提供了多种类型的Result，常见的包括： - dispatcher : 服务器端转发到指定的视图资源。 - redirect : 重定向到一个指定的URL地址。 - chain : 启动一个新的Action链。 - stream : 将二进制数据流发送到客户端。

不同的Result类型提供了灵活的页面跳转和数据传输方式，开发者可以根据具体需求选择合适的Result类型。

7.2 实现Action与Result的交互

7.2.1 Action的创建和配置

在Struts2框架中创建Action的基本步骤如下：

1. 创建一个Action类，继承自 ActionSupport 或实现 Action 接口。
2. 实现Action类的方法，每个方法对应一个业务操作。
3. 在 struts.xml 中配置Action映射。

下面是一个简单的Action类示例：

public class MyAction extends ActionSupport {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String execute() {
        // 业务逻辑处理
        return SUCCESS;
    }
}

接着，在 struts.xml 中进行配置：

<action name="myAction" class="com.example.MyAction">
    <result name="success">/success.jsp</result>
</action>

7.2.2 Result的配置与使用

根据Action方法执行的结果，返回不同的Result，从而实现页面跳转或数据展示。例如：

<action name="myAction" class="com.example.MyAction">
    <result name="success" type="dispatcher">/success.jsp</result>
    <result name="input">/input.jsp</result>
</action>

在Action方法中，可以根据业务逻辑执行的结果返回不同的字符串，如 SUCCESS 、 INPUT 等。根据返回值，Struts2会自动选择对应的Result进行处理。

7.3 常用Result类型的应用实例

7.3.1 页面转发与重定向

页面转发和重定向是Web应用中常用的两种页面跳转方式。

• 页面转发（dispatcher）：在服务器端进行，浏览器地址栏不变。配置如下：

<result name="forward" type="dispatcher">/page.jsp</result>

• 页面重定向（redirect）：在客户端进行，浏览器地址栏改变。配置如下：

<result name="redirect" type="redirect">***</result>

7.3.2 动态返回结果的应用

动态返回结果允许开发者根据Action方法中的逻辑动态选择返回哪个视图或资源。例如，在一个订单处理系统中：

public String processOrder() {
    boolean success = processTheOrder();
    if (success) {
        return SUCCESS;
    } else {
        return ERROR;
    }
}

根据订单处理的结果，用户将被跳转到成功页面或错误页面：

<action name="processOrder" class="com.example.OrderAction">
    <result name="success">/order_success.jsp</result>
    <result name="error">/order_error.jsp</result>
</action>

通过动态Result的应用，我们能够灵活地控制用户界面的响应，提高用户体验，同时保持代码的可维护性和可扩展性。

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

简介：Struts2是一个基于MVC模式的Java Web应用框架，本实例将深入探讨其核心特性如拦截器、国际化支持、重复登录防范、Token机制，以及与myEclipse集成、Action/Result、配置文件(struts.xml)和JSP视图技术的使用。通过实践这些关键知识点，开发者将提升在构建和维护Java Web应用方面的能力。

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