SpringBoot3学习：从入门到初级应用教程-原创手记-慕课网

概述

Spring Boot 3 学习涵盖了从环境搭建到项目部署的全过程，包括 Spring Boot 3 的新特性、与 Spring Boot 2 的区别、开发环境的配置及常用功能的实现。本文详细介绍了如何创建和运行 Spring Boot 3 项目，以及如何利用 Maven 或 Gradle 进行依赖管理和部署应用。

SpringBoot3简介

SpringBoot3的特点与优势

Spring Boot 3 是 Spring Boot 的最新版本，提供了许多新的特性和改进。以下是 Spring Boot 3 的一些重要特点和优势：

Java 17 支持：Spring Boot 3 完全支持 Java 17 及更高版本，这意味着开发者可以利用 Java 17 中的新功能，如模式匹配和密封类。
改进的启动时间：Spring Boot 3 通过优化启动过程，使应用程序的启动时间更快。
现代化的依赖管理：Spring Boot 3 使用 Spring Boot BOM（Bill of Materials）来管理依赖版本，简化了依赖管理。
增强的安全性：提供了更多的安全相关配置选项，帮助开发者构建更安全的应用程序。
改进的健康检查：增加了对更多健康检查的支持，帮助开发者更好地监控应用程序的健康状况。
改进的开发体验：Spring Boot 3 提供了更多的配置选项和工具集成，使得开发体验更加流畅。

SpringBoot3与SpringBoot2的区别

Spring Boot 3 相较于 Spring Boot 2 有一些重要的区别和改进，主要体现在以下几个方面：

Java 17 支持：Spring Boot 3 完全支持 Java 17 及更高版本，而 Spring Boot 2 最多支持 Java 11。
改进的启动时间：Spring Boot 3 通过优化启动过程，使应用程序的启动时间更快。
现代化的依赖管理：Spring Boot 3 使用 Spring Boot BOM 来管理依赖版本，而 Spring Boot 2 使用的是 Spring Boot 版本依赖。
增强的安全性：Spring Boot 3 提供了更多的安全相关配置选项，如内置的安全配置和改进的加密支持。
改进的健康检查：Spring Boot 3 增加了对更多健康检查的支持，帮助开发者更好地监控应用程序的健康状况。
改进的开发体验：Spring Boot 3 提供了更多的配置选项和工具集成，使得开发体验更加流畅。
Spring Data Commons 改进：Spring Boot 3 中的 Spring Data Commons 提供了新的特性，如改进的数据访问和查询支持。

这些改进使得 Spring Boot 3 更加现代化和强大，为开发者提供了更好的开发体验和应用程序性能。

如何搭建SpringBoot3开发环境

搭建 Spring Boot 3 开发环境需要以下几个步骤：

安装 Java 17 及更高版本：确保你的系统中安装了 Java 17 或更高版本。可以在命令行中运行 java -version 检查 Java 版本。
安装 Maven 或 Gradle：Spring Boot 支持 Maven 和 Gradle 作为构建工具。这里以 Maven 为例，首先确保你已经安装了 Maven。可以在命令行中运行 mvn -v 检查 Maven 版本。

安装 Spring Boot CLI（可选）：Spring Boot CLI 是一个命令行工具，可以帮助开发者快速创建和运行 Spring Boot 应用程序。可以通过以下命令安装：

curl -s https://api.adoptium.net/v3/bundle/releases/2022-09-21/ea/latest/adoptium?architecture=x64&heap_size=normal&image_type=jre&jvmVariant=hotspot&jvmVersion=17&operating_system=linux | tar -x -C /usr/local --strip-components=1 -z -v -f -

IDE 设置：推荐使用 IntelliJ IDEA 或 Eclipse，这些 IDE 提供了 Spring Boot 项目的模板和工具，帮助开发者更快地构建应用程序。在 IntelliJ IDEA 中，可以通过以下步骤创建一个新的 Spring Boot 项目：
- 打开 IntelliJ IDEA。
- 选择 File -> New -> Project。
- 选择 Spring Boot 项目模板。
- 输入项目名称和相关配置。
- 点击 Finish 完成项目创建。

创建 Spring Boot 项目：

使用命令行工具：

mvn io.spring.platform:start \
-Dplatform.version=SpringBoot3.0.0 \
-DarchetypeGroupId=org.springframework.boot \
-DarchetypeArtifactId=spring-boot-archetype \
-DarchetypeVersion=3.0.0 \
-DgroupId=com.example \
-DartifactId=hello-world \
-Dversion=1.0.0 \
-Dpackage=com.example.helloworld

使用 IntelliJ IDEA 或 Eclipse 创建 Spring Boot 项目模板。

配置项目：在 pom.xml 或 build.gradle 文件中配置项目依赖和设置。

Maven 示例：

<project xmlns="http://maven.apache.org/POM/4.0.0"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.example</groupId>
 <artifactId>hello-world</artifactId>
 <version>1.0.0</version>
 <parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>3.0.0</version>
 </parent>
 <dependencies>
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
 </dependencies>
</project>

Gradle 示例：

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

group 'com.example'
version '1.0.0'

repositories {
 mavenCentral()
}

dependencies {
 implementation 'org.springframework.boot:spring-boot-starter-web'
}

完成以上步骤后，你就成功搭建了 Spring Boot 3 的开发环境，可以开始编写和运行 Spring Boot 应用了。

SpringBoot3快速入门

创建第一个SpringBoot项目

创建第一个 Spring Boot 项目非常简单。以下是使用 IntelliJ IDEA 创建 Spring Boot 项目的步骤：

打开 IntelliJ IDEA：
- 打开 IntelliJ IDEA，并选择 File -> New -> Project。
选择 Spring Boot 项目模板：
- 在弹出的对话框中，选择 Spring Initializr。
- 在 Project SDK 中选择 Java 17 或更高版本。
填写项目基本信息：
- 输入项目名称，例如 hello-world。
- 选择项目语言为 Java。
- 选择项目打包方式为 Maven 或 Gradle。
选择依赖：
- 点击 Spring Web 依赖，选择 Spring Web 依赖，以便创建一个简单的 Web 应用程序。
创建项目：
- 点击 Finish 按钮，IntelliJ IDEA 将为你生成一个新的 Spring Boot 项目。

项目创建完成后，你将看到以下目录结构：

hello-world
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── helloworld
│   │   │               ├── Application.java
│   │   │               ├── HelloWorldController.java
│   │   └── resources
│   │       └── application.properties
└── pom.xml

其中，Application.java 是项目的主入口文件，HelloWorldController.java 是一个简单的控制器类，application.properties 是项目的配置文件。

Hello World应用实例

编写一个简单的 Hello World 应用程序，可以通过访问 /hello 端点来查看输出。

在 HelloWorldController.java 中编写控制器代码：

package com.example.helloworld;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloWorldController {

   @GetMapping("/hello")
   public String hello() {
       return "Hello, World!";
   }
}

在 Application.java 中启动 Spring Boot 应用：

package com.example.helloworld;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

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

运行项目：
- 在 IntelliJ IDEA 中，点击 Run 按钮运行项目，或者在终端中执行 mvn spring-boot:run。
- 打开浏览器，访问 http://localhost:8080/hello，可以看到输出 Hello, World!。

项目目录结构解析

Spring Boot 项目的目录结构如下：

hello-world
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── helloworld
│   │   │               ├── Application.java
│   │   │               ├── HelloWorldController.java
│   │   └── resources
│   │       └── application.properties
└── pom.xml

src/main/java：存放 Java 源代码文件，如控制器类、服务类和实体类。
src/main/resources：存放资源文件，如配置文件 application.properties。
pom.xml：项目的 Maven 配置文件，包含项目依赖、构建配置等信息。

通过这个目录结构，你可以更好地组织和管理代码，使得项目更加清晰易读。

SpringBoot3核心配置

使用application.properties配置文件

Spring Boot 使用 application.properties 文件进行配置。该文件位于 src/main/resources 目录下，用于设置应用程序的各种属性。以下是一个完整的 application.properties 文件示例，包括常用的配置属性：

示例代码：

# 服务器配置
server.port=8080
server.tomcat.max-threads=150

# 日志配置
logging.level.root=INFO
logging.file.name=application.log

# 数据库配置
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# 应用程序属性
app.name=My Application
app.version=1.0.0

通过上述配置，你可以自定义服务器端口、日志级别、数据库连接信息等。

使用YAML文件进行配置

除了 application.properties 文件，Spring Boot 还支持使用 YAML 文件进行配置。YAML 文件提供了更简洁的语法，适合复杂的配置场景。以下是一个完整的 application.yml 文件示例，包括常用的配置属性：

示例代码：

server:
  port: 8080
tomcat:
  max-threads: 150

logging:
  level:
    root: INFO
  file:
    name: application.log

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

app:
  name: My Application
  version: 1.0.0

这种配置方式使得配置文件更加简洁易读，特别适合复杂的配置场景。

自动配置原理

Spring Boot 的自动配置功能是其核心特性之一。通过自动配置，Spring Boot 能够根据类路径中的依赖关系，自动配置应用程序的各个部分。

自动配置的基本原理如下：

依赖检测：Spring Boot 会检测类路径中的依赖关系，识别出需要配置的组件，如数据库连接、Web 服务器等。
条件注解：使用条件注解（如 @ConditionalOnClass、@ConditionalOnProperty 等）来决定是否加载某个配置。
配置类：每个自动配置的组件都有一个对应的配置类，该类定义了自动配置的细节。
优先级：每个自动配置都有一个优先级，优先级高的配置会覆盖优先级低的配置。
配置覆盖：用户可以在 application.properties 或 application.yml 文件中覆盖自动配置的设置。

例如，如果项目中引入了 spring-boot-starter-web 依赖，Spring Boot 会自动配置 Spring MVC 和嵌入式 Tomcat 服务器。

示例代码：

package com.example.helloworld;

import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnClass({ DispatcherServlet.class })
public class WebAutoConfiguration {

    // 自动配置 Web 服务器的细节
    // ...
}

通过这种方式，Spring Boot 能够简化配置过程，使得应用程序更加易于管理和维护。

SpringBoot3常用功能

集成Spring MVC与RESTful API

Spring Boot 通过集成 Spring MVC 和 RESTful API，使得开发 Web 应用程序更加便捷。

创建控制器：

package com.example.helloworld;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloWorldController {

   @GetMapping("/hello")
   public String hello() {
       return "Hello, World!";
   }
}

配置 RESTful API：

package com.example.helloworld;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

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

访问 RESTful API：
- 启动应用程序后，打开浏览器访问 http://localhost:8080/hello，可以看到输出 Hello, World!。

通过这种方式，Spring Boot 自动配置了 Spring MVC 和 RESTful API，使得开发 Web 服务更加简单。

数据库连接与JPA操作

Spring Boot 通过集成 JPA（Java Persistence API）使得数据库操作更加简单。

引入依赖：

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
   <groupId>com.h2database</groupId>
   <artifactId>h2</artifactId>
   <scope>runtime</scope>
</dependency>

配置数据库连接：

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

创建实体类：

package com.example.helloworld.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class User {

   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
   private String name;
   private String email;

   // Getters and Setters
}

创建仓库接口：

package com.example.helloworld.repository;

import com.example.helloworld.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

创建服务类：

package com.example.helloworld.service;

import com.example.helloworld.entity.User;
import com.example.helloworld.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

   @Autowired
   private UserRepository userRepository;

   public User saveUser(User user) {
       return userRepository.save(user);
   }

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

创建控制器：

package com.example.helloworld;

import com.example.helloworld.entity.User;
import com.example.helloworld.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
public class UserController {

   @Autowired
   private UserService userService;

   @PostMapping("/users")
   public User saveUser(@RequestBody User user) {
       return userService.saveUser(user);
   }

   @GetMapping("/users/{id}")
   public User getUserById(@PathVariable Long id) {
       return userService.getUserById(id);
   }
}

通过以上步骤，你已经成功地使用 Spring Boot 和 JPA 进行了数据库操作。

异步处理与多线程支持

Spring Boot 通过集成 Spring Task 和 Threading API，提供了异步处理和多线程支持的功能。

引入依赖：

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

配置异步支持：

package com.example.helloworld;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableAsync
public class Application {

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

创建异步服务：

package com.example.helloworld.service;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsyncService {

   @Async
   public void performLongTask() {
       // 模拟长时间操作
       try {
           Thread.sleep(5000);
           System.out.println("Long task completed.");
       } catch (InterruptedException e) {
           Thread.currentThread().interrupt();
       }
   }
}

创建控制器调用异步服务：

package com.example.helloworld;

import com.example.helloworld.service.AsyncService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AsyncController {

   @Autowired
   private AsyncService asyncService;

   @GetMapping("/async-task")
   public String startAsyncTask() {
       asyncService.performLongTask();
       return "Async task started.";
   }
}

通过这种方式，Spring Boot 提供了异步处理和多线程支持，使得应用程序能够更好地利用系统资源。

SpringBoot3的依赖管理

使用Maven进行依赖管理

Spring Boot 使用 Maven 作为主要的构建工具，通过 pom.xml 文件进行依赖管理。

引入 Spring Boot 依赖：

<parent>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-parent</artifactId>
   <version>3.0.0</version>
</parent>

引入具体依赖：

<dependencies>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-jpa</artifactId>
   </dependency>
   <dependency>
       <groupId>com.h2database</groupId>
       <artifactId>h2</artifactId>
       <scope>runtime</scope>
   </dependency>
</dependencies>

通过这种方式，Spring Boot 通过父 POM 文件管理和版本控制依赖，简化了依赖管理过程。

使用Gradle进行依赖管理

Spring Boot 也支持使用 Gradle 进行依赖管理，通过 build.gradle 文件进行配置。

引入 Spring Boot 依赖：

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

引入具体依赖：

dependencies {
   implementation 'org.springframework.boot:spring-boot-starter-web'
   implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
   runtimeOnly 'com.h2database:h2'
}

通过这种方式，Spring Boot 使用 Gradle 的依赖管理功能管理项目的依赖和版本。

依赖启动器与常用依赖介绍

Spring Boot 提供了许多 “starter” 依赖，它们是一组预定义的依赖组合，使得开发过程更加简单。以下是常用的依赖启动器：

spring-boot-starter-web：

用于创建 Web 应用程序，包括 Spring MVC 和嵌入式 Web 服务器。

示例代码：

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

spring-boot-starter-data-jpa：

用于集成 JPA 和 Spring Data JPA，简化数据库操作。

示例代码：

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

spring-boot-starter-security：

用于安全相关的配置，如认证和授权。

示例代码：

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

spring-boot-starter-thymeleaf：

用于集成 Thymeleaf 模板引擎。

示例代码：

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

通过这些依赖启动器，Spring Boot 简化了项目的配置过程，使得开发者可以快速搭建和运行应用程序。

SpringBoot3项目部署

打包与发布SpringBoot应用

Spring Boot 应用可以通过 Maven 或 Gradle 打包为一个可执行的 JAR 或 WAR 文件。

使用Maven打包

mvn clean package

这将生成一个名为 target/hello-world-1.0.0.jar 的可执行 JAR 文件。

使用Gradle打包

./gradlew clean build

这将生成一个名为 build/libs/hello-world-1.0.0.jar 的可执行 JAR 文件。

部署在Tomcat服务器上

Spring Boot 应用默认使用嵌入式 Tomcat 服务器运行，但也可以部署在外部的 Tomcat 服务器上。

修改 pom.xml 或 build.gradle 文件：

移除 spring-boot-starter-web 依赖中的嵌入式 Tomcat 依赖。

添加 spring-boot-starter-tomcat 依赖。

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

打包为 WAR 文件：
- 修改 pom.xml 或 build.gradle 文件，将项目类型设置为 war。
- 使用 Maven 或 Gradle 打包为 WAR 文件。
```
mvn clean package
```
  或
```
./gradlew clean build
```
部署到外部 Tomcat 服务器：
- 将生成的 WAR 文件复制到 Tomcat 的 webapps 目录下。
- 启动 Tomcat 服务器。
- 访问部署的应用程序。

使用Docker部署

通过 Docker 部署 Spring Boot 应用可以提供更好的可移植性和一致性。

创建 Dockerfile：

# 使用官方 Java 镜像作为基础镜像
FROM openjdk:17-buster

# 设置工作目录
WORKDIR /app

# 将应用 JAR 文件复制到容器中
COPY target/hello-world-1.0.0.jar /app/app.jar

# 设置启动命令
ENTRYPOINT ["java", "-jar", "app.jar"]

构建 Docker 镜像：
```
docker build -t hello-world:1.0.0 .
```

运行 Docker 容器：

docker run -p 8080:8080 hello-world:1.0.0

通过这种方式，Spring Boot 应用可以方便地部署到任何支持 Docker 的环境中。

以上内容涵盖了从入门到高级应用的 Spring Boot 3 教程，通过上述步骤，你将能够熟练地使用 Spring Boot 3 创建和部署 Web 应用程序。