Struts框架入门示例：Hello, World! 应用

无畏道人

于 2024-09-01 13:52:27 发布

阅读量1.1k

点赞数 22

本文链接：https://blog.csdn.net/weixin_36173034/article/details/141830873

版权

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

简介：Struts是一个用于构建Java Web应用程序的开源MVC框架。"struts_helloapp"很可能是一个基础的入门示例应用，用于教学或演示Struts框架的基本用法。这个示例应用可能包含一个简单的"Hello, World!"程序，包括Action类、配置文件、JSP页面、ActionForm以及必要的库文件。用户通过访问特定URL触发Action，然后显示"Hello, World!"消息。本应用是理解Struts工作原理以及MVC模式的一个良好起点。 Struts

1. Struts框架简介

在Web开发领域，Struts框架自诞生以来一直扮演着重要的角色。它是由Apache软件基金会发起并维护的一个开源项目，旨在简化MVC（Model-View-Controller）模式的实现，提高开发效率和系统的可维护性。Struts 2是这一系列框架的最新版本，它不仅吸收了传统Struts框架的优点，还融入了WebWork框架的优秀特性。

随着技术的发展，Struts 2框架在社区的支持下不断更新，提供了更加丰富的功能和更为灵活的配置选项。在深入探讨其MVC实现方式、配置细节、Action类设计之前，让我们先从整体上对Struts框架进行一个快速的了解。对于有一定IT背景的读者，Struts框架将使你能够快速构建动态Web应用，而对于经验丰富的开发者，深入理解Struts的运作机制将有助于优化你的应用性能，并解决实际开发中遇到的问题。接下来，我们将逐步深入Struts框架的世界，探索其在现代Web开发中的独特魅力。

2. MVC模式的Struts实现

2.1 MVC设计模式概述

2.1.1 MVC模式的基本概念

MVC（Model-View-Controller）模式是一种广泛应用于软件开发的架构模式，尤其是在Web开发领域。它将应用分为三个主要部分：

Model（模型） ：负责数据和业务逻辑的处理。它封装了应用程序的状态，同时提供数据访问的接口。
View（视图） ：负责展示数据。视图通常从模型中获取数据，以便在用户界面上展示。在Web应用中，它通常对应于JSP或HTML页面。
Controller（控制器） ：负责接收用户的输入，然后调用模型和视图去完成用户的请求。控制器处理用户输入，更新模型，并选择视图进行展示。

2.1.2 MVC模式在Web开发中的优势

在Web开发中，MVC模式为开发者提供了一个清晰的开发框架，使得他们能够将用户界面的表示、用户交互逻辑以及数据处理逻辑分离，这样带来的好处包括但不限于：

低耦合 ：各个组件之间的依赖性较低，便于分工合作，且易于修改和维护。
高重用性 ：模型和视图的组件可以被不同的控制器重用，模型中的业务逻辑也可在不同情境下复用。
更好的可测试性 ：可以单独对模型、视图和控制器进行测试，提高了代码的可靠性和质量。
更高的可维护性 ：由于组件的分离，使得代码更加模块化，维护和升级变得更加容易。

2.2 Struts框架与MVC模式

2.2.1 Struts框架的核心组件

Struts框架基于MVC设计模式，其核心组件主要包括：

Action类 ：它是控制器的角色，用于处理用户的请求，并调用模型完成业务逻辑处理。Action类通常会调用业务逻辑的组件或EJB，然后决定返回哪个视图。
ActionForm ：它是模型和视图之间的桥梁，用于封装用户提交的数据，并在视图和Action之间传递数据。
ActionMapping ：定义了请求与Action类之间的映射关系。
ActionForward ：定义了Action执行后，请求转发的目标资源（可以是另一个Action或JSP页面）。
配置文件（struts-config.xml） ：用于配置Struts应用的映射信息和处理逻辑。

2.2.2 MVC模式在Struts中的映射关系

在Struts框架中，MVC模式的具体映射关系如下：

Model ：在Struts中，Model通常由Action类和ActionForm组成。ActionForm用于封装和传递数据，而Action类则进行业务逻辑处理。
View ：在Struts中，视图主要通过JSP页面来实现，JSP页面负责展示数据和收集用户的输入。
Controller ：Struts的控制器逻辑主要通过Action类来实现，同时配置文件（struts-config.xml）定义了请求和Action的映射关系，以及请求如何流转。

Struts通过这些核心组件，实现了MVC设计模式，使得Web应用的开发更加规范和高效。Struts框架的组件之间通过预定义的接口和配置进行通信，这降低了组件间的耦合度，提高了代码的可维护性和可扩展性。

graph LR
A[用户请求] --> B[控制器:ActionServlet]
B --> C{ActionMapping}
C -->|匹配| D[Action]
C -->|不匹配| E[默认Action]
D --> F[Model:ActionForm]
F -->|数据处理| G[Model:业务逻辑]
G --> H[数据更新]
H --> I[返回ActionForward]
E --> I[返回ActionForward]
I --> J[视图:JSP页面]
J --> K[响应用户]

以上流程图展示了在Struts框架中，用户请求是如何通过控制器（ActionServlet）被分发到相应的Action处理，以及数据是如何在Model和View之间流转的。

3. Action类设计实现

3.1 Action类的角色与职责

3.1.1 Action类的基本结构

在Struts框架中，Action类是MVC模式中的Controller部分的主要实现，它负责处理用户的请求并返回相应的响应。Action类通常继承自 org.apache.struts.action.Action 类，并实现相应的 execute 方法，该方法是Action类的核心，负责接收请求、处理业务逻辑并返回结果。

下面是一个基本的Action类的结构示例：

package com.example.action;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

public class ExampleAction extends Action {
    public ActionForward execute(ActionMapping mapping, ActionForm form, 
                                 HttpServletRequest request, HttpServletResponse response)
            throws IOException, ServletException {
        // Action类的业务逻辑处理
        // ...
        // 根据业务逻辑处理结果，决定返回哪个结果页面
        return mapping.findForward("success");
    }
}

在上面的代码中， execute 方法接收四个参数： ActionMapping 对象用于获取配置信息， ActionForm 对象用于传递表单数据， HttpServletRequest 和 HttpServletResponse 对象分别用于获取请求信息和响应请求。

3.1.2 Action类的方法和执行流程

Action类的 execute 方法作为处理用户请求的入口点，其执行流程大致如下：

接收请求：通过 ActionMapping 对象获取映射配置，通过 ActionForm 对象获取用户通过表单提交的数据。
业务逻辑处理：根据业务需求进行相应的逻辑处理，这可能包括调用服务层组件、数据库操作等。
结果响应：根据业务逻辑处理的结果，选择一个结果页面并返回。可以通过 ActionForward 对象来实现。
状态管理：根据需要，Action类可能会管理应用的状态信息，这些信息可以在多个请求之间持久化。

在Struts2框架中，Action类的职责相对较为简化，因为Struts2支持直接在Action中进行数据校验和业务处理，而不需要额外的ActionForm。不过，这并不意味着Action类可以直接替代服务层组件，良好的设计原则仍然推荐保持业务逻辑在服务层处理，以保持Action类的简洁和易于测试。

3.2 Action类的生命周期管理

3.2.1 Action类的生命周期

Action类的生命周期与请求的生命周期紧密相连。在Struts框架中，并不存在传统意义上的“生命周期”，因为Action类不是单例的，每个请求都会创建一个新的Action实例。因此，管理Action类的生命周期主要是指控制Action类实例的创建和销毁时机。

在Struts1中，Action类是单例模式，需要通过特定的生命周期管理方法（如 init 和 destroy 方法）来进行初始化和销毁操作。而在Struts2中，每个请求都会创建一个新的Action实例，不需要显式地管理实例的生命周期，但是开发者需要注意不要在Action类中保存状态，因为这可能会导致状态不一致。

3.2.2 如何管理Action类的状态

尽管Action类不是单例，但在某些情况下，我们可能需要在Action类中处理会话（session）级别的状态信息。为了管理这些状态信息，Struts提供了几种方式：

使用 ActionContext 类来获取当前的请求范围和会话范围内的数据。
在Action类中声明属性，并通过Struts的值栈（ValueStack）与页面传递的数据进行绑定。
利用Struts的拦截器（Interceptor）机制来进行状态的管理，例如，可以创建一个拦截器来管理用户登录状态。

对于状态的管理，开发者应当遵循以下最佳实践：

避免在Action类中使用实例变量来存储状态，除非是会话级别的状态，因为每个请求都会创建一个新的Action实例。
利用 ActionContext 和值栈来与页面交互，而不是直接操作请求和响应对象。
如果确实需要在Action类中保持状态信息，请确保在适当的生命周期点（例如，动作执行完毕后）进行状态的清理。

3.2.3 实例代码解析与状态管理

下面提供一个简单的Action类示例，并展示如何在其中管理状态信息：

public class UserAction extends ActionSupport {
    private User user; // 用于在Action中保存用户信息的实例变量

    public String execute() {
        // 此处假设已经从服务层获取了用户信息，并将它赋值给了user变量
        // 这个user对象可以保存在session范围内，以便在多个请求之间共享
        return SUCCESS;
    }

    // 使用setter方法来设置user对象，以便于在Action中管理状态
    public void setUser(User user) {
        this.user = user;
    }

    public User getUser() {
        return user;
    }
}

在上面的示例中， UserAction 类中包含了一个 user 实例变量，该变量可以用于在多个请求之间保持用户状态。通过提供 setUser 和 getUser 方法，我们可以控制用户对象的设置和获取，以保持状态信息的一致性。

在实际应用中，开发者应该使用Struts提供的拦截器来处理更复杂的逻辑，例如用户认证和会话管理。这样可以将业务逻辑与状态管理分离，提高代码的可维护性和可测试性。

4. 配置文件使用(struts-config.xml)

4.1 配置文件的作用与结构

4.1.1 struts-config.xml的基本组成

在Struts框架中，配置文件 struts-config.xml 是整个应用的神经中枢。这个文件定义了Struts应用的许多关键部分，包括表单 bean、全局转发、action 映射以及消息资源。一个典型的 struts-config.xml 文件由以下几个部分组成：

form-beans : 定义与表单相关的JavaBean，用于封装表单提交的数据。
global-exceptions : 配置应用范围内的异常处理。
global-forwards : 配置全局的页面重定向路径，不依赖于具体动作（action）。
action-mappings : 定义action映射，配置如何响应用户请求。
message-resources : 引入资源文件，用于国际化支持。

下面是一个简化的 struts-config.xml 配置文件示例：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
        "***">
<struts-config>
    <form-beans>
        <form-bean name="userForm" type="com.example.UserForm"/>
    </form-beans>

    <global-forwards>
        <forward name="index" path="/index.jsp"/>
    </global-forwards>

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

    <message-resources parameter="com.example.messages.ApplicationResources"/>
</struts-config>

4.1.2 配置文件中的关键元素解析

form-bean : 描述了表单 bean 的具体配置，其中 name 属性指定了表单 bean 的名字， type 属性指定了表单 bean 的完整类名。
global-forwards : 定义了全局的转发规则，可以定义多个 forward 子元素，这样在多个地方可以重用这些转发路径。
action : 描述了如何将用户请求映射到相应的动作类（Action类），其中 path 属性定义了请求的URL模式， type 属性指定了处理请求的动作类， name 属性指定了对应的表单 bean 名字， scope 属性定义了动作实例的作用域， validate 属性指定是否执行验证， input 属性定义了如果验证失败应重定向的页面， <forward> 子元素定义了动作成功或失败后页面跳转的路径。

4.2 配置文件的高级应用

4.2.1 动态配置与国际化配置

动态配置

在实际开发中，动态配置是指在不重新部署应用的情况下，对配置文件进行更新。Struts框架允许开发者使用如下方式动态加载配置：

<struts-config>
    <!-- ... -->
    <action-mappings>
        <!-- 动态配置 -->
        <action path="/dynamicAction"
            type="com.example.DynamicAction" parameter="request">
            <!-- 动态参数传递 -->
            <set-property property="myProperty" value="dynamicValue" />
            <!-- ... -->
        </action>
    </action-mappings>
    <!-- ... -->
</struts-config>

使用 <set-property> 可以动态指定action的属性。

国际化配置

Struts支持国际化配置，可以通过定义消息资源文件来实现多语言支持。例如：

<struts-config>
    <!-- ... -->
    <message-resources parameter="com.example.messages.ApplicationResources"/>
    <!-- ... -->
</struts-config>

在 ApplicationResources.properties 中添加国际化消息：

login.page.title=Login Page
login.button.submit=Submit

在JSP文件中使用资源文件中的消息：

<h2><bean:write name="resources" key="login.page.title"/></h2>

4.2.2 配置文件与代码解耦的策略

为了实现解耦，可以采用以下策略：

使用常量定义 : 在配置文件中定义所有的常量，而不是在代码中直接使用硬编码的字符串。
使用Struts插件 : 利用Struts插件可以减少配置文件的复杂性，例如使用Struts2的Tiles插件来管理页面布局。
使用拦截器 : 通过定义拦截器来处理业务逻辑，减少Action类中的代码量，提高配置的灵活性。
模块化配置 : 将配置文件拆分为多个模块，每个模块处理一组相关的功能，有助于保持配置文件的清晰和可维护性。
通过继承与覆盖 : 使用Action类的继承机制，并通过覆盖继承来实现特定模块或用例的定制，避免重复配置。

下面是一个使用拦截器来处理请求的配置示例：

<struts-config>
    <!-- ... -->
    <action-mappings>
        <action path="/processRequest"
            type="com.example.ProcessRequestAction"
            name="requestForm">
            <interceptor-ref name="defaultStack"/>
            <interceptor-ref name="myInterceptorStack">
                <param name="myParam">someValue</param>
            </interceptor-ref>
            <forward name="success" path="/success.jsp"/>
        </action>
    </action-mappings>
    <!-- ... -->
</struts-config>

通过这样的策略和配置，可以显著提升Struts应用的可扩展性和可维护性。

5. JSP页面设计展示

5.1 JSP在Struts中的角色

5.1.1 JSP页面与Struts的交互方式

JSP（Java Server Pages）是Java EE技术中用于开发动态web页面的技术。在Struts框架中，JSP扮演着视图（View）的角色，负责与用户进行交互，并将用户的输入传递给业务逻辑层进行处理。Struts提供了一种声明式的机制，通过配置文件将JSP页面与业务逻辑层的Action类进行关联。

在Struts中，JSP页面通常会包含表单元素，这些元素对应于ActionForm中的属性。当用户提交表单时，数据会通过HTTP请求传递到后端的Action类。Action类处理完业务逻辑后，会将数据存储在值对象（Value Object）或模型（Model）中，并选择一个JSP页面作为响应返回给客户端，完成一次请求-响应周期。

5.1.2 JSP页面的设计原则

JSP页面设计时需遵循以下原则以确保良好的用户体验和系统性能：

MVC设计原则： 遵循模型-视图-控制器（MVC）设计模式，将业务逻辑、数据和显示分离，提高代码的可维护性和可扩展性。
最小化脚本编写： 尽量避免在JSP页面中编写Java代码，使用JSTL（JavaServer Pages Standard Tag Library）标签库和EL（Expression Language）表达式来减少脚本。
重用组件： 利用自定义标签或JSP片段来创建可重用的页面组件，避免页面内容的冗余。
避免硬编码： 不要在JSP页面中直接使用硬编码的字符串或URL，这些应通过配置文件管理，便于后续维护和国际化。
性能优化： 使用JSP的缓冲技术减少对服务器资源的消耗，对于频繁访问且内容不经常变化的页面片段，可以通过设置缓冲来提高访问速度。

5.2 JSP页面的动态数据展示

5.2.1 使用EL表达式和JSTL标签

EL（Expression Language）提供了一种简便的方式来访问存储在Java对象中的数据。在JSP页面中，可以通过EL表达式来展示动态数据。EL表达式通常与JSTL（JavaServer Pages Standard Tag Library）标签一起使用，以便更简洁地处理数据和实现流程控制。

一个典型的EL表达式看起来如下：

${user.name}

这个表达式会访问名为 user 的对象，并获取其 name 属性。

JSTL标签库提供了一系列的标签来执行条件判断、循环处理等操作。例如，以下JSTL标签用于遍历一个用户列表并显示每个用户的名字：

<c:forEach var="user" items="${users}">
    <p>${user.name}</p>
</c:forEach>

5.2.2 处理表单数据与验证

在Struts框架中，处理JSP页面上的表单数据是常见的任务。Struts自动将表单数据绑定到ActionForm对象上，ActionForm对象则负责数据验证。在JSP页面中，需要定义表单元素，并确保其 name 属性与ActionForm中的属性名称一致。

例如，一个简单的注册表单可能包含用户名和密码字段：

<form action="register" method="post">
    用户名：<input type="text" name="username"><br>
    密码：<input type="password" name="password"><br>
    <input type="submit" value="注册">
</form>

在提交表单后，Struts框架会自动将这些数据封装到对应的ActionForm实例中，然后由Action类进行处理。如果需要在JSP页面进行前端验证，可以使用JavaScript或者HTML5的内置验证功能。

对于数据验证，可以在ActionForm中定义业务规则，或者使用Struts提供的内置验证框架。例如，创建一个验证方法：

public String validate() {
    if (username == null || username.equals("")) {
        errors.add("username", new ActionMessage("error.username.empty"));
    }
    return SUCCESS;
}

在JSP页面中，可以通过Struts标签显示错误信息：

<s:fielderror/>

通过这种方式，可以确保用户在前端输入的数据符合要求，减少后端无效数据处理的压力。

6. ActionForm的使用与替代技术

6.1 ActionForm的定义与作用

6.1.1 ActionForm的基本用法

在Struts 1.x中，ActionForm是控制器（Action）和视图（JSP）之间传递数据的桥梁。ActionForm对象负责封装用户请求的参数，并将其传递给Action进行处理。当表单提交时，Struts会自动创建ActionForm实例，并调用其setter方法填充数据，然后在Action中通过getter方法获取这些数据。

ActionForm通常继承自 org.apache.struts.action.ActionForm 类。以下是一个简单的ActionForm示例：

public class LoginActionForm 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;
    }

    public void validate(ActionMapping mapping, ActionForm form,
                         HttpServletRequest request, HttpServletResponse response) {
        if (username == null || "".equals(username.trim())) {
            errors.add("username", new ActionMessage("error.username.required"));
        }

        if (password == null || "".equals(password.trim())) {
            errors.add("password", new ActionMessage("error.password.required"));
        }
    }
}

在Struts配置文件中注册ActionForm：

<form-bean name="loginForm" type="com.example.LoginActionForm" />
<form-property name="username" type="java.lang.String" />
<form-property name="password" type="java.lang.String" />

6.1.2 ActionForm与Action的交互

当一个表单提交后，Struts框架会寻找匹配的Action，并创建相应的ActionForm实例来保存用户输入的数据。ActionForm中的validate()方法会在数据提交时被调用，用于执行校验逻辑，如果校验失败，用户会被重新提示错误信息。

ActionForm与Action的交互流程大致如下：

用户提交表单。
Struts框架根据配置文件中的查找并实例化对应的ActionForm。
Struts框架使用表单数据填充ActionForm实例。
如果有validate()方法定义，Struts将调用它进行数据校验。
校验成功后，Struts查找配置文件中的，创建对应的Action实例。
ActionForm将数据传递给Action，Action进行业务处理。
Action完成后，Struts根据配置将用户重定向或转发到适当的视图。

6.2 替代ActionForm的技术

6.2.1 使用POJO代替ActionForm

随着Struts 2.x的流行，ActionForm的设计在某种程度上已经被简化。Struts 2放弃了ActionForm的概念，而是采用普通的Java对象（POJOs）作为表单的载体。在Struts 2中，表单数据通过对象属性自动绑定，不再需要继承特定的ActionForm类。

一个典型的Struts 2 POJO表单可能如下所示：

public class LoginForm {
    private String username;
    private String password;
    private boolean rememberMe;

    // Getters and setters omitted for brevity
}

在Struts 2中，表单数据与POJO的绑定是通过 @属性 注解实现的，不需要在XML配置中显式声明。

6.2.2 与Spring框架集成的优势

Struts 2与Spring框架的集成提供了更强大的功能，如依赖注入（DI）、声明式事务管理等。通过集成Spring，开发者可以使用Spring的IoC容器管理Action的依赖关系，并可以利用Spring强大的事务管理能力。

这种集成的流程通常包括以下步骤：

在项目中添加Spring库依赖。
创建Spring配置文件，配置Action的bean及其依赖。
在Struts 2配置文件中指定Spring容器的路径。
Struts 2在初始化时会加载Spring的配置文件，从而实现Spring的bean管理。
Action实例通过Spring容器进行创建和管理，自动注入所需的依赖。

例如，使用Spring配置文件配置Action bean：

<beans xmlns="***"
       xmlns:xsi="***"
       xsi:schemaLocation="***
                           ***">
    <bean id="loginAction" class="com.example.LoginAction" scope="prototype">
        <!-- Other configurations, such as property injection -->
    </bean>
</beans>

Struts 2配置文件中指定Spring容器：

<constant name="struts.objectFactory.spring.autoWire" value="name" />

通过这种方式，Action的创建和依赖注入由Spring管理，使得整个应用更加灵活和可测试。

7. DispatcherServlet的角色与功能

在现代Web应用框架中，DispatcherServlet扮演着重要的角色。在Struts 2框架中，虽然其核心控制流程与传统的Spring MVC有所不同，但是作为Web层的核心控制器，其职责和重要性是相似的。在这一章节中，我们将深入探讨DispatcherServlet在Web层的作用、配置细节以及如何优化其性能。

7.1 Servlet与DispatcherServlet的区别

7.1.1 Servlet的工作原理

Servlet是一种在服务器端运行的Java程序，它可以响应客户端（通常是Web浏览器）的请求，并将响应返回给客户端。Servlet通过继承特定的类和实现接口来完成其工作，处理请求的主要方法是 service() ，该方法会根据请求类型（GET、POST等）调用相应的方法（ doGet 、 doPost 等）。一个Servlet实例通常被配置在Web应用的部署描述符中，并且对每个请求都运行在独立的线程中。

7.1.2 DispatcherServlet的作用

DispatcherServlet是Spring框架提供的一个用于处理Web请求的Servlet，它的主要作用是将请求分发给Spring MVC应用的各个组件。它可以作为前端控制器，管理Web层的所有请求。DispatcherServlet的核心功能包括：

接收请求：作为请求的入口点。
解析请求：使用HandlerMapping来决定哪个Handler（控制器）应该处理该请求。
处理请求：调用HandlerAdapter来处理请求。
视图解析：将处理结果返回给客户端之前，使用ViewResolver来解析视图。
渲染视图：根据返回的数据渲染相应的视图。

7.2 DispatcherServlet的配置与优化

7.2.1 DispatcherServlet的配置细节

DispatcherServlet的配置主要涉及web.xml文件或者使用Spring Boot的application.properties/.yml文件。下面是一些关键的配置细节：

contextConfigLocation ：指定DispatcherServlet的Spring配置文件位置。如果未指定，Spring会默认寻找 /WEB-INF/<servlet-name>-servlet.xml 。
load-on-startup ：是否在Web应用启动时加载和初始化Servlet。
init-param ：可以设置初始化参数，如 dispatchOptionsRequest 来允许发送HTTP Options请求等。

<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring-dispatcher-servlet.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

7.2.2 高效利用DispatcherServlet的策略

异步处理：允许长耗时请求异步处理，提高响应时间和吞吐量。
缓存静态资源：使用Spring MVC的资源处理器来缓存静态资源，减少对服务器的重复请求。
视图缓存：利用Spring的缓存抽象（例如使用 @Cacheable 注解）来缓存那些不经常变化的视图。
静态资源映射：通过配置DispatcherServlet不拦截静态资源的请求，让Web服务器（如Tomcat、Jetty）直接提供这些资源，减少Spring MVC处理的开销。

@Bean
public EmbeddedServletContainerCustomizer containerCustomizer() {
    return (configurer) -> configurer.addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), true, "/*");
}

DispatcherServlet的深入理解和正确配置对于提高Web应用的性能至关重要。上述配置细节和优化策略有助于开发者更好地利用DispatcherServlet管理Web层的请求和响应。在实践中，根据应用的具体需求对DispatcherServlet进行适当的配置和优化，可以显著提升用户体验和系统的性能表现。

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