Spring Boot整合JSP完整教程与实战项目

Jay星晴

686人浏览 · 2025-09-10 11:40:27

Jay星晴 · 2025-09-10 11:40:27 发布

简介：Spring Boot默认不支持JSP，推荐使用Thymeleaf等模板引擎，但在某些传统项目中仍需使用JSP进行动态页面开发。本文详细介绍了如何在Spring Boot中整合JSP，包括添加Tomcat的JSP依赖、配置视图解析器、创建JSP页面、定义控制器路由及测试运行等内容。同时，文章也对比了JSP与现代前端框架的适用场景，帮助开发者在不同项目中做出合理选择。通过该教程，开发者可快速掌握Spring Boot整合JSP的核心步骤与注意事项。

1. Spring Boot框架简介与特性

Spring Boot 是构建现代 Java Web 应用的首选框架，其核心设计理念是“约定优于配置”，通过自动装配机制显著减少了传统 Spring MVC 所需的手动配置。其起步依赖（Starter Dependencies）机制简化了 Maven 配置，使开发者能够快速引入功能模块。此外，Spring Boot 内嵌了 Tomcat、Jetty 等 Web 服务器，支持开箱即用的快速启动与部署。

1.1 Spring Boot 的核心特性

Spring Boot 的主要特性包括：

特性	说明
自动装配（Auto-Configuration）	根据类路径中的依赖自动配置 Bean，减少 XML 或 Java Config 的冗余配置
起步依赖（Starter Dependencies）	提供预定义的依赖组合，简化 Maven/Gradle 构建文件的管理
内嵌服务器支持	默认集成 Tomcat、Jetty 等 Web 容器，无需外部部署即可运行 Web 应用
Actuator 模块	提供应用监控、健康检查、信息展示等运维支持
独立运行（Spring Boot CLI）	支持通过命令行快速构建和运行 Groovy 脚本

这些特性使得 Spring Boot 成为构建微服务、RESTful API 和传统 Web 应用的理想选择。

1.2 Spring Boot 与传统 Spring MVC 的区别

对比维度	Spring MVC	Spring Boot
配置方式	需手动配置 DispatcherServlet、ViewResolver 等组件	自动配置，开发者只需关注业务逻辑
项目结构	需手动引入多个依赖并配置 web.xml	提供 Starter 模块，开箱即用
服务器依赖	需部署在外部 Tomcat 等容器中	内嵌服务器，可独立运行
开发效率	配置繁琐，适合大型项目定制	快速启动，适合敏捷开发与中小型项目

这种简化使得开发者能够更快速地构建和部署应用，同时保留了 Spring 强大的扩展能力，为后续整合 JSP 技术提供了良好的基础。

2. JSP技术概述与应用场景

2.1 JSP的基本概念与运行机制

2.1.1 JSP的定义与发展历史

Java Server Pages（JSP）是一种基于Java技术的动态网页开发技术，它允许开发者将Java代码嵌入到HTML页面中，从而实现动态内容的生成。JSP本质上是Servlet的扩展，它在服务器端被编译为Servlet，然后由Servlet容器（如Tomcat）执行，最终将生成的HTML返回给客户端浏览器。

JSP的发展可以追溯到20世纪90年代末期，Sun Microsystems（现为Oracle）在1999年首次推出JSP 1.0规范。随后，随着Java EE标准的不断完善，JSP经历了多个版本的演进：

JSP 1.1 （1999年）：引入了Tag Library API，允许开发者自定义标签。
JSP 1.2 （2001年）：增强了与Servlet 2.3的兼容性。
JSP 2.0 （2003年）：引入了Expression Language（EL）和Simple Tag Extensions，简化了JSP的编写。
JSP 2.1 （2006年）：作为Java EE 5的一部分，支持统一表达式语言（Unified EL）。
JSP 2.3 （2011年）：作为Java EE 6的一部分，增加了对EL 3.0的支持。
JSP 2.4 （2021年）：作为Jakarta EE 9的一部分，名称从javax改为了jakarta。

随着Web开发技术的不断演进，JSP逐渐被更现代的前端技术和模板引擎（如Thymeleaf、Freemarker、Velocity）所替代，但其在传统Java Web项目中仍然有广泛的应用基础。

2.1.2 JSP的生命周期与执行流程

JSP的生命周期与Servlet类似，主要包括以下几个阶段：

阶段	描述
翻译阶段	JSP页面被Web容器转换为Java源代码（Servlet）
编译阶段	生成的Java代码被编译为字节码文件（.class）
加载阶段	Web容器加载生成的Servlet类
初始化阶段	调用jspInit()方法进行初始化
执行阶段	调用_jspService()方法处理请求，生成响应内容
销毁阶段	调用jspDestroy()方法释放资源

JSP的执行流程如下：

graph TD
    A[客户端发送HTTP请求] --> B[Web容器检查是否已编译JSP]
    B -->|是| C[_jspService()方法处理请求]
    B -->|否| D[将JSP翻译为Servlet]
    D --> E[编译Servlet为.class文件]
    E --> F[加载Servlet类]
    F --> G[jspInit()初始化]
    G --> H[_jspService()处理请求]
    H --> I[生成HTML响应]
    I --> J[返回客户端]

下面是一个简单的JSP页面示例：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>JSP示例</title>
</head>
<body>
    <h1>欢迎访问JSP页面</h1>
    <p>当前时间：<%= new java.util.Date() %></p>
</body>
</html>

代码逻辑分析：

<%@ page ... %> ：页面指令，用于设置页面的基本属性，如内容类型、字符编码、语言等。
<%= new java.util.Date() %> ：表达式标签，用于输出Java表达式的结果。此处输出当前时间。
<% ... %> ：脚本片段标签，用于嵌入Java代码逻辑。
<%! ... %> ：声明标签，用于定义JSP页面中的变量或方法。

该JSP页面在服务器端被翻译为一个继承自 HttpJspBase 的Servlet类，其中的HTML部分会被转换为 out.write() 方法调用，而Java代码则直接嵌入到 _jspService() 方法中。

2.2 JSP在Web开发中的角色定位

2.2.1 与HTML、Servlet的关系

JSP与HTML、Servlet之间存在紧密的联系，三者在Web开发中各自承担不同的职责：

技术	角色	特点
HTML	静态内容展示	用于构建网页结构和样式，不包含动态逻辑
Servlet	控制器逻辑	接收请求、处理业务逻辑、调用模型并转发到视图
JSP	视图展示	负责将模型数据动态渲染为HTML页面

在传统的MVC架构中，Servlet作为控制器（Controller），负责接收请求并调用模型（Model）处理数据；模型将处理结果返回给控制器；控制器将数据封装到 request 或 session 中，并转发（forward）到JSP页面；JSP作为视图（View）负责将数据渲染成HTML返回给客户端。

例如，Servlet中可以这样转发请求到JSP：

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    String message = "Hello from Servlet";
    request.setAttribute("message", message);
    RequestDispatcher dispatcher = request.getRequestDispatcher("/WEB-INF/views/index.jsp");
    dispatcher.forward(request, response);
}

参数说明：

setAttribute("message", message) ：将数据放入请求作用域，供JSP页面使用。
getRequestDispatcher() ：获取请求转发器，指定目标JSP路径。
forward() ：将请求和响应转发给目标资源。

JSP页面中通过EL表达式访问该值：

<p>${message}</p>

2.2.2 在传统MVC架构中的位置

JSP在MVC架构中作为View层的核心组件，负责数据的展示与用户交互。整个MVC架构流程如下：

graph LR
    A[客户端] --> B(Servlet控制器)
    B --> C[处理请求]
    C --> D[调用业务逻辑]
    D --> E[模型返回数据]
    E --> F[Servlet设置数据]
    F --> G[JSP渲染页面]
    G --> H[返回HTML响应]

在Spring MVC中，JSP通常与 InternalResourceViewResolver 配合使用，实现视图的自动解析。例如：

@Bean
public ViewResolver viewResolver() {
    InternalResourceViewResolver resolver = new InternalResourceViewResolver();
    resolver.setPrefix("/WEB-INF/jsp/");
    resolver.setSuffix(".jsp");
    resolver.setViewClass(JstlView.class);
    return resolver;
}

参数说明：

setPrefix() ：指定JSP页面所在的目录前缀。
setSuffix() ：指定JSP文件的后缀。
setViewClass() ：设置视图类，通常使用JSTL支持的 JstlView 。

控制器方法返回视图名称，Spring会自动拼接前缀和后缀：

@GetMapping("/home")
public String showHome() {
    return "home";  // 实际访问 /WEB-INF/jsp/home.jsp
}

2.3 JSP的适用场景与优劣势分析

2.3.1 适合使用JSP的项目类型

尽管现代Web开发中前后端分离已成为主流，但JSP在某些场景下依然具有优势：

项目类型	说明
传统企业系统	如ERP、OA系统，维护成本低，无需复杂前端框架
快速原型开发	小型项目或内部工具，快速搭建无需复杂构建流程
与Spring MVC集成	Spring Boot默认不支持JSP，但在传统Spring MVC中仍有使用基础
教学示例	学习Java Web基础，便于理解MVC流程与动态页面生成

例如，一个内部员工管理系统可以使用JSP快速实现页面渲染：

<c:forEach items="${employees}" var="emp">
    <tr>
        <td>${emp.id}</td>
        <td>${emp.name}</td>
        <td>${emp.department}</td>
    </tr>
</c:forEach>

代码说明：

使用JSTL <c:forEach> 标签循环遍历员工数据。
${emp.name} 表达式输出员工名称。

2.3.2 JSP与现代前端技术的对比

对比维度	JSP	现代前端技术（如Vue、React）
渲染方式	服务器端渲染（SSR）	客户端渲染（CSR）
开发效率	快速搭建，适合简单页面	需要构建工具、组件化开发
性能表现	首屏加载快	首屏依赖JavaScript加载
SEO友好	对搜索引擎更友好	初期SEO支持较弱
交互体验	页面刷新	单页应用，无刷新交互
维护成本	适用于小型项目	适用于大型复杂项目

例如，使用React实现类似功能：

{employees.map(emp => (
  <tr key={emp.id}>
    <td>{emp.id}</td>
    <td>{emp.name}</td>
    <td>{emp.department}</td>
  </tr>
))}

对比分析：

JSP适合数据绑定简单、页面结构固定的场景。
React适合组件化开发、复杂交互、单页应用等场景。

2.4 JSP与Spring Boot整合的必要性探讨

2.4.1 Spring Boot为何默认不支持JSP

Spring Boot默认使用 spring-boot-starter-web 模块，该模块默认使用嵌入式Tomcat服务器，并且默认不支持JSP页面的编译与执行。其原因包括：

嵌入式Tomcat限制 ：Spring Boot使用的嵌入式Tomcat版本（如Tomcat 9+）默认不包含JSP编译器（Jasper），导致JSP无法被解析。
设计哲学 ：Spring Boot推崇轻量级、前后端分离的设计理念，鼓励使用模板引擎如Thymeleaf、Freemarker等。
性能与维护 ：JSP页面需要编译为Servlet，增加了运行时开销；而模板引擎通常在启动时预编译，性能更优。

为了在Spring Boot中启用JSP支持，需要添加以下依赖：

<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
</dependency>

2.4.2 在Spring Boot中引入JSP的实际价值

尽管Spring Boot默认不推荐使用JSP，但在以下场景中仍有其价值：

使用场景	说明
迁移旧项目	企业已有JSP项目，希望逐步迁移到Spring Boot架构
快速原型开发	开发内部工具或演示系统，无需复杂前端框架
教学用途	学习Spring MVC与JSP整合流程，理解传统Web开发方式
SEO优化	对搜索引擎优化要求较高的页面，服务器端渲染更具优势

例如，在Spring Boot中配置JSP视图解析器：

@Configuration
public class JspConfig {
    @Bean
    public ViewResolver jspViewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/jsp/");
        resolver.setSuffix(".jsp");
        resolver.setViewClass(JstlView.class);
        resolver.setOrder(2);
        return resolver;
    }
}

参数说明：

setPrefix() ：指定JSP文件存放路径。
setSuffix() ：指定JSP文件后缀。
setOrder() ：视图解析器的优先级，确保JSP优先于其他模板引擎。

通过上述配置，开发者可以在Spring Boot中实现对JSP页面的渲染支持，满足特定项目需求。

3. Spring Boot中JSP整合的前期准备

在进入Spring Boot与JSP整合的具体实现之前，我们需要进行一系列的前期准备工作。这些工作不仅包括项目的搭建与依赖管理，还涉及视图解析器的配置原理以及JSP页面的目录结构规范。只有在这些基础配置完成后，我们才能顺利地进行控制器与JSP页面的交互开发。

3.1 项目构建与Maven依赖管理

在Spring Boot中整合JSP，第一步是创建一个标准的Spring Boot项目，并通过Maven进行依赖管理。Spring Boot默认并不直接支持JSP页面的渲染，因此我们需要手动添加必要的依赖项，确保应用能够正确解析并渲染JSP文件。

3.1.1 创建Spring Boot初始项目结构

创建Spring Boot项目最常用的方式是使用Spring Initializr（ https://start.spring.io ）。选择以下配置：

Project : Maven
Language : Java
Spring Boot Version : 推荐使用最新稳定版本（如2.7.x或3.0.x）
Dependencies : Spring Web

下载项目后，解压并导入IDE（如IntelliJ IDEA或Eclipse），你会看到标准的Spring Boot项目结构：

src
├── main
│   ├── java
│   │   └── com.example.demo
│   │       ├── DemoApplication.java
│   │       └── controller
│   ├── resources
│       ├── application.properties
│       ├── static
│       └── templates

3.1.2 添加tomcat-embed-jasper依赖的必要性

默认情况下，Spring Boot使用Thymeleaf作为模板引擎，并不支持JSP。为了在Spring Boot中支持JSP，我们需要添加以下两个关键依赖：

tomcat-embed-jasper ：用于嵌入式Tomcat中JSP的解析与编译。
jstl ：JSP标准标签库，用于在JSP中使用JSTL标签。

在 pom.xml 中添加如下依赖：

<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
</dependency>

逻辑分析与参数说明：

tomcat-embed-jasper ：这是Spring Boot内嵌Tomcat的一部分，负责将JSP转换为Servlet。在Spring Boot中，默认的嵌入式服务器是Tomcat，而该依赖提供了JSP解析能力。
jstl ：JSTL（JSP Standard Tag Library）是JSP中常用的标签库，提供如 <c:if> 、 <c:forEach> 等结构化标签，使JSP页面逻辑更清晰。

注意：如果你使用的是Spring Boot 3.x版本，部分依赖可能需要更新为Jakarta EE的命名空间，如 jakarta.servlet:jakarta.servlet-api 等。

3.2 视图解析器的配置原理与实践

视图解析器（ViewResolver）在Spring MVC中扮演着非常重要的角色。它负责将控制器返回的视图名称（如“index”）解析为实际的视图资源（如“/WEB-INF/views/index.jsp”）。在整合JSP时，我们需要配置 InternalResourceViewResolver ，以确保Spring Boot能够正确地加载JSP页面。

3.2.1 InternalResourceViewResolver的作用机制

InternalResourceViewResolver 是Spring MVC中用于解析内部资源（如JSP）的标准实现。其核心逻辑如下：

接收控制器返回的视图名称（view name）。
根据配置的前缀（prefix）和后缀（suffix），拼接出完整的JSP路径。
将拼接后的路径交给 RequestDispatcher 进行转发，从而加载实际的JSP页面。

例如：

控制器返回 "index" ，视图解析器会将其转换为 /WEB-INF/views/index.jsp 。

示例配置代码：

@Configuration
public class ViewResolverConfig {

    @Bean
    public ViewResolver viewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".jsp");
        resolver.setViewClass(JstlView.class);
        return resolver;
    }
}

代码逻辑分析：

resolver.setPrefix(“/WEB-INF/views/”) ：设定视图路径的前缀。通常JSP文件放在 /WEB-INF/views/ 目录下，这样可以防止用户直接访问JSP文件。
resolver.setSuffix(“.jsp”) ：设定视图路径的后缀，即自动在视图名称后添加 .jsp 。
resolver.setViewClass(JstlView.class) ：指定视图类为 JstlView ，以支持JSTL标签。

3.2.2 配置prefix和suffix参数的细节

视图解析器的配置中， prefix 和 suffix 是非常关键的参数。它们决定了JSP文件在项目中的存储位置和命名规范。

常见配置组合：

prefix	suffix	控制器返回值	实际路径
`/WEB-INF/views/`	`.jsp`	`"home"`	`/WEB-INF/views/home.jsp`
`/pages/`	`.jsp`	`"login"`	`/pages/login.jsp`
`/templates/`	`.jsp`	`"dashboard"`	`/templates/dashboard.jsp`

最佳实践建议 ：
- JSP页面建议放置在 /WEB-INF/ 目录下，防止直接访问。
- 使用统一的命名规范（如 prefix + name + suffix ）有助于后期维护和团队协作。

配置方式（Java配置 vs XML配置）

除了Java配置方式外，也可以在 application.properties 中进行配置：

spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp

注意：如果你使用的是Spring Boot 2.x及以下版本，这种方式是可行的。但在Spring Boot 3.x中，建议使用Java配置类来定义视图解析器。

3.3 JSP页面的目录结构规范

JSP页面的存放位置和目录结构在Spring Boot中有一定的规范要求，尤其是在使用嵌入式Tomcat时。Spring Boot默认将静态资源（如HTML、CSS、JS）放在 src/main/resources/static 目录下，而JSP文件则需要放在 src/main/webapp/WEB-INF/views 目录中。

3.3.1 resources目录下的视图路径设置

在Spring Boot项目中，传统的Maven结构下， resources 目录通常用于存放配置文件（如 application.properties ）、静态资源（ static ）、模板资源（ templates ）等。然而，对于JSP来说， resources 并不是合适的存放位置。

原因如下：

Spring Boot的打包机制将 resources 目录下的内容打包到 BOOT-INF/classes 中，而JSP文件需要在 webapp 目录下才能被Tomcat正确识别。
若将JSP文件放在 resources 目录下，会导致Tomcat在运行时找不到对应的JSP文件，从而抛出 View not found 异常。

3.3.2 webapp目录结构的兼容性处理

为了兼容传统的JSP开发模式，Spring Boot允许我们创建 src/main/webapp 目录，并在其中构建标准的Web应用目录结构：

src/main/webapp
├── WEB-INF
│   └── views
│       └── index.jsp
└── static
    └── css
    └── js

创建webapp目录的方法：

在 src/main 下新建 webapp 文件夹。
在 webapp 中创建 WEB-INF 目录。
在 WEB-INF 中创建 views 目录，用于存放JSP文件。

配置Spring Boot识别webapp目录：

在 application.properties 中添加以下配置，确保Spring Boot将 webapp 目录识别为Web资源目录：

spring.web.resources.static-locations=classpath:/static/,file:src/main/webapp/

注意：该配置将 src/main/webapp 目录加入静态资源搜索路径，但JSP文件本身仍需放置在 WEB-INF/views 目录中。

Mermaid流程图：JSP目录结构与访问流程

graph TD
    A[Controller返回view name] --> B[InternalResourceViewResolver]
    B --> C[拼接prefix + view name + suffix]
    C --> D[定位JSP文件路径]
    D --> E{路径是否正确?}
    E -->|是| F[转发至JSP页面]
    E -->|否| G[抛出View Not Found异常]

表格：JSP目录结构与访问路径对照表

文件路径	访问URL示例	是否推荐使用
`src/main/resources/templates/`	`/templates/index.jsp`	❌ 不推荐
`src/main/webapp/WEB-INF/views/`	`/WEB-INF/views/index.jsp`	✅ 推荐
`src/main/webapp/pages/`	`/pages/login.jsp`	✅ 可选
`src/main/webapp/static/`	`/static/js/app.js`	✅ 推荐

通过本章的讲解，我们已经完成了Spring Boot整合JSP所需的前期准备。从项目的创建、依赖管理，到视图解析器的配置，再到JSP页面的目录结构规范，每一个步骤都为后续的JSP页面开发打下了坚实的基础。在下一章中，我们将深入讲解控制器与JSP页面的交互实现，包括路由设计、数据绑定与页面跳转等核心内容。

4. 控制器与JSP页面的交互实现

在Spring Boot项目中，控制器（Controller）是处理HTTP请求的核心组件，它负责接收用户请求、调用业务逻辑、返回视图名称或数据。当Spring Boot整合JSP时，控制器不仅要处理数据逻辑，还需与JSP页面进行数据绑定与视图渲染。本章将围绕控制器的设计、路由跳转逻辑以及JSP页面的动态内容展示，深入探讨控制器与JSP页面的交互实现机制。

4.1 控制器设计的基本原则

在Spring Boot中，控制器类通常使用 @Controller 注解标识，并通过 @RequestMapping 及其派生注解（如 @GetMapping 、 @PostMapping ）来定义请求映射路径。控制器设计的合理与否，直接影响到应用的可维护性和扩展性。

4.1.1 使用 @Controller 与 @RequestMapping 注解

@Controller 是Spring MVC中的核心注解之一，它结合了 @Component 和 @ResponseBody 的功能。但与 @RestController 不同， @Controller 返回的字符串将被视图解析器处理为视图名称，而非直接作为响应体输出。

示例代码如下：

@Controller
@RequestMapping("/user")
public class UserController {

    @GetMapping("/profile")
    public String showProfile() {
        return "profile"; // 返回值将被视图解析器解析为 /WEB-INF/jsp/profile.jsp
    }
}

代码分析：

@Controller ：标记该类为控制器组件，Spring会自动扫描并注册为Bean。
@RequestMapping("/user") ：类级别的路径前缀，所有方法的请求路径都将以 /user 为前缀。
@GetMapping("/profile") ：方法级别的GET请求映射，等价于 @RequestMapping(value = "/profile", method = RequestMethod.GET) 。
return "profile" ：返回的字符串 “profile” 将由视图解析器拼接路径，如配置为 /WEB-INF/jsp/ ，最终指向 /WEB-INF/jsp/profile.jsp 。

参数说明：

注解	说明
`@Controller`	标识该类为控制器，返回值作为视图名称
`@RequestMapping`	定义URL映射路径，可作用于类和方法
`@GetMapping`	简化GET请求映射，相当于 `@RequestMapping(method = RequestMethod.GET)`

4.1.2 返回值与视图名称的映射规则

控制器方法返回的字符串默认会被视图解析器解析为视图名称。Spring Boot通过 InternalResourceViewResolver 配置视图路径的前缀（prefix）和后缀（suffix）。

例如：

spring:
  mvc:
    view:
      prefix: /WEB-INF/jsp/
      suffix: .jsp

此时，返回 "profile" 会被解析为 /WEB-INF/jsp/profile.jsp 。

流程图如下：

graph TD
    A[Controller方法返回字符串] --> B{是否存在视图解析器}
    B -->|是| C[拼接prefix + 返回值 + suffix]
    C --> D[定位JSP页面]
    B -->|否| E[抛出视图未找到异常]

控制器的设计应遵循单一职责原则，每个方法只处理一个请求路径，并返回对应的视图名称或数据模型。

4.2 路由设计与页面跳转逻辑

路由设计是控制器中非常关键的一环，它决定了请求如何被分发到对应的方法进行处理。页面跳转则依赖于返回的视图名称以及模型数据的传递。

4.2.1 GET/POST 请求的处理方式

Spring Boot中使用 @GetMapping 和 @PostMapping 分别处理GET和POST请求。GET请求通常用于获取数据并跳转页面，POST请求用于提交表单或修改数据。

示例代码如下：

@PostMapping("/login")
public String handleLogin(@RequestParam String username, Model model) {
    if ("admin".equals(username)) {
        model.addAttribute("message", "登录成功");
        return "welcome";
    } else {
        model.addAttribute("error", "用户名错误");
        return "login";
    }
}

代码分析：

@PostMapping("/login") ：处理POST请求，路径为 /user/login （结合类注解）。
@RequestParam String username ：从请求参数中获取 username 的值。
Model model ：用于向视图传递数据。
model.addAttribute("message", "登录成功") ：将键值对添加到模型中，供JSP页面使用。

参数说明：

参数	说明
`@RequestParam`	用于绑定请求参数，适用于GET和POST
`Model`	Spring MVC提供的模型对象，用于传递数据到视图层
`return "welcome"`	视图解析器会将其解析为 `/WEB-INF/jsp/welcome.jsp`

4.2.2 参数传递与模型数据绑定

控制器可以通过多种方式向JSP页面传递数据，包括 Model 、 ModelMap 、 Map 、 @ModelAttribute 等。推荐使用 Model 接口进行数据绑定。

示例代码：

@GetMapping("/user/{id}")
public String getUserById(@PathVariable Long id, Model model) {
    User user = userService.findById(id);
    model.addAttribute("user", user);
    return "userDetail";
}

代码分析：

@PathVariable Long id ：从URL路径中提取id参数。
model.addAttribute("user", user) ：将查询到的用户对象绑定到模型中。
JSP页面可通过EL表达式 ${user.name} 来访问用户信息。

表格：控制器向JSP传值方式对比

方式	说明	适用场景
`Model`	推荐使用，接口简洁	页面展示模型数据
`ModelMap`	继承 `Map` ，功能类似	页面模型绑定
`Map`	直接使用Map结构	简单数据传递
`@ModelAttribute`	可用于方法参数或返回值	表单回显、数据预加载

4.3 JSP页面的数据展示与交互

JSP页面负责接收控制器传递的数据并进行展示，通常使用EL表达式和JSTL标签库来实现动态内容的渲染。

4.3.1 EL表达式与JSTL标签库的应用

EL表达式（Expression Language）用于访问模型中的数据，其语法为 ${key} 。JSTL（JSP Standard Tag Library）提供了丰富的标签用于控制页面逻辑。

示例JSP代码：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head><title>用户详情</title></head>
<body>
    <h2>用户信息</h2>
    <p>姓名：${user.name}</p>
    <p>邮箱：${user.email}</p>
    <h3>兴趣列表：</h3>
    <ul>
        <c:forEach items="${user.interests}" var="interest">
            <li>${interest}</li>
        </c:forEach>
    </ul>
    <c:if test="${not empty message}">
        <p style="color:green;">${message}</p>
    </c:if>
    <c:if test="${not empty error}">
        <p style="color:red;">${error}</p>
    </c:if>
</body>
</html>

代码分析：

<%@ taglib prefix="c" uri="..." %> ：引入JSTL核心标签库。
${user.name} ：显示用户姓名。
<c:forEach> ：遍历用户兴趣列表。
<c:if> ：条件判断，显示提示信息或错误信息。

参数说明：

EL/JSTL 元素	说明
`${}`	EL表达式，用于输出模型数据
`<c:if>`	条件判断标签
`<c:forEach>`	循环遍历标签
`<c:choose>` 、 `<c:when>`	多条件分支判断

4.3.2 页面动态内容的渲染方法

JSP页面不仅支持静态内容展示，还可以通过动态逻辑控制页面行为。例如根据用户权限显示不同菜单、根据状态显示不同按钮等。

示例代码片段：

<c:if test="${user.role == 'admin'}">
    <a href="/user/manage">管理后台</a>
</c:if>

<c:choose>
    <c:when test="${user.status == 'active'}">
        <span style="color:green;">已激活</span>
    </c:when>
    <c:otherwise>
        <span style="color:red;">未激活</span>
    </c:otherwise>
</c:choose>

说明：

<c:if> ：根据用户角色判断是否显示链接。
<c:choose> + <c:when> ：多条件分支，显示用户状态。

流程图：JSP页面动态渲染逻辑

graph TD
    A[控制器传递数据到模型] --> B[JSP页面加载]
    B --> C{是否存在EL表达式或JSTL标签}
    C -->|是| D[执行标签逻辑]
    D --> E[动态渲染页面内容]
    C -->|否| F[静态内容展示]

通过合理使用EL表达式和JSTL标签，可以实现JSP页面的动态内容展示与逻辑控制，提升用户体验和开发效率。

总结：

本章详细阐述了Spring Boot中控制器的设计原则、路由处理方式以及与JSP页面的数据交互机制。控制器作为请求的入口，承担着路由分发和数据绑定的核心任务，而JSP页面则通过EL表达式和JSTL标签实现动态内容的渲染。掌握这些内容，是实现Spring Boot与JSP整合的关键基础。

5. Spring Boot启动与JSP访问测试

在完成所有Spring Boot与JSP整合的配置后，下一步就是启动应用并验证JSP页面能否正确访问。本章将详细展示Spring Boot应用的启动流程、浏览器访问JSP页面的操作步骤，并深入分析常见的启动异常和错误信息（如404错误、视图找不到等），同时提供对应的解决方案。

5.1 Spring Boot项目的启动方式

Spring Boot 提供了多种方式来启动项目，包括使用IDE（如IntelliJ IDEA、Eclipse）、通过命令行执行 mvn spring-boot:run ，以及打包成可执行的 JAR 文件后运行。我们以 Maven 构建工具为例，展示完整的启动流程。

5.1.1 使用IDE启动Spring Boot项目

在IDE中启动Spring Boot项目是最常见也是最便捷的方式。以IntelliJ IDEA为例：

打开项目，确保 pom.xml 中已正确添加 tomcat-embed-jasper 和 JSP 相关依赖。
找到主启动类（通常为 Application.java ），该类包含 @SpringBootApplication 注解。
右键点击主类，选择 Run 'Application' ，即可启动项目。

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

代码逻辑分析：

@SpringBootApplication 是一个组合注解，包含了 @ComponentScan 、 @SpringBootConfiguration 和 @EnableAutoConfiguration 。
SpringApplication.run(Application.class, args) 启动了Spring Boot应用，内嵌Tomcat服务器也随之启动。

启动成功后，控制台会输出如下日志：

Tomcat started on port(s): 8080 (http) with context path ''

说明应用已成功启动，监听端口为8080。

5.1.2 使用Maven命令行启动

在项目根目录下执行以下命令：

mvn spring-boot:run

该命令会下载依赖、编译项目并启动Spring Boot应用。启动成功后，同样可以看到Tomcat启动日志和监听端口信息。

5.1.3 打包并运行JAR文件

执行打包命令：

mvn clean package

Maven会在 target/ 目录下生成一个可执行的JAR文件，例如： demo-0.0.1-SNAPSHOT.jar 。

执行运行命令：

java -jar demo-0.0.1-SNAPSHOT.jar

该命令会运行打包后的JAR文件，Spring Boot应用随即启动。

5.2 访问JSP页面的测试步骤

完成启动后，接下来需要验证JSP页面是否可以正常访问。我们以一个简单的“Hello JSP”页面为例进行测试。

5.2.1 准备JSP页面

在Spring Boot项目中，JSP页面应放置在 src/main/webapp/WEB-INF/jsp/ 路径下。例如创建一个 hello.jsp 页面：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Hello JSP</title>
</head>
<body>
    <h1>Welcome to Spring Boot with JSP!</h1>
    <p>当前时间：${now}</p>
</body>
</html>

5.2.2 编写控制器映射

创建一个控制器类 HelloController.java ，将请求映射到 hello.jsp ：

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

import java.util.Date;

@Controller
public class HelloController {

    @GetMapping("/hello")
    public String sayHello(Model model) {
        model.addAttribute("now", new Date());
        return "hello";
    }
}

代码逻辑分析：

@GetMapping("/hello") 表示当访问 /hello 路径时，该方法会被调用。
model.addAttribute("now", new Date()) 将当前时间添加到模型中，供JSP页面使用。
return "hello" 表示返回视图名称为 hello ，视图解析器会自动拼接 prefix 和 suffix ，最终指向 WEB-INF/jsp/hello.jsp 。

5.2.3 浏览器访问测试

确保Spring Boot应用已经启动。
打开浏览器，访问地址： http://localhost:8080/hello
如果一切配置正确，将看到如下页面：

Welcome to Spring Boot with JSP!

当前时间：2025年4月5日 下午3:30:00

这说明JSP页面已经成功渲染，并与控制器正确交互。

5.3 常见启动异常与解决方案

在整合Spring Boot与JSP的过程中，可能会遇到各种启动异常。以下是一些常见的错误类型及其解决方法。

5.3.1 404错误（页面未找到）

现象：
访问页面时出现“404 Not Found”错误。

可能原因：
- 控制器路径配置错误。
- 视图解析器配置不正确。
- JSP页面路径错误或未放在正确目录下。

解决方案：

检查控制器映射路径：

@GetMapping("/hello")

确认浏览器访问的URL是否与控制器映射路径一致。

检查视图解析器配置：

在 application.properties 中确认是否配置了正确的视图前缀和后缀：

spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp

检查JSP页面路径：

确保JSP页面位于 src/main/webapp/WEB-INF/jsp/ 目录下，且文件名与控制器返回的视图名一致。

5.3.2 视图找不到（View Not Found）

现象：
启动时控制台输出类似如下错误：

Caused by: javax.servlet.ServletException: Circular view path [hello]: would dispatch back to the current handler URL [/hello] again. Check your ViewResolver setup!

可能原因：
- 视图解析器配置不正确，导致视图路径解析错误。
- JSP页面未被正确编译或未被Tomcat识别。

解决方案：

确认视图解析器配置：

确保视图前缀和后缀拼接后，能正确指向JSP页面的实际路径。

清除缓存并重新启动：

有时候旧的编译文件可能影响新页面的加载，建议执行以下命令：

mvn clean
mvn spring-boot:run

检查Tomcat是否支持JSP：

确保 pom.xml 中已添加 tomcat-embed-jasper 依赖：

<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

5.3.3 EL表达式未被解析

现象：
JSP页面中的EL表达式（如 ${now} ）未被解析，直接显示在页面上。

可能原因：
- JSP页面顶部未正确声明 isELIgnored 属性。
- Tomcat版本过低，不支持JSP 2.0以上标准。

解决方案：

修改JSP页面声明：

在JSP页面开头添加如下声明：

<%@ page isELIgnored="false" contentType="text/html;charset=UTF-8" language="java" %>

升级Tomcat版本：

确保Spring Boot使用的Tomcat版本为8.x或以上。可以通过 pom.xml 中指定版本：

<properties>
    <tomcat.version>9.0.56</tomcat.version>
</properties>

5.4 日志分析与调试技巧

在Spring Boot启动过程中，控制台输出的日志信息是排查问题的重要依据。以下是几种常用日志查看与调试技巧：

5.4.1 查看Tomcat启动日志

启动时，Spring Boot会输出Tomcat的启动日志，包括监听端口、上下文路径等信息：

Tomcat started on port(s): 8080 (http) with context path ''

如果未看到类似信息，说明Tomcat可能未正确启动。

5.4.2 启用DEBUG日志级别

在 application.properties 中启用DEBUG日志：

logging.level.org.springframework=DEBUG

这样可以查看Spring Boot自动配置的详细过程，帮助定位配置错误。

5.4.3 使用Actuator端点查看健康状态

添加Spring Boot Actuator依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

启动后访问 http://localhost:8080/actuator/health ，查看应用健康状态。

5.5 流程图与配置检查表

以下是一个整合Spring Boot与JSP的启动与测试流程图，帮助理解整个流程：

graph TD
    A[启动Spring Boot应用] --> B[检查Tomcat是否启动成功]
    B --> C{视图解析器配置是否正确?}
    C -->|是| D[访问控制器路径]
    C -->|否| E[修正prefix和suffix配置]
    D --> F{JSP页面是否存在?}
    F -->|是| G[浏览器渲染页面]
    F -->|否| H[检查JSP路径和文件名]
    G --> I[查看页面是否正常显示]
    I --> J{EL表达式是否解析?}
    J -->|是| K[测试完成]
    J -->|否| L[检查JSP头部声明]

此外，提供一个配置检查表供参考：

检查项	是否完成	说明
添加 `tomcat-embed-jasper` 依赖	✅	确保JSP编译支持
配置视图解析器前缀和后缀	✅	拼接JSP路径
JSP页面位于 `WEB-INF/jsp/` 下	✅	安全路径，避免直接访问
控制器返回视图名称正确	✅	与JSP文件名一致
EL表达式启用	✅	设置 `isELIgnored="false"`
Tomcat版本兼容性	✅	推荐使用Tomcat 9以上

通过本章的详细讲解，你已经掌握了Spring Boot启动应用、访问JSP页面的方法，并能够识别和解决常见的启动异常。下一章将探讨JSP在现代Web开发中的定位，以及与前后端分离架构的对比，帮助你更好地理解JSP的应用场景和选择依据。

6. JSP在现代Web开发中的定位与对比

随着前端技术的飞速发展，传统的服务端渲染（如JSP）在现代Web开发中的地位逐渐被前后端分离架构所取代。然而，JSP仍然在某些特定场景中具有不可替代的价值。本章将从技术演进的角度出发，深入对比JSP与现代前端框架（如Vue、React）在架构设计、开发效率、性能优化等方面的差异，同时探讨Spring Boot整合JSP的最佳实践场景，帮助开发者在不同项目背景下做出合理选择。

6.1 JSP与前后端分离架构的对比

JSP（JavaServer Pages）作为早期Web开发中主流的动态页面技术，其核心理念是“服务端渲染”，即在服务器端将数据与页面模板进行合并，生成HTML响应给浏览器。而现代Web开发中，前后端分离架构逐渐成为主流，前端框架如Vue、React、Angular等通过API接口获取数据，并在浏览器端完成页面的动态渲染。

6.1.1 JSP在传统MVC中的优势

在传统的MVC架构中，JSP作为视图层承担了页面渲染的角色，与Servlet控制器（如Spring MVC中的 @Controller ）协同工作，实现了逻辑与展示的分离。其优势主要体现在以下几个方面：

优势点	说明
简单易用	JSP语法基于HTML扩展，学习成本低，适合后端开发人员快速上手
服务端渲染	页面在服务器生成，首次加载速度快，SEO友好
集成方便	与Spring Boot等Java框架集成简单，无需额外构建工具
数据绑定自然	通过EL表达式和JSTL标签库，可直接绑定后端模型数据

示例代码：JSP页面中的EL表达式绑定数据

<%@ page contentType="text/html;charset=UTF-8" %>
<html>
<head>
    <title>用户信息</title>
</head>
<body>
    <h1>欢迎，${user.name}</h1>
    <p>你的邮箱是：${user.email}</p>
</body>
</html>

代码解析：

<%@ page contentType="text/html;charset=UTF-8" %> ：设置页面的字符编码和内容类型。
${user.name} ：EL表达式，用于从Model中获取名为 user 的对象的 name 属性。
整个页面由服务器渲染完成后发送至浏览器，无需JavaScript即可展示完整内容。

6.1.2 前后端分离（如Vue、React）的流行趋势

随着前端技术的发展，前后端分离架构成为主流趋势。Vue、React等前端框架通过组件化开发、虚拟DOM、状态管理等机制，提升了开发效率与用户体验。其优势如下：

优势点	说明
前后端解耦	后端专注于提供API接口，前端负责页面交互，便于团队协作
组件化开发	支持模块化、组件化开发，提升代码复用率
单页应用（SPA）体验	页面切换无需刷新，用户体验更流畅
强大的生态支持	如Vue Router、Vuex、React Router、Redux等工具链完善

示例代码：Vue组件展示用户信息

<template>
  <div>
    <h1>欢迎，{{ user.name }}</h1>
    <p>你的邮箱是：{{ user.email }}</p>
  </div>
</template>

<script>
export default {
  data() {
    return {
      user: {
        name: '张三',
        email: 'zhangsan@example.com'
      }
    };
  }
};
</script>

代码解析：

<template> ：定义HTML结构，使用双大括号 {{ }} 进行数据绑定。
data() ：定义组件的响应式数据对象， user 对象包含 name 和 email 字段。
Vue通过数据驱动视图更新，页面渲染由前端完成。

对比分析：

对比维度	JSP（服务端渲染）	Vue/React（客户端渲染）
渲染方式	服务器端合成HTML	浏览器端动态生成DOM
SEO友好性	高	需服务端渲染（SSR）支持
首屏加载速度	快	依赖JavaScript执行速度
开发效率	适合小型项目	适合大型复杂项目
技术栈耦合度	高（Java后端紧密耦合）	低（API接口解耦）

graph TD
    A[JSP] --> B[服务端渲染]
    A --> C[传统MVC架构]
    D[Vue/React] --> E[客户端渲染]
    D --> F[前后端分离架构]
    B --> G[首次加载快]
    E --> H[单页应用体验]
    C --> I[SEO友好]
    F --> J[API接口交互]

6.2 Spring Boot整合JSP的最佳实践场景

虽然前后端分离已成为主流，但在某些特定项目背景下，使用Spring Boot整合JSP仍然是一个高效且合理的方案。

6.2.1 快速原型开发与小型项目适用性

对于中小型项目或需要快速搭建原型的场景，JSP + Spring Boot的组合具备明显优势：

开发门槛低 ：无需配置前端构建环境，适合Java后端人员快速开发。
部署简单 ：Spring Boot内嵌Tomcat，JSP页面可直接部署运行。
维护成本低 ：视图与控制器耦合度高，逻辑清晰，便于维护。

适用场景举例：

内部管理系统（如OA、CRM）
数据报表展示页面
快速验证产品原型（MVP）

Spring Boot整合JSP步骤回顾（简要）：

创建Spring Boot项目，添加Tomcat JSP支持依赖（如 tomcat-embed-jasper ）。
配置视图解析器 InternalResourceViewResolver ，指定JSP路径。
编写控制器返回视图名称，Spring Boot自动匹配JSP文件。
启动应用并访问JSP页面。

Maven依赖示例：

<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

配置视图解析器：

@Configuration
public class WebConfig {
    @Bean
    public ViewResolver viewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/jsp/");
        resolver.setSuffix(".jsp");
        resolver.setViewClass(JstlView.class);
        return resolver;
    }
}

6.2.2 与Thymeleaf等模板引擎的对比

除了JSP，Spring Boot还支持多种模板引擎，如Thymeleaf、Freemarker、Mustache等。这些模板引擎各有特点，开发者可根据项目需求进行选择。

模板引擎	优点	缺点
JSP	传统Java Web标准，支持EL表达式	不支持内嵌模板，依赖Servlet容器
Thymeleaf	支持原生HTML，适合前后端联调	语法相对复杂，初次学习成本较高
Freemarker	强大的模板逻辑控制能力	不支持HTML原生预览
Mustache	语法简洁，跨平台支持好	功能有限，不适合复杂逻辑

Thymeleaf示例：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>用户信息</title>
</head>
<body>
    <h1 th:text="'欢迎，' + ${user.name}">欢迎，张三</h1>
    <p th:text="'你的邮箱是：' + ${user.email}">你的邮箱是：zhangsan@example.com</p>
</body>
</html>

对比分析：

对比项	JSP	Thymeleaf
HTML兼容性	依赖JSP编译器，不能直接打开	支持原生HTML，可独立预览
表达式语法	EL表达式（${}）	Thymeleaf表达式（${}）
控制结构	JSTL标签库	Thymeleaf内置控制结构
性能表现	相对较高	稍慢
社区活跃度	下降	活跃

graph LR
    A[JSP] --> B[传统MVC]
    A --> C[服务端渲染]
    D[Thymeleaf] --> E[静态HTML兼容]
    D --> F[前后端协作友好]
    C --> G[适合小型项目]
    F --> H[适合中大型项目]

总结性对比表格：

项目维度	JSP + Spring Boot	Vue/React + Spring Boot	Thymeleaf + Spring Boot
开发难度	简单，适合Java后端	需前端技能，适合全栈开发	中等，需学习模板语法
页面加载速度	快（服务端渲染）	依赖JavaScript加载	与JSP相近
SEO支持	天然支持	需SSR或预渲染	天然支持
项目适用性	快速原型、小型系统	大型SPA、中后台管理系统	中大型系统、文档类页面
维护成本	较低	高（需协调前后端）	中等

综上所述，JSP在现代Web开发中虽不再是主流，但其在特定项目场景下仍具备独特优势。开发者应根据项目规模、团队构成、技术栈等因素，合理选择是否在Spring Boot中整合JSP，或转向前后端分离架构与现代模板引擎。

7. Spring Boot整合JSP的完整流程与实战示例

7.1 整合JSP的完整步骤回顾

在前面的章节中，我们已经详细介绍了Spring Boot整合JSP所需的各项配置和基础知识。现在，我们将以一个清晰的步骤流程来回顾整个整合过程，帮助读者构建一个完整的知识体系。

7.1.1 从创建项目到配置视图解析器

创建Spring Boot项目
使用Spring Initializr（https://start.spring.io/）创建一个Maven项目，选择以下依赖项：
- Spring Web
- Tomcat（默认嵌入）
添加JSP支持依赖
在 pom.xml 中添加以下依赖以支持JSP页面的编译与运行：

xml <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> </dependency>

配置视图解析器
在 application.properties 中添加以下配置，指定JSP页面的前缀和后缀：

properties spring.mvc.view.prefix=/WEB-INF/jsp/ spring.mvc.view.suffix=.jsp

这样Spring Boot就知道如何定位和渲染JSP页面。

创建JSP目录结构
在 src/main/webapp/WEB-INF/jsp/ 下创建 .jsp 文件，例如 hello.jsp 。

7.1.2 控制器编写与页面访问测试

编写控制器类
创建一个控制器类，使用 @Controller 注解，并定义一个方法返回视图名称：

```java
@Controller
public class HelloController {

   @GetMapping("/hello")
   public String sayHello(Model model) {
       model.addAttribute("message", "Hello from Spring Boot with JSP!");
       return "hello"; // 对应 /WEB-INF/jsp/hello.jsp
   }

}
```

创建JSP页面
在 src/main/webapp/WEB-INF/jsp/hello.jsp 中编写如下内容：

```jsp
<%@ page language=”java” contentType=”text/html; charset=UTF-8” pageEncoding=”UTF-8”%>

Hello Page

${message}

```

启动项目并测试访问
运行Spring Boot项目，访问 http://localhost:8080/hello ，应能看到页面输出内容。

7.2 实战示例：构建一个完整的JSP页面应用

为了进一步巩固Spring Boot整合JSP的能力，我们来实现一个简单的用户登录系统，包含登录页面、登录处理和数据展示页面。

7.2.1 登录页面的设计与实现

创建登录页面
创建 login.jsp 页面，位于 /WEB-INF/jsp/login.jsp ：

```jsp
<%@ taglib prefix=”c” uri=”http://java.sun.com/jsp/jstl/core” %>

Login Page

Login Form

${error}

```

控制器实现登录逻辑

```java
@Controller
public class LoginController {

   @GetMapping("/login")
   public String showLoginForm() {
       return "login";
   }

   @PostMapping("/login")
   public String handleLogin(@RequestParam String username,
                             @RequestParam String password,
                             Model model) {
       if ("admin".equals(username) && "123456".equals(password)) {
           model.addAttribute("username", username);
           return "dashboard";
       } else {
           model.addAttribute("error", "Invalid username or password");
           return "login";
       }
   }

}
```

7.2.2 数据展示与页面跳转功能演示

创建仪表盘页面
创建 dashboard.jsp ：

```jsp

Dashboard

Welcome, ${username}!

You have successfully logged in.

```

运行测试
启动项目后，访问 http://localhost:8080/login ，输入用户名 admin 和密码 123456 ，页面应跳转到仪表盘页面。输入错误信息会显示提示。

7.3 常见问题与注意事项总结

在实际开发过程中，可能会遇到一些常见问题。以下是一些典型的错误场景及其解决方法。

7.3.1 不同Tomcat版本对JSP的支持差异

Tomcat版本	JSP支持情况	说明
8.x ~ 9.x	完全支持	默认内嵌Tomcat支持JSP
10.x	不完全兼容	需要额外配置或降级依赖版本
自定义Tomcat容器	需确认是否部署webapps目录	若使用外置Tomcat，需将JSP页面放在 `webapps` 目录下

解决方案 ：
- 推荐使用Spring Boot默认的嵌入式Tomcat 9.x版本。
- 如果使用Tomcat 10，需修改JSP中使用到的JSTL标签库为Jakarta EE 9+版本。

7.3.2 打包部署时的兼容性处理技巧

打包方式	问题	解决方案
jar包	无法识别 `webapp` 目录	Spring Boot默认不打包 `webapp` 下的JSP资源
war包	需要外置Tomcat部署	配置 `spring-boot-maven-plugin` 为war包，并设置 `webapp` 路径

操作步骤（打包为war） ：

修改 pom.xml 中的打包方式为 war ：

xml <packaging>war</packaging>

设置 spring-boot-maven-plugin 生成war包：

xml <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <packaging>war</packaging> </configuration> </plugin> </plugins> </build>