Spring Boot整合JSP的Web开发实战项目

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

简介：Spring Boot + JSP Demo工程是一个基于Java的Web开发示例项目，展示了如何将Spring Boot框架与JSP技术结合，构建动态网页应用。Spring Boot提供自动配置、内嵌服务器和起步依赖等特性，提升开发效率；JSP则用于构建交互式前端页面。本项目涵盖Spring Boot与JSP的整合配置、控制器编写、视图解析配置以及项目的运行测试，适合Java Web初学者掌握Spring Boot与JSP协同开发的核心流程与实践技巧。

1. Spring Boot简介与核心特性

1.1 Spring Boot的诞生背景

随着Java EE开发的复杂性不断增加，传统的Spring框架在配置和部署上显得繁琐。为了提升开发效率、降低配置复杂度，Pivotal团队于2014年推出了 Spring Boot 。它基于约定优于配置的理念，通过自动化配置和起步依赖（Starter Dependencies）简化了Spring应用的搭建和部署过程。

Spring Boot的出现标志着Java开发进入了一个更加轻量、快速、模块化的新阶段，尤其适合微服务架构和云原生应用的开发需求。它不仅继承了Spring框架的灵活性和扩展性，还极大提升了开发者的编码效率。

2. Spring Boot自动配置机制

Spring Boot的自动配置机制是其最核心的特性之一，能够极大地减少开发者手动配置的工作量。这一机制基于Spring框架强大的条件化配置能力，结合Maven或Gradle依赖管理机制，实现了“约定优于配置”的理念。通过自动配置，Spring Boot能够在启动时自动检测项目中引入的依赖包，并根据这些依赖动态地加载相应的配置类和Bean定义，从而让开发者几乎不需要编写任何XML配置文件或繁琐的 @Bean 定义代码。

本章将从自动配置的基本原理出发，逐步深入讲解其底层实现机制、加载流程、调试方式以及如何实现自定义自动配置，帮助开发者从“使用”层面提升到“理解与定制”层面，从而更灵活地控制Spring Boot应用的启动行为。

2.1 自动配置的基本原理

Spring Boot的自动配置机制并不是魔法，它建立在Spring框架原有的条件化装配机制之上，通过一系列约定与规范，实现了对开发者的高度封装与自动化。理解其基本原理是掌握自动配置机制的第一步。

2.1.1 条件化配置与@Conditional注解

Spring框架从3.1版本开始引入了 @Conditional 注解，允许开发者根据特定条件来决定是否将某个Bean或配置类加载到Spring容器中。Spring Boot正是基于这一机制，构建了其自动配置体系。

核心条件注解类型

注解名称	作用
@ConditionalOnClass	检查类路径中是否存在指定类
@ConditionalOnMissingClass	检查类路径中是否不存在指定类
@ConditionalOnBean	检查容器中是否存在指定Bean
@ConditionalOnMissingBean	检查容器中是否不存在指定Bean
@ConditionalOnProperty	检查配置文件中是否存在指定属性
@ConditionalOnWebApplication	检查当前是否是Web应用环境
@ConditionalOnNotWebApplication	检查当前是否不是Web应用环境

示例：使用 @ConditionalOnClass 实现条件化配置

我们来看一个典型的自动配置类示例：

@Configuration
@ConditionalOnClass({DataSource.class, EmbeddedDatabaseType.class})
public class DataSourceAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }
}

代码逻辑分析：

• @ConditionalOnClass({DataSource.class, EmbeddedDatabaseType.class}) ：表示当前类路径中必须存在 DataSource 和 EmbeddedDatabaseType 这两个类，配置类才会生效。
• @ConditionalOnMissingBean ：表示只有在容器中没有定义 DataSource Bean的情况下，才会创建默认的 DataSource 实例。
• DataSourceBuilder.create().build() ：使用Spring Boot提供的 DataSourceBuilder 来创建默认的数据源Bean。

通过这样的条件化配置，Spring Boot可以智能地判断是否需要加载某个配置项，避免了手动配置的繁琐和潜在冲突。

小结：

@Conditional 系列注解是Spring Boot自动配置机制的基石，它们使得配置类能够在运行时根据环境和依赖状态动态地启用或禁用，从而实现“按需加载”的自动配置策略。

2.1.2 Spring Boot Starter依赖的作用机制

Spring Boot通过Starter依赖来统一管理自动配置的入口。每个Starter依赖本质上是一个Maven或Gradle模块，它封装了相关的自动配置类、默认配置属性以及所需的第三方依赖。

Starter依赖结构解析

以 spring-boot-starter-web 为例，其Maven依赖如下：

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

当引入该依赖后，Spring Boot会自动引入以下内容：

• 内嵌的Tomcat服务器（默认）
• Spring MVC相关模块
• 自动配置类，如 DispatcherServletAutoConfiguration 、 WebMvcAutoConfiguration
• 默认的视图解析器、静态资源处理配置等

Starter依赖的组成结构

组成部分	说明
核心依赖	如 spring-webmvc 、 spring-context 等
自动配置类	位于 META-INF/spring.factories 中定义的配置类
默认属性	通常定义在 application.properties 或 application.yml 中
嵌套依赖	如 spring-boot-starter-tomcat 等，用于支持运行时环境

自动配置类的注册方式

Spring Boot通过 spring.factories 机制来注册自动配置类。例如，在 spring-boot-autoconfigure 模块的 META-INF/spring.factories 文件中，你可能会看到如下内容：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaAutoConfiguration

这表示Spring Boot在启动时会加载这些配置类，并根据条件判断是否启用。

Starter依赖的优势

• 简化依赖管理 ：开发者只需引入一个Starter即可完成多个相关组件的集成。
• 统一配置入口 ：所有Starter都遵循统一的命名规范和配置方式。
• 自动装配机制 ：配合 @Conditional 机制，实现智能配置加载。

2.2 自动配置类的加载过程

了解Spring Boot自动配置类的加载流程，有助于开发者在调试或优化项目时更好地理解底层机制。

2.2.1 Spring Boot的自动配置类加载流程

Spring Boot在启动时会通过以下步骤加载自动配置类：

graph TD
    A[Spring Boot启动] --> B[读取spring.factories中的配置类]
    B --> C[解析并加载配置类]
    C --> D[应用@Conditional条件判断]
    D --> E[将符合条件的Bean注册到容器中]
    E --> F[完成自动配置]

详细流程说明：

1. Spring Boot启动 ：当调用 SpringApplication.run() 方法时，Spring Boot开始启动流程。
2. 读取spring.factories ：Spring Boot会扫描所有依赖中的 META-INF/spring.factories 文件，找到其中定义的自动配置类。
3. 加载配置类 ：将这些配置类加载到Spring上下文中。
4. 条件判断 ：每个配置类上的 @Conditional 注解会被解析，判断该类是否应该生效。
5. Bean注册 ：符合条件的配置类中的 @Bean 方法会被执行，生成对应的Bean并注册到容器中。
6. 完成自动配置 ：所有符合条件的自动配置类执行完毕，Spring Boot完成自动配置阶段。

示例：查看加载的自动配置类

你可以通过在 application.properties 中添加以下配置来查看Spring Boot加载了哪些自动配置类：

debug=true

启动应用后，控制台会输出类似如下信息：

CONDITIONS EVALUATION REPORT

Positive matches:
   WebMvcAutoConfiguration matched:
      - @ConditionalOnClass found required classes 'javax.servlet.Servlet', 'org.springframework.web.servlet.DispatcherServlet' (OnClassCondition)
      - @ConditionalOnWebApplication (required) found 'session' scope (OnWebApplicationCondition)

Negative matches:
   DataSourceAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'javax.sql.DataSource' (OnClassCondition)

这表明Spring Boot已经成功识别了哪些自动配置类被加载，哪些被跳过。

2.2.2 如何查看和调试默认自动配置

除了使用 debug=true 外，开发者还可以通过编程方式查看已加载的自动配置类。

示例：使用 SpringApplication 获取自动配置报告

public static void main(String[] args) {
    SpringApplication app = new SpringApplication(MyApplication.class);
    app.setMainApplicationClass(MyApplication.class);
    ConfigurableApplicationContext context = app.run(args);
    AutoConfigurationReport report = context.getBeanFactory().getBean(AutoConfigurationReport.class);
    Map<String, List<ConditionEvaluationReport.ConditionAndOutcomes>> conditionMap = report.getConditionAndOutcomesBySource();
    conditionMap.forEach((key, value) -> {
        System.out.println("Class: " + key);
        value.forEach(condition -> {
            System.out.println("  Condition: " + condition.getCondition());
            System.out.println("  Outcome: " + condition.getOutcome());
        });
    });
}

代码逻辑分析：

• AutoConfigurationReport ：是Spring Boot自动生成的自动配置报告对象。
• getConditionAndOutcomesBySource() ：返回每个自动配置类的条件判断结果。
• 遍历输出结果，可以看到每个自动配置类是否被加载及其原因。

通过这种方式，开发者可以深入了解Spring Boot的自动配置过程，并据此进行调试和优化。

2.3 自定义自动配置

虽然Spring Boot提供了丰富的自动配置类，但在实际项目中，我们往往需要根据业务需求自定义自动配置。例如，为某个中间件（如Redis、RabbitMQ）编写自动配置类，或封装公司内部的公共组件。

2.3.1 创建自定义Starter模块

一个典型的Spring Boot Starter模块结构如下：

my-starter/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/starter/
│   │   │       ├── MyAutoConfiguration.java
│   │   │       └── MyProperties.java
│   │   └── resources/
│   │       └── META-INF/
│   │           └── spring.factories
└── pom.xml

步骤说明：

1. 定义配置属性类 ：用于接收 application.properties 中的自定义配置。

@ConfigurationProperties(prefix = "my.starter")
public class MyProperties {
    private String name;
    private int timeout;

    // getters and setters
}

2. 编写自动配置类 ：

@Configuration
@ConditionalOnClass(MyService.class)
@EnableConfigurationProperties(MyProperties.class)
public class MyAutoConfiguration {

    @Autowired
    private MyProperties myProperties;

    @Bean
    @ConditionalOnMissingBean
    public MyService myService() {
        return new MyServiceImpl(myProperties.getName(), myProperties.getTimeout());
    }
}

3. 配置 spring.factories 文件 ：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.starter.MyAutoConfiguration

4. 打包并发布到Maven仓库 ：

使用Maven命令进行打包：

mvn clean install

之后其他项目就可以通过以下方式引入：

<dependency>
    <groupId>com.example</groupId>
    <artifactId>my-starter</artifactId>
    <version>1.0.0</version>
</dependency>

2.3.2 实现自定义自动配置类

在自定义自动配置类中，通常需要关注以下几个关键点：

• 配置属性绑定 ：通过 @EnableConfigurationProperties 绑定自定义配置类。
• 条件判断 ：使用 @ConditionalOnClass 、 @ConditionalOnMissingBean 等注解控制配置加载逻辑。
• Bean定义 ：提供默认的Bean实现，并允许用户自定义替换。

示例：自定义配置类

@Configuration
@ConditionalOnClass({MyService.class})
@EnableConfigurationProperties(MyProperties.class)
public class MyAutoConfiguration {

    @Autowired
    private MyProperties myProperties;

    @Bean
    @ConditionalOnMissingBean
    public MyService myService() {
        return new MyServiceImpl(myProperties.getName(), myProperties.getTimeout());
    }
}

代码分析：

• @ConditionalOnClass({MyService.class}) ：确保只有在类路径中存在 MyService 接口时才加载此配置类。
• @EnableConfigurationProperties(MyProperties.class) ：启用配置属性绑定。
• @ConditionalOnMissingBean ：防止用户已经自定义了 MyService Bean的情况下重复注入。

2.3.3 配置META-INF/spring.factories文件

spring.factories 文件是Spring Boot识别自动配置类的关键。它位于 resources/META-INF/ 目录下，内容格式如下：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.starter.MyAutoConfiguration

每一行表示一个自动配置类的全限定名，多个类之间用反斜杠 \ 换行连接。

注意事项：

• spring.factories 文件必须使用UTF-8编码。
• 配置类必须是 @Configuration 注解的类。
• 多个自动配置类可共用一个 spring.factories 文件。

通过本章内容，我们深入解析了Spring Boot自动配置机制的原理、加载流程以及如何实现自定义自动配置。掌握这些内容，不仅有助于开发者高效使用Spring Boot，还能在需要时灵活定制其行为，满足复杂业务场景的需求。

3. Spring Boot整合JSP技术

JSP（Java Server Pages）作为Java Web开发中历史悠久且稳定的技术之一，虽然在现代Web开发中逐渐被前后端分离架构所取代，但在许多传统企业级应用中仍然广泛使用。Spring Boot为了支持传统Web开发，提供了对JSP的良好集成支持。本章将详细介绍如何在Spring Boot项目中集成JSP，并通过具体的配置与开发实践，帮助开发者掌握JSP与Spring Boot结合的开发方式。

3.1 JSP技术基础与原理

JSP是基于Servlet技术的扩展，允许开发者将Java代码嵌入HTML页面中，从而实现动态网页的生成。它本质上是一种模板引擎，最终会被编译为Servlet执行。理解JSP的基本原理对于在Spring Boot中使用JSP至关重要。

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

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

1. 翻译阶段（Translation） ：JSP容器将 .jsp 文件翻译为 .java 文件（即Servlet源码）。
2. 编译阶段（Compilation） ：将生成的 .java 文件编译为 .class 字节码文件。
3. 加载与初始化阶段（Loading and Initialization） ：类加载器加载编译后的Servlet类，并调用 jspInit() 方法进行初始化。
4. 执行阶段（Execution） ：当客户端发起请求时，容器调用 _jspService() 方法处理请求，生成响应内容。
5. 销毁阶段（Destroy） ：容器调用 jspDestroy() 方法释放资源。

阶段	描述
翻译	将JSP文件转换为Servlet代码
编译	编译生成的Servlet类
初始化	调用 jspInit() 方法初始化资源
执行	处理请求，生成HTML响应
销毁	调用 jspDestroy() 方法释放资源

JSP的执行流程体现了其与Servlet的紧密关系，理解这一点有助于开发者在Spring Boot中更好地使用JSP进行视图渲染。

3.1.2 JSP与Servlet的关系

JSP本质上就是Servlet的一种变体。JSP文件在运行时会被编译为Servlet类，其生命周期与Servlet一致。不同之处在于：

• 编写方式 ：Servlet是纯Java代码，JSP是HTML与Java代码的混合。
• 可读性 ：JSP更适合页面展示逻辑，Servlet更适合处理业务逻辑。
• 维护性 ：JSP更易于维护HTML内容，而Servlet更便于实现复杂的控制逻辑。

// 示例：JSP编译后的Servlet类结构
public final class index_jsp extends HttpJspBase {
    public void _jspService(HttpServletRequest request, HttpServletResponse response) {
        // 实际HTML输出逻辑
    }
}

逻辑分析 ：
- index_jsp 类继承自 HttpJspBase ，后者是JSP容器提供的基类。
- _jspService() 方法处理HTTP请求并输出HTML内容。
- 此类由JSP容器自动编译生成，开发者无需手动编写。

该机制表明，JSP在底层仍然是Servlet技术的封装，Spring Boot对JSP的支持本质上也是对Servlet的适配。

3.2 Spring Boot项目中引入JSP支持

虽然Spring Boot默认更推荐使用Thymeleaf、Freemarker等模板引擎，但通过简单的配置即可支持JSP技术。

3.2.1 添加JSP依赖（如tomcat-embed-jasper）

在Spring Boot项目中使用JSP需要引入JSP引擎依赖。以Maven项目为例，需在 pom.xml 中添加以下依赖：

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

参数说明 ：
- tomcat-embed-jasper 是Tomcat内置的JSP引擎实现，用于处理JSP文件的编译和执行。
- 如果使用外部Tomcat部署，此依赖可省略，但在嵌入式Tomcat环境中是必需的。

3.2.2 配置JSP视图解析器

为了让Spring Boot识别并渲染JSP页面，需要在配置文件中设置视图解析器。

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

参数说明 ：
- prefix ：JSP页面的存放路径，通常为 /WEB-INF/jsp/ ，避免直接访问。
- suffix ：JSP文件的扩展名，通常为 .jsp 。

逻辑分析 ：
- 当控制器返回视图名称如 "index" 时，Spring Boot会自动将其解析为 /WEB-INF/jsp/index.jsp 。
- 这种配置方式与传统的Spring MVC一致，确保视图定位正确。

3.3 JSP页面开发实践

在Spring Boot中完成JSP集成后，接下来将通过实际开发展示JSP页面的使用技巧，包括JSP指令、EL表达式、JSTL标签库以及动态页面跳转。

3.3.1 使用JSP指令和动作标签

JSP指令用于控制页面的处理方式，常见的指令包括：

• <%@ page %> ：定义页面的全局属性。
• <%@ include %> ：静态包含其他页面内容。
• <%@ taglib %> ：引入标签库。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head><title>JSP示例</title></head>
<body>
    <h1>欢迎访问JSP页面</h1>
    <jsp:include page="footer.jsp"/>
</body>
</html>

逻辑分析 ：
- <%@ page %> 设置页面编码为UTF-8，语言为Java。
- <%@ taglib %> 引入JSTL核心标签库，用于条件判断、循环等操作。
- <jsp:include> 动态包含 footer.jsp 页面内容。

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

JSP中常使用EL表达式（Expression Language）和JSTL（JSP Standard Tag Library）来简化页面逻辑。

<c:if test="${user != null}">
    <p>欢迎回来，${user.name}！</p>
</c:if>

<ul>
    <c:forEach items="${users}" var="user">
        <li>${user.id} - ${user.name}</li>
    </c:forEach>
</ul>

逻辑分析 ：
- ${user.name} ：使用EL表达式从模型中获取数据。
- <c:if> ：判断用户是否登录。
- <c:forEach> ：遍历用户列表并输出。

3.3.3 在Spring Boot中实现动态页面跳转

控制器返回的字符串将被视图解析器处理为JSP路径。以下是一个典型的控制器示例：

@Controller
public class PageController {

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

逻辑分析 ：
- @Controller ：标识该类为Spring MVC控制器。
- Model ：用于向JSP页面传递数据。
- return "index" ：返回视图名称，Spring Boot自动定位到 index.jsp 。

流程图示意 （mermaid）：

graph TD
    A[客户端请求 /home] --> B[PageController接收请求]
    B --> C[调用showHome方法]
    C --> D[添加数据到Model]
    D --> E[返回视图名称 index]
    E --> F[视图解析器解析为 /WEB-INF/jsp/index.jsp]
    F --> G[渲染页面并返回响应]

流程说明 ：
1. 客户端访问 /home 路径。
2. Spring Boot路由到 PageController 。
3. 控制器方法处理逻辑并添加数据。
4. 返回视图名称，视图解析器定位JSP文件。
5. JSP页面渲染后返回给客户端。

通过以上章节内容的详细讲解，我们已经掌握了在Spring Boot中集成JSP的完整流程，包括JSP的基本原理、依赖配置、视图解析器设置，以及JSP页面的开发实践。下一章将进一步结合Spring Boot的Web开发能力，构建完整的Web应用。

4. Spring Boot Web开发实践

本章将深入探讨如何在Spring Boot项目中进行完整的Web开发实践。我们将围绕MVC架构、控制器开发、视图解析、静态资源处理以及表单交互等内容展开，结合JSP技术实现一个完整的Web应用。通过本章的学习，开发者将掌握Spring Boot Web开发的核心技能，并具备构建动态Web应用的能力。

4.1 控制器开发与MVC架构

在Spring Boot中，控制器是Web应用的核心组件之一，负责接收客户端请求、处理业务逻辑，并将结果返回给视图。Spring MVC框架提供了强大的注解支持，使得控制器的开发变得简洁高效。

4.1.1 @Controller与@RestController注解的区别

Spring Boot中常用的控制器注解有 @Controller 和 @RestController ，它们分别适用于不同的返回类型。

• @Controller ：用于返回视图名称或视图对象，适用于结合JSP、Thymeleaf等视图技术进行页面渲染。
• @RestController ：是 @Controller 和 @ResponseBody 的组合注解，表示返回值直接作为响应体，适用于构建RESTful API接口。

代码示例：

@Controller
public class HomeController {
    @GetMapping("/home")
    public String home(Model model) {
        model.addAttribute("message", "Hello from HomeController");
        return "home"; // 返回JSP视图名称
    }
}

@RestController
public class ApiRestController {
    @GetMapping("/api/data")
    public Map<String, Object> getData() {
        Map<String, Object> data = new HashMap<>();
        data.put("id", 1);
        data.put("name", "Spring Boot");
        return data; // 返回JSON数据
    }
}

逻辑分析：

• @Controller 配合 Model 对象可以将数据传递给JSP页面，最终通过视图解析器渲染成HTML页面。
• @RestController 省去了在每个方法上添加 @ResponseBody 的步骤，适用于前后端分离的场景，返回的数据直接以JSON格式输出。

4.1.2 请求映射与参数绑定

Spring Boot提供了丰富的请求映射注解，如 @GetMapping 、 @PostMapping 、 @RequestMapping 等，同时支持多种参数绑定方式。

示例代码：

@Controller
public class UserController {
    @GetMapping("/user/{id}")
    public String getUser(@PathVariable Long id, Model model) {
        model.addAttribute("userId", id);
        return "userProfile";
    }

    @PostMapping("/submit")
    public String submitForm(@RequestParam String name, @RequestParam String email, Model model) {
        model.addAttribute("name", name);
        model.addAttribute("email", email);
        return "formResult";
    }
}

参数说明：

• @PathVariable ：用于捕获URL中的路径参数，如 /user/123 中的 123 。
• @RequestParam ：用于接收查询参数或表单提交的参数，常用于GET和POST请求。
• Model ：用于向视图传递数据，支持在JSP页面中通过EL表达式获取。

流程图：

graph TD
    A[客户端请求] --> B{判断请求方法}
    B -->|GET| C[调用@GetMapping方法]
    B -->|POST| D[调用@PostMapping方法]
    C --> E[绑定路径参数@PathVariable]
    D --> F[绑定表单参数@RequestParam]
    E --> G[填充Model对象]
    F --> G
    G --> H[返回视图名称]
    H --> I[视图解析器渲染JSP]

4.2 视图路径与资源访问配置

在Spring Boot中，默认的视图解析规则可以简化JSP页面的配置。同时，静态资源的访问也需要合理配置路径，以确保CSS、JS、图片等资源能够被正确加载。

4.2.1 配置spring.mvc.view.prefix与suffix

Spring Boot通过 application.properties 或 application.yml 文件配置视图前缀和后缀，从而实现JSP页面的自动解析。

配置示例（application.properties）：

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

逻辑说明：

• spring.mvc.view.prefix ：指定JSP页面的存放目录，通常为 /WEB-INF/views/ ，以避免直接访问。
• spring.mvc.view.suffix ：指定JSP页面的后缀名，省去在控制器中重复书写 .jsp 。

控制器代码示例：

@Controller
public class PageController {
    @GetMapping("/about")
    public String about() {
        return "about"; // 实际路径为：/WEB-INF/views/about.jsp
    }
}

4.2.2 静态资源路径的映射规则

Spring Boot默认会从 src/main/resources/static 、 src/main/resources/public 等目录加载静态资源。

自定义静态资源路径：

spring.web.resources.static-locations=classpath:/static/,file:/opt/my-static-resources/

访问方式：

• /css/style.css ：Spring Boot会依次从配置的静态资源路径中查找该文件。
• 例如： http://localhost:8080/css/style.css

资源加载流程图：

graph LR
    A[客户端请求静态资源] --> B[Spring Boot资源处理器]
    B --> C{检查资源是否存在}
    C -->|存在| D[返回资源内容]
    C -->|不存在| E[返回404]

4.3 表单提交与数据处理

在Web开发中，表单提交是常见交互方式。Spring Boot提供了完善的表单数据接收、验证和页面跳转机制。

4.3.1 接收表单数据并进行验证

Spring Boot支持通过 @RequestParam 或 @ModelAttribute 接收表单数据，并结合 @Valid 进行参数验证。

表单类定义：

public class UserForm {
    private String name;
    private String email;

    // Getters and Setters
}

控制器代码：

@PostMapping("/register")
public String register(@Valid @ModelAttribute UserForm userForm, BindingResult result, Model model) {
    if (result.hasErrors()) {
        return "registerForm";
    }
    model.addAttribute("success", "注册成功！");
    return "successPage";
}

参数说明：

• @ModelAttribute ：将表单数据自动绑定到Java对象。
• @Valid ：启用数据验证，需配合JSR-303注解如 @NotBlank 、 @Email 等使用。
• BindingResult ：用于获取验证错误信息。

4.3.2 将数据传递给JSP页面进行展示

在JSP页面中，可以通过EL表达式或JSTL标签库获取控制器传递的模型数据。

JSP页面代码示例（registerForm.jsp）：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Register</title>
</head>
<body>
    <c:if test="${not empty success}">
        <div class="alert alert-success">${success}</div>
    </c:if>
    <form action="/register" method="post">
        <label>姓名：</label><input type="text" name="name" value="${userForm.name}" />
        <label>邮箱：</label><input type="text" name="email" value="${userForm.email}" />
        <input type="submit" value="提交" />
    </form>
</body>
</html>

逻辑说明：

• 使用 <c:if> 判断是否存在 success 变量，若有则显示提示信息。
• 通过EL表达式 ${userForm.name} 回显表单数据，提升用户体验。

表单处理流程图：

graph TD
    A[用户填写表单] --> B[提交到/register接口]
    B --> C[Spring Boot接收请求]
    C --> D{参数验证是否通过}
    D -->|是| E[跳转到成功页面]
    D -->|否| F[返回表单并显示错误]

4.4 项目运行与调试

在开发过程中，提高调试效率是提升开发体验的重要一环。Spring Boot提供了诸如DevTools热部署、日志输出等工具，帮助开发者快速定位问题。

4.4.1 使用Spring Boot DevTools提升开发效率

Spring Boot DevTools 是一个开发工具模块，能够实现类路径变化时自动重启应用，提升开发调试效率。

添加依赖（pom.xml）：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

功能特性：

• 自动重启：修改代码后，Spring Boot会自动重启应用。
• LiveReload：支持浏览器自动刷新。
• 禁用缓存：在开发模式下自动禁用模板缓存。

使用建议：

• 仅在开发阶段启用，生产环境应移除或禁用。
• 可通过 application.properties 进一步配置：
  properties spring.devtools.restart.enabled=true spring.devtools.livereload.enabled=true

4.4.2 日志输出与常见问题排查

Spring Boot默认使用 Spring Boot Starter Logging 进行日志输出，开发者可以通过日志快速定位问题。

配置日志级别（application.properties）：

logging.level.org.springframework.web=WARN
logging.level.com.example.demo=DEBUG

日志输出示例：

2025-04-05 14:20:00.123 DEBUG 12345 --- [nio-8080-exec-1] c.e.d.controller.HomeController        : 接收到GET请求 /home

常见问题排查技巧：

• 查看控制台日志是否有 NoSuchBeanDefinitionException 、 NoSuchMethodError 等异常。
• 检查JSP路径是否正确，避免视图解析失败。
• 使用 @ComponentScan 确保组件被正确扫描注入。
• 在开发工具中使用断点调试，配合 @Autowired 注入验证。

调试流程图：

graph TD
    A[启动Spring Boot应用] --> B[加载配置和组件]
    B --> C[启动内嵌Tomcat服务器]
    C --> D[监听8080端口]
    D --> E[接收请求并处理]
    E --> F{是否有异常抛出}
    F -->|是| G[输出日志并定位问题]
    F -->|否| H[正常响应请求]

本章详细讲解了Spring Boot Web开发的核心实践内容，包括控制器开发、视图路径配置、静态资源处理、表单提交与调试技巧。通过本章的学习，开发者可以掌握构建完整Web应用所需的核心技能，并具备进一步扩展Spring Boot Web功能的能力。下一章将进入部署与优化阶段，探讨如何将Spring Boot应用打包上线并进行性能调优。

5. Spring Boot工程部署与优化

5.1 项目打包与运行方式

在Spring Boot项目开发完成后，打包与部署是项目上线前的重要步骤。Spring Boot支持多种打包方式，其中最常用的是使用Maven或Gradle构建可执行的JAR包。这种方式将所有依赖与应用代码打包为一个独立的可执行文件，简化了部署流程。

5.1.1 使用Maven/Gradle构建可执行jar包

使用Maven构建：
在 pom.xml 中确保打包插件已配置：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

执行Maven命令进行打包：

mvn clean package

构建完成后，可在 target/ 目录下找到生成的可执行JAR文件，例如： myapp-0.0.1-SNAPSHOT.jar 。

使用Gradle构建：
在 build.gradle 中确保插件已正确引入：

plugins {
    id 'org.springframework.boot' version '2.7.0'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'java'
}

执行构建命令：

gradle clean build

构建完成后，可在 build/libs/ 目录下找到对应的JAR文件。

运行方式：

java -jar myapp-0.0.1-SNAPSHOT.jar

5.1.2 嵌入式Tomcat与外部Tomcat部署对比

对比项	嵌入式Tomcat	外部Tomcat
启动方式	直接运行JAR文件	部署WAR包到Tomcat服务器
灵活性	适合快速部署	适合已有服务器环境
升级维护	需重新打包	可单独升级Tomcat版本
日志管理	集中于JAR运行日志	可复用Tomcat日志机制
资源占用	独立运行，资源可控	依赖Tomcat配置

构建WAR包示例（Maven）：

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

<packaging>war</packaging>

排除内嵌Tomcat依赖（可选）：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <scope>provided</scope>
</dependency>

构建WAR文件后，将其部署到外部Tomcat的 webapps 目录即可。

5.2 性能调优与日志管理

提升Spring Boot应用的性能和可维护性，需要从监控、缓存、连接池等多方面进行优化。

5.2.1 Spring Boot Actuator监控工具的使用

引入依赖：

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

在 application.properties 中启用所有端点（生产环境应谨慎开放）：

management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always

访问监控接口示例：

curl http://localhost:8080/actuator/health
curl http://localhost:8080/actuator/metrics

Actuator提供了对应用健康状态、线程、内存、GC等指标的实时监控，帮助开发者快速定位性能瓶颈。

5.2.2 配置缓存与数据库连接池优化

缓存配置（以Caffeine为例）：

引入依赖：

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>

启用缓存：

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

使用缓存注解：

@Cacheable("users")
public User getUserById(Long id) {
    return userRepository.findById(id).orElse(null);
}

数据库连接池优化（以HikariCP为例）：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# HikariCP配置
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.idle-timeout=30000
spring.datasource.hikari.max-lifetime=1800000

5.3 安全性与部署建议

保障Spring Boot应用的安全性是部署上线前不可忽视的环节，主要从HTTPS、安全头设置和防止Web攻击三方面着手。

5.3.1 启用HTTPS与配置SSL证书

生成自签名证书（测试用）：

keytool -genkeypair -alias myssl -keyalg RSA -keysize 2048 -storetype PKCS12 -keystore myssl.p12 -validity 3650

配置 application.properties 启用HTTPS：

server.port=8443
server.ssl.key-store=classpath:myssl.p12
server.ssl.key-store-password=123456
server.ssl.key-store-type=PKCS12
server.ssl.key-alias=myssl

5.3.2 配置安全头与防止常见Web攻击

引入Spring Security依赖：

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

配置安全头（如X-Content-Type-Options、X-Frame-Options等）：

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .headers(headers -> headers
                .contentSecurityPolicy("script-src 'self'")
                .and()
                .xssProtection(xss -> xss
                    .block(true))
                .and()
                .httpStrictTransportSecurity(hsts -> hsts
                    .maxAgeInSeconds(31536000)
                    .includeSubDomains(true))
            )
            .authorizeHttpRequests(auth -> auth
                .anyRequest().authenticated()
            )
            .formLogin(Customizer.withDefaults());
        return http.build();
    }
}

5.4 云平台部署实践

随着云原生技术的发展，越来越多的Spring Boot应用被部署到Docker容器或云平台中，以提升可移植性与弹性伸缩能力。

5.4.1 部署到Docker容器环境

编写Dockerfile：

FROM openjdk:17-jdk-slim
COPY target/myapp-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]

构建Docker镜像：

docker build -t myapp .

运行容器：

docker run -d -p 8080:8080 --name myapp-container myapp

5.4.2 在阿里云、AWS等云平台上运行Spring Boot应用

阿里云部署流程简述：

1. 将应用打包为Docker镜像。
2. 推送镜像到阿里云容器镜像服务。
3. 创建ECS实例并安装Docker。
4. 拉取镜像并启动容器。
5. 配置安全组和域名绑定。

AWS部署建议：

• 使用EC2实例部署Docker容器。
• 利用Elastic Load Balancing进行负载均衡。
• 使用RDS托管数据库服务。
• 配合CloudWatch进行日志和监控管理。

部署流程图如下（mermaid）：

graph TD
    A[本地开发] --> B(构建Docker镜像)
    B --> C(推送至云平台镜像仓库)
    C --> D{选择云平台}
    D -->|阿里云| E[创建ECS实例并运行]
    D -->|AWS| F[使用EC2 + ELB部署]
    E --> G[配置安全组与域名解析]
    F --> H[集成RDS + CloudWatch]

通过本章内容，我们了解了Spring Boot应用的打包方式、性能调优手段、安全加固措施以及云平台部署实践，为应用的上线和运维提供了完整的技术路径。

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

简介：Spring Boot + JSP Demo工程是一个基于Java的Web开发示例项目，展示了如何将Spring Boot框架与JSP技术结合，构建动态网页应用。Spring Boot提供自动配置、内嵌服务器和起步依赖等特性，提升开发效率；JSP则用于构建交互式前端页面。本项目涵盖Spring Boot与JSP的整合配置、控制器编写、视图解析配置以及项目的运行测试，适合Java Web初学者掌握Spring Boot与JSP协同开发的核心流程与实践技巧。

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