深入理解Struts框架：mystruts实践与应用

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

简介：Struts是Apache软件基金会的Jakarta项目下的一款开源框架，专注于构建基于Java的企业级Web应用程序。Struts 1.3.10是该框架的一个较旧版本，含有更新和安全修复。主要知识点包括MVC模式、ActionServlet、ActionForm、Action类、ActionMapping、Tiles扩展、Struts标签库、国际化与本地化处理、异常处理以及安全性。学习和应用"mystruts"时，需要掌握这些概念，并了解如何在项目中进行配置和使用。尽管Struts 1已不再维护，其历史和原理的理解仍有助于把握现代MVC框架设计。

1. Struts框架概述

在信息技术高速发展的今天，Struts框架作为Java EE应用中不可或缺的一部分，长久以来支撑着企业级应用的构建和部署。本章将从宏观的角度出发，对Struts框架进行简单介绍，为之后的深入讨论打下基础。

1.1 Struts框架的起源与发展

Struts框架最初是由Craig McClanahan创建，并在2001年被捐献给Apache软件基金会。它基于经典的MVC（Model-View-Controller）设计模式，旨在简化Java Web应用程序的开发。自从推出以来，Struts经历了多个版本的迭代，每个版本都在提升性能和增加新特性的同时，也不断改进着安全性和易用性。

1.2 Struts框架的核心价值

Struts的核心价值在于其提供了基于Web应用开发的高级抽象，允许开发者集中精力在业务逻辑的实现上，而不是底层的HTTP请求和响应处理。通过使用Struts，开发者可以方便地将用户界面（View）与业务逻辑（Model）分离，利用XML配置文件来管理应用的流程控制（Controller），从而加快开发速度，提升软件质量。

1.3 Struts框架的适用场景

Struts适合于开发各种Web应用，特别是那些需要高度定制化和处理复杂业务逻辑的中大型企业应用。它通过组件化的方式促进了代码的复用，同时也支持插件系统，允许开发者根据需求扩展框架功能。然而，在选择使用Struts时，也应当考虑到它的某些局限性，例如与新兴技术的融合可能不如其它更现代的框架那样迅速。

通过本章的介绍，我们对Struts有了初步的了解。接下来的章节将深入探讨Struts的特性和应用，帮助读者更好地掌握这个强大的Web应用框架。

2. Struts 1.3.10版本特性详解

2.1 核心组件的更新

2.1.1 ActionServlet的新特性

ActionServlet作为Struts框架中的核心控制器组件，其在Struts 1.3.10版本中得到了一些改进。新特性包括更高效的请求处理流程、线程安全的特性以及更好的资源管理。

在资源管理方面，ActionServlet的配置变得更灵活。开发者可以配置多个资源包以支持不同的语言环境，这对于国际化和本地化支持尤为重要。此外，与早期版本相比，ActionServlet在处理请求时减少了对象的创建，改进了性能。

从线程安全的角度看，ActionServlet在处理并发请求时，能够保证数据的一致性。当多个请求并发访问同一个Action实例时，ActionServlet通过同步机制保护了共享资源，避免了线程安全问题。

代码块展示一个简化的ActionServlet配置：

<servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
    <init-param>
        <param-name>config</param-name>
        <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>
    <init-param>
        <param-name>detail</param-name>
        <param-value>2</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

2.1.2 ActionForm的改进点

ActionForm是Struts框架中用于收集请求数据的组件。在Struts 1.3.10中，ActionForm进行了改进，提高了数据封装和验证的效率。

新的ActionForm实现了更智能的数据验证机制，能够自动识别字段类型并应用相应的验证规则。这减少了开发人员编写验证逻辑的工作量，并提高了验证的准确性。例如，对于字符串类型的字段，如果长度超出限制，Struts将自动执行长度验证。

另外，ActionForm增加了对属性变更的监听支持，这使得它能够更灵活地与数据模型交互。当表单字段的值发生变化时，可以通过监听器来执行一些额外的逻辑，例如触发其他字段的自动填充或者触发某个业务逻辑。

下面是一个ActionForm的简单示例：

public class LoginForm extends ActionForm {
    private String username;
    private String password;

    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}

2.2 新增功能与改进

2.2.1 插件支持的增强

Struts框架的插件机制允许开发者扩展框架的功能。在Struts 1.3.10版本中，对插件的支持进行了增强，使得插件之间的集成更加平滑。

新增的插件管理器允许开发者通过配置文件来管理插件的加载顺序和依赖关系。这种机制提高了插件系统的可维护性和可扩展性。同时，框架也引入了更丰富的钩子（Hook）点，让插件能够在特定的生命周期事件中插入自定义行为。

下面是一个插件配置的示例：

<struts-config>
    <plug-in className="org.example.MyPlugin"/>
</struts-config>

2.2.2 验证框架的优化

Struts的验证框架在1.3.10版本中得到了优化，使得验证过程更加模块化和灵活。新的验证框架支持注解和XML两种配置方式，开发者可以根据喜好选择。

通过注解方式，开发者可以在ActionForm的字段上直接使用标注来定义验证规则，这样可以将验证逻辑更紧密地与业务模型绑定。而XML配置方式则允许更为复杂的验证场景，如跨字段验证。

验证规则的XML配置示例：

<validators>
    <field property="username" depends="required">
        <arg0 key="error.required" />
    </field>
    <field property="password" depends="required,mask">
        <arg0 key="error.required" />
        <arg1 value="^[a-zA-Z0-9]*$" />
    </field>
</validators>

2.3 兼容性与迁移指导

2.3.1 与Struts 1.2.x版本的兼容性问题

Struts 1.3.10版本在向后兼容方面做了很多工作，但由于新增了某些特性和改进，与Struts 1.2.x版本存在一些兼容性问题。开发者在迁移过程中需要注意这些差异，并根据实际情况进行适配。

兼容性问题主要涉及到API的变动、配置文件格式的变化以及插件机制的调整。比如，一些老旧的API可能已经被废弃，或者接口的签名发生了改变，这需要开发者在迁移代码时进行相应的修改。

为了平滑迁移，Struts项目提供了兼容性模式（compatibility mode），允许开发者在一定范围内选择旧版本的实现细节。但长期看，建议开发者按照新版本的规范重构代码，以充分利用新版本的优势。

2.3.2 迁移策略和步骤

迁移至Struts 1.3.10版本需要仔细规划和测试。建议的迁移策略包括：

1. 评估现有项目 ：检查现有项目中使用到的Struts组件和API，确定可能受影响的部分。
2. 更新配置文件 ：根据Struts 1.3.10的新特性，更新web.xml和struts-config.xml配置文件。
3. 重构代码 ：逐步重构项目代码，替换掉已经废弃的API和方法。
4. 测试 ：对每个迁移后的组件进行单元测试和集成测试，确保功能的正确性。
5. 文档更新 ：更新项目文档，记录迁移过程中所做的改动。

迁移过程的步骤可以详细到具体的文件或模块，例如先从迁移web.xml开始，然后是struts-config.xml的配置文件，最后是ActionForm和Action类的重构。针对每个步骤，都要进行充分的单元测试，确保迁移后的代码与原有功能等价。

下面是一个迁移后的struts-config.xml文件示例：

<struts-config>
    <action-mappings>
        <action path="/login"
                type="com.example.LoginAction"
                name="loginForm"
                scope="request"
                validate="true"
                input="/login.jsp">
            <forward name="success" path="/welcome.jsp"/>
        </action>
    </action-mappings>
</struts-config>

这个文件展示了升级后的配置方式，其中 validate="true" 属性是新增的，用于启用ActionForm的自动验证功能。

3. 深入理解MVC设计模式

3.1 MVC设计模式基础

3.1.1 MVC模式的定义与组成

MVC（Model-View-Controller）模式是软件架构中的一种设计模式，旨在将数据模型（Model）、视图（View）和控制器（Controller）分离，以实现程序结构的分层与解耦。这种模式最初由Trygve Reenskaug在1978年提出，并广泛应用于图形用户界面（GUI）开发中。

• Model（模型） ：负责数据和业务逻辑的处理。模型代表应用程序的数据结构，以及对这些数据的操作。
• View（视图） ：负责数据的展示，视图是用户在屏幕上看到并与之交互的界面。
• Controller（控制器） ：作为模型和视图之间的协调者，接收用户的输入并调用模型和视图去完成用户的请求。

3.1.2 各组件的作用与协同工作

在MVC模式中，三个组件各自承担不同的角色，同时又相互协作，共同完成用户请求的处理过程。

• 用户交互 ：用户通过视图（View）进行交互，触发事件（如按钮点击）。
• 事件分派 ：控制器（Controller）接收到事件，并决定如何处理，可能涉及更新模型（Model）或视图（View）。
• 数据处理 ：模型（Model）负责数据的处理和业务逻辑的实现。
• 视图更新 ：如果需要更新用户界面，控制器会通知视图进行更新，展示新的或更新后的数据。

协同工作的流程如下：

1. 用户操作视图，产生事件。
2. 控制器响应事件，并请求模型进行业务处理。
3. 模型更新数据，执行业务逻辑。
4. 模型通知控制器数据已更新。
5. 控制器根据业务逻辑决定是否需要更新视图。
6. 视图更新以反映模型中数据的变化。

3.2 MVC在Struts中的应用实例

3.2.1 实例分析：用户登录功能

在Struts框架中，MVC模式的应用非常典型。以用户登录功能为例，我们可以看到Struts是如何利用MVC模式来组织代码和处理请求的。

• Model（模型） ：在Struts应用中，模型通常由Action类或Java Bean来实现，这些组件封装了业务逻辑和数据访问。例如，用户登录的验证逻辑就在一个Action类中实现。
• View（视图） ：视图是由JSP页面来实现的，在用户登录的场景中，就是登录表单的HTML页面。
• Controller（控制器） ：Struts的控制器是ActionServlet，它负责接收用户的请求，并根据配置文件struts-config.xml中的定义，将请求分发给相应的Action对象处理。

3.2.2 模块划分与代码组织策略

在实现具体功能时，遵循MVC模式的指导原则，可以有效地组织代码，提高可维护性。

• Model ：将业务逻辑和数据访问代码放在单独的包（Package）中，例如 com.example.model 。
• View ：将视图相关的JSP文件放在Web应用的目录下，如 /WebContent/login.jsp 。
• Controller ：将控制器相关的代码，如Action类和相关的配置文件，放在 com.example.action 包中。

通过模块化分工，开发人员可以更清晰地理解和管理项目结构，同时便于团队协作和后期的维护。

在本小节中，我们通过分析用户登录功能来理解MVC在Struts中的应用。请在实际开发中，根据具体的业务需求和设计，灵活应用MVC原则，组织代码结构。

4. Struts核心组件与实践应用

4.1 ActionServlet核心组件解析

4.1.1 Servlet的生命周期与工作流程

Struts框架的中心是ActionServlet，它继承自javax.servlet.http.HttpServlet，并充当Struts控制器的角色。了解ActionServlet的生命周期对于理解整个Struts工作流程至关重要。

生命周期阶段： 1. 初始化：在Servlet容器启动或第一次接收到请求时，Servlet容器会加载Servlet并调用init()方法。 2. 处理请求：对于每个客户端请求，Servlet容器都会调用service()方法。 3. 处理用户特定请求：service()方法会根据请求类型调用doGet()、doPost()等方法。 4. 销毁：当Servlet容器关闭或服务器停止时，会调用destroy()方法。

工作流程： 1. 用户发送请求至服务器。 2. 请求到达ActionServlet，它通过配置文件找到对应的Action类。 3. ActionServlet调用Action类的execute()方法，执行业务逻辑。 4. Action类根据执行结果，返回一个ActionForward对象，它指明了下一个处理组件或者JSP页面。 5. ActionServlet根据返回的ActionForward对象将请求转发到相应的组件。 6. 最终，用户看到执行结果，比如页面更新或数据提交成功。

代码块分析：

public class MyActionServlet extends ActionServlet {
    public void init() throws ServletException {
        // 配置文件加载与初始化操作
        super.init();
        // 可以添加自定义的初始化代码
    }
    protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        super.service(request, response);
    }
    protected ActionForward performAction(HttpServletRequest request,
            HttpServletResponse response, ActionMapping mapping)
            throws IOException, ServletException {
        // 实际调用的业务逻辑处理方法
        ActionForward forward = super.performAction(request, response, mapping);
        return forward;
    }
}

参数说明： - init() 方法用于初始化ActionServlet，读取配置文件等。 - service() 方法处理用户请求。 - performAction() 方法执行实际的业务逻辑，并返回跳转信息。

4.1.2 配置文件解析与初始化过程

Struts框架通过配置文件（struts-config.xml）来配置ActionServlet和其他组件。初始化过程包括加载并解析这些配置文件，以确定框架如何处理特定类型的请求。

解析配置文件的步骤： 1. 首先，ActionServlet在初始化时查找并加载struts-config.xml文件。 2. 该文件中定义了Action类、ActionForm类、JSP页面以及它们之间的映射关系。 3. 配置文件被解析，各个组件被实例化和初始化。 4. 当请求到来时，Struts使用这些配置信息来定位对应的Action类。

代码块分析：

<struts-config>
    <form-beans>
        <form-bean name="loginForm" type="com.example.LoginForm"/>
    </form-beans>
    <action-mappings>
        <action path="/login" type="com.example.LoginAction" name="loginForm"
            scope="request" validate="true" input="/login.jsp">
            <forward name="success" path="/welcome.jsp"/>
        </action>
    </action-mappings>
</struts-config>

在这个配置文件示例中：

• <form-beans> 节点定义了表单bean的类型。
• <action-mappings> 节点定义了请求路径和对应的Action类。
• <forward> 子节点定义了在特定条件下要跳转的目标页面。

4.2 ActionForm与用户交互的实践技巧

4.2.1 FormBean的创建与配置

FormBean在Struts框架中扮演数据封装的角色，通常是与JSP表单元素对应的JavaBean。FormBean的实例化和数据绑定过程是用户交互的核心环节。

创建FormBean的步骤：

1. 定义FormBean类： 创建一个Java类，添加属性以及对应的getter和setter方法。
2. 配置FormBean： 在struts-config.xml中定义FormBean。
3. 使用FormBean： 在JSP表单中使用name属性与FormBean的属性进行绑定。
4. 在Action中处理FormBean： Action类将接收FormBean的实例，并调用业务逻辑。

代码块分析：

public class LoginForm extends ActionForm {
    private String username;
    private String password;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    // validate() 方法用于执行表单验证逻辑
    public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) {
        ActionErrors errors = new ActionErrors();
        if (username == null || "".equals(username.trim())) {
            errors.add("username", new ActionMessage("error.username.empty"));
        }
        // 其他验证...
        return errors;
    }
}

参数说明： - username 和 password 是表单提交的字段。 - validate() 方法用于实现表单验证逻辑，返回ActionErrors对象时，表示存在验证错误。

4.2.2 数据封装与表单验证

当用户提交表单时，Struts框架会自动将表单数据封装到对应的FormBean实例中。接着，数据验证将决定数据是否可以用于业务逻辑处理。

数据封装过程：

1. 表单提交时，Struts使用表单字段的name属性来填充FormBean的相应属性。
2. 使用Java反射机制自动调用setter方法设置属性值。
3. 如果表单中未提供属性值，则该属性可能为null或空字符串。

表单验证流程：

1. 在FormBean类中实现validate()方法。
2. 在此方法中，编写检查逻辑，验证各个字段的数据有效性。
3. 验证失败时，向ActionErrors对象添加错误信息。
4. validate()方法返回ActionErrors对象。如果对象非空，Struts会将错误信息显示在页面上，并返回表单以便用户更正。

代码块分析：

public class LoginForm extends ActionForm {
    // ... (getter/setter methods)

    public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) {
        ActionErrors errors = new ActionErrors();
        if (username == null || "".equals(username.trim())) {
            errors.add("username", new ActionMessage("error.username.empty"));
        }
        // 可以添加其他字段的验证逻辑
        return errors;
    }
}

4.3 Action业务逻辑处理的高级应用

4.3.1 Action类的设计与实现

Action类是Struts框架的业务逻辑处理核心，负责执行与具体业务相关的操作，并决定请求应该被转发到哪个视图组件。

设计Action类的基本步骤：

1. 创建Action类： 实现Action接口或继承Action类。
2. 实现execute()方法： 执行业务逻辑，返回ActionForward对象。
3. 配置Action类： 在struts-config.xml中定义Action映射。
4. 处理异常和错误： 捕获和处理业务逻辑中可能出现的异常。

代码块分析：

public class LoginAction extends Action {
    public ActionForward execute(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response)
            throws Exception {
        LoginForm loginForm = (LoginForm) form;
        // 执行业务逻辑
        boolean isValidUser = authenticateUser(loginForm.getUsername(), loginForm.getPassword());

        if (isValidUser) {
            return mapping.findForward("success");
        } else {
            ActionErrors errors = new ActionErrors();
            errors.add("login", new ActionMessage("error.login.failed"));
            saveErrors(request, errors);
            return mapping.findForward("input");
        }
    }
}

参数说明： - execute() 方法返回ActionForward对象，指导请求转发。 - form 参数是ActionForm的实例，用于获取用户输入的数据。 - request 和 response 参数用于处理请求和响应。 - authenticateUser() 是示例方法，用于验证用户登录信息。 - saveErrors() 方法用于保存错误信息，以便在视图中显示。

4.3.2 业务逻辑的组织与事务管理

一个良好的业务逻辑层需要遵循高内聚、低耦合的原则。Struts框架中的Action类可能负责多个业务操作，因此合理组织这些操作是实现复杂业务的关键。

业务逻辑组织：

1. 划分业务逻辑单元： 将每个业务功能封装在单独的方法中。
2. 解耦合： 减少方法间的直接依赖。
3. 重用组件： 识别出可重用的业务逻辑，并将其抽象成组件。

事务管理：

1. 使用声明式事务： 利用如Spring框架的声明式事务管理来管理Action中的业务操作。
2. 注解方式： 使用如@Transactional注解来标识事务边界。
3. 保证数据一致性： 确保业务操作要么全部成功，要么在遇到异常时回滚。

代码块分析：

public class AccountService {
    // 假设这是账户相关的业务操作
    @Transactional
    public void transferFunds(Account fromAccount, Account toAccount, double amount) {
        // 执行转账操作的业务逻辑
        // 从fromAccount扣除金额
        // 向toAccount添加金额
        // 如果操作失败，抛出异常以回滚事务
    }
}

public class TransferAction extends Action {
    private AccountService accountService = new AccountService();
    public ActionForward execute(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response)
            throws Exception {
        // 获取表单数据，并调用业务服务
        // ...
        accountService.transferFunds(fromAccount, toAccount, amount);
        // ...
    }
}

在这里， AccountService 类提供了一个转账的服务，而 TransferAction 则是实际的业务逻辑调用点。通过 @Transactional 注解，整个转账操作被包裹在同一个事务中，确保操作的原子性。

通过本章节的介绍，我们深入了解了ActionServlet在Struts中的核心作用，包括它的生命周期、如何通过配置文件进行初始化。同时，我们探讨了ActionForm作为数据封装的角色以及如何进行表单验证。最后，我们学习了Action类的设计和实现，以及如何组织业务逻辑和事务管理。这些知识构成了Struts应用开发的核心部分，为理解后续章节奠定了坚实的基础。

5. Struts扩展机制与国际化支持

5.1 ActionMapping与URL映射策略

URL映射的基本概念与重要性

在Struts框架中，ActionMapping是用来描述请求和动作之间的映射关系的。开发者通过配置ActionMapping，可以控制哪些URL请求被转发到哪个Action类处理。一个清晰和良好的URL映射策略能够改善应用的可维护性，提高用户体验。理解ActionMapping的工作原理和配置方法，对于使用Struts进行Web应用开发至关重要。

映射规则与优先级处理

在ActionMapping的配置中，开发者可以为不同的请求指定不同的Action路径和名称。映射规则通常在 struts-config.xml 配置文件中定义，涉及到了请求的 <action-mappings> 部分，每个映射包括一个 <action> 标签，指定了请求路径（ path ）、请求处理类（ type ）、以及返回结果（ forward ）等信息。

<action path="/login"
        type="com.example.LoginAction"
        name="loginForm"
        scope="request"
        validate="true"
        input="/login.jsp">
    <forward name="success" path="/welcome.jsp"/>
    <forward name="failure" path="/login.jsp"/>
</action>

在上述例子中，路径为 /login 的请求会被映射到 com.example.LoginAction 类进行处理。如果验证成功且结果为 success ，则转发到 /welcome.jsp ；如果失败，则重定向回 /login.jsp 。

当有多个 <action> 标签匹配同一个请求时，Struts会根据优先级来决定使用哪个映射。在XML配置中，具体的优先级规则可能因为版本的不同而有所变化。在早期版本中，Struts会按照在 struts-config.xml 中出现的顺序来解析ActionMapping。

路径变量的使用与管理

Struts支持动态URL，即路径中可以包含变量。这些路径变量可以用来传递参数给Action，从而实现更加灵活的请求处理。路径变量通过 <action-mappings> 中的 <param> 标签定义，并在URL中使用花括号 {} 作为标识。

<action path="/user/{userId}"
        type="com.example.GetUserAction"
        name="userForm"
        scope="request">
    <forward name="success" path="/userDetails.jsp"/>
</action>

在上述配置中， {userId} 会被替换为具体的用户ID，并传递给 GetUserAction 类。Struts自动将这个路径变量注入到ActionForm中，开发者可以在Action类中通过 userForm.getUserId() 方法获取用户ID。

5.2 Tiles扩展与页面片段应用

页面片段的定义与布局控制

Struts通过Tiles插件来实现页面片段的定义和布局控制，这允许开发者创建可复用的页面组件，并通过配置文件将它们组装成完整的页面布局。Tiles插件的使用极大地提高了Web应用的可维护性，并使得页面的管理变得更加灵活。

<definition name="baseLayout" template="/WEB-INF/layouts/baseLayout.jsp">
    <put name="title" value="My Application"/>
    <put name="header" value="/WEB-INF/layouts/header.jsp"/>
    <put name="footer" value="/WEB-INF/layouts/footer.jsp"/>
</definition>

在上述例子中，定义了一个基础的布局 baseLayout ，它包含了标题（title）、头部（header）和底部（footer）三个部分。这些部分被定义为变量，在其他 Tiles 定义中可以通过 <put> 标签插入实际的JSP页面。

Tiles配置与应用实例

配置完页面片段后，就需要将它们组合到具体的页面中。这通常通过Struts的Action来完成，Action将相关的Tiles定义传递给结果页面。

<action path="/viewPage"
        type="com.example.ViewPageAction"
        name="pageForm"
        scope="request">
    <forward name="success" page="/WEB-INF/pages/viewPage.jsp" />
</action>

在Action类中，我们可以这样使用Tiles：

public class ViewPageAction extends Action {
    public ActionForward execute(ActionMapping mapping,
                                 ActionForm form,
                                 HttpServletRequest request,
                                 HttpServletResponse response) throws Exception {
        // 设置Tiles需要使用的参数
        ActionContext ctx = ActionContext.getContext();
        ctx.put("title", "View Page Title");
        return mapping.findForward("success");
    }
}

在 viewPage.jsp 中，可以这样引用Tiles定义：

<%@ taglib uri="/tags Tiles" prefix="tiles" %>
<tiles:insert template="/WEB-INF/layouts/baseLayout.jsp" />

这样， viewPage.jsp 就会被包含在 baseLayout.jsp 定义的布局中，并且可以通过Tiles定义引入的JSP片段渲染出最终页面。

5.3 国际化与本地化的实现方式

资源文件的使用与管理

国际化（Internationalization）和本地化（Localization）是使Web应用能够支持多语言和区域设置的关键技术。在Struts中，国际化主要通过属性文件（.properties）来实现，这些文件包含了对应语言的文本信息。

Struts允许开发者通过设置 <constant> 标签在 struts-config.xml 中指定资源文件的路径，并且可以为每种语言创建一个对应的属性文件。例如，为英语和中文分别创建 ApplicationResources_en.properties 和 ApplicationResources_zh.properties 。

用户界面的语言切换

用户界面的语言切换通常是通过Action来实现的。开发者可以创建一个Action，这个Action根据用户的语言选择加载对应的资源文件，并将它们设置到页面上下文中，从而实现语言切换。

public class ChangeLanguageAction extends Action {
    public ActionForward execute(ActionMapping mapping,
                                 ActionForm form,
                                 HttpServletRequest request,
                                 HttpServletResponse response) throws Exception {
        // 假设用户选择的语言保存在session中
        Locale locale = (Locale) request.getSession().getAttribute("userLocale");
        if (locale == null) {
            locale = new Locale("en", "US"); // 默认语言设置为英语
        }
        Locale.setDefault(locale);
        return mapping.findForward("success");
    }
}

然后在JSP页面中，可以使用Struts标签库来显示本地化后的文本：

<%@ taglib uri="/tags/struts-bean" prefix="bean" %>
<bean:resource bundle="ApplicationResources" key="welcome.message" />

以上代码会根据当前的Locale设置，从 ApplicationResources 资源文件中获取键为 welcome.message 的值，并显示在页面上。

通过这样的实现方式，Struts不仅简化了国际化和本地化的流程，还确保了Web应用能够灵活地支持多语言环境，增强了应用的可用性和用户体验。

6. Struts异常处理与安全性

Struts框架提供了全面的异常处理机制来帮助开发者更好地管理和响应应用程序中出现的错误情况。同时，安全机制的实施对于保持应用的稳定性和用户的信任至关重要。本章将深入探讨Struts的异常处理机制和安全性考虑，并与其它现代框架进行对比。

6.1 异常处理机制的深入剖析

异常处理是任何成熟框架不可或缺的一部分。Struts通过其核心组件Action类提供了异常处理机制。程序员可以在Action类中自定义异常处理逻辑。

6.1.1 异常捕获与记录

在Struts中，异常通常会在Action执行的处理方法中被捕获。开发者可以使用try-catch块来捕获和处理异常。

public ActionForward execute(ActionMapping mapping, ActionForm form,
                             HttpServletRequest request, HttpServletResponse response)
        throws Exception {
    try {
        // 正常的业务逻辑
    } catch (Exception e) {
        // 记录异常信息到日志文件
        logger.error("Error occurred during processing", e);
        // 将错误信息封装到request中供JSP页面展示
        request.setAttribute("errorMessage", "An error occurred, please try again later.");
        return mapping.findForward("error");
    }
}

6.1.2 自定义异常处理逻辑

开发者可以通过实现自定义的ExceptionResolver接口来定义如何处理异常。这种方式使得异常处理逻辑可以更加灵活和模块化。

public class MyExceptionResolver implements ExceptionResolver {
    public ActionForward resolveException(HttpServletRequest request, HttpServletResponse response,
                                          Object handler, Exception ex) {
        // 自定义异常处理逻辑
        return new ActionForward("/error.jsp");
    }
}

6.2 安全性考虑与实践

Web应用的安全性涉及到多个方面，Struts框架提供了各种工具来帮助开发者加强安全性。

6.2.1 输入验证与防止XSS攻击

Struts通过内置的验证框架来帮助开发者进行输入验证。这包括防止跨站脚本攻击（XSS）和SQL注入等。

<action name="login" class="LoginAction">
    <result name="input">/login.jsp</result>
    <result name="success" type="redirect">/welcome.jsp</result>
    <validation type="loginForm" />
</action>

6.2.2 权限控制与用户认证策略

为了实现权限控制和用户认证，Struts建议与Spring Security等安全框架结合使用。通过配置拦截器来限制对某些动作的访问。

<action-mappings>
    <action path="/admin/*" type="com.example.AdminAction" name="adminForm"
            validate="true" input="/adminLogin.jsp">
        <interceptor-ref name="defaultStack"/>
        <interceptor-ref name="security">
            <param name="excludeMethods">input,login</param>
        </interceptor-ref>
    </action>
</action-mappings>

6.3 Struts与其他现代框架的对比

Struts作为较早的MVC框架之一，为Java Web应用开发做出了重大贡献。然而，在与现代框架的对比中，Struts也暴露出了一些局限性。

6.3.1 Struts的局限性与改进

Struts框架在设计上相对较为老旧，处理性能以及对新兴技术的适应性不及一些现代框架。例如，它的配置文件繁琐且不易于维护，以及在异步请求处理上的局限。

6.3.2 Struts 1与Struts 2等框架的比较分析

Struts 2相较于Struts 1有诸多改进，包括更简洁的配置、强大的拦截器机制、支持RESTful架构等。同时，Struts 2与其他现代框架（如Spring MVC和JSF）相比，有其独特的优势和不足。

Struts的异常处理机制和安全性特性是其成熟的标志，但现代框架在这些方面往往有更好的表现。通过对比分析，开发者可以根据具体需求和项目环境选择合适的框架。

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

简介：Struts是Apache软件基金会的Jakarta项目下的一款开源框架，专注于构建基于Java的企业级Web应用程序。Struts 1.3.10是该框架的一个较旧版本，含有更新和安全修复。主要知识点包括MVC模式、ActionServlet、ActionForm、Action类、ActionMapping、Tiles扩展、Struts标签库、国际化与本地化处理、异常处理以及安全性。学习和应用"mystruts"时，需要掌握这些概念，并了解如何在项目中进行配置和使用。尽管Struts 1已不再维护，其历史和原理的理解仍有助于把握现代MVC框架设计。

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