SpringBoot3教程：初学者快速上手指南-原创手记-慕课网

概述

本文提供了全面的SpringBoot3教程，涵盖了环境搭建、项目创建、核心特性和优势、基本配置、开发实践、测试方法以及打包部署等内容，帮助开发者快速掌握SpringBoot3的使用。从操作系统和工具安装到SpringBoot项目的快速创建，文章详细介绍了每一个步骤。SpringBoot3的自动配置、内置开发服务器和起步依赖等功能也得到了充分的讲解。最后，文章还介绍了如何测试和部署SpringBoot应用，确保应用在生产环境中的稳定运行。

SpringBoot3简介与环境搭建

什么是SpringBoot3

Spring Boot 3是由Spring团队开发的一个基于Spring框架的快速开发框架，旨在简化新Spring应用的初始搭建及开发过程。它允许开发者通过较少的代码来配置和运行一个独立的、生产级别的Spring应用。Spring Boot 3在Spring Boot 2的基础上进行了许多改进和优化，特别是在依赖管理和启动性能方面。它提供了自动配置、嵌入式服务器、集成第三方库等特性，使得开发者可以专注于业务逻辑，而不是配置细节。

Spring Boot 3的目标是尽可能减少基础配置，使开发者能够快速搭建一个可用的应用，同时提供良好的开发体验和生产环境的支持。

开发环境的搭建

操作系统与工具

操作系统：Windows, macOS, Linux
IDE：Eclipse, IntelliJ IDEA, VSCode
JDK版本：Java 17及以上版本
Maven或Gradle构建工具

安装JDK

下载JDK：访问Oracle官网或其他可信来源下载Java Development Kit（JDK）。
安装JDK：按照下载页面的指引进行安装，确保安装成功后环境变量已经配置好。
验证安装：打开命令行工具，输入java -version和javac -version命令，应该能看到安装的Java版本信息。

安装IDE

IntelliJ IDEA：
- 访问官网下载页面：https://www.jetbrains.com/idea/
- 下载并安装适合的操作系统版本。
- 安装完成后，可以设置软件的许可证（建议使用学生许可证，免费且长期有效）。
- 安装过程中可以选择安装Spring插件。
Eclipse IDE：
- 访问官网下载页面：https://www.eclipse.org/downloads/
- 下载并安装Eclipse IDE for Enterprise Java Developers。
- 安装完成后，需额外安装Spring工具插件，可在Eclipse市场中搜索并安装。

安装Maven或Gradle

Maven：
- 访问官网下载页面：https://maven.apache.org/download.cgi
- 下载并安装。
- 设置环境变量MAVEN_HOME和PATH。
- 验证安装：在命令行工具中输入mvn -v，若显示Maven版本信息，则安装成功。
Gradle：
- 访问官网下载页面：https://gradle.org/
- 下载并安装。
- 设置环境变量GRADLE_HOME和PATH。
- 验证安装：在命令行工具中输入gradle -v，若显示Gradle版本信息，则安装成功。

快速创建SpringBoot3项目

使用Spring Initializr

Spring Initializr是一个在线工具，可以帮助快速创建Spring Boot项目。步骤如下：
- 访问Spring Initializr官网：https://start.spring.io/
- 选择项目依赖：选择Java版本为17，Spring Boot版本为3.x，项目打包方式为Maven或Gradle，项目名称、所属组织等。
- 选择所需依赖：例如Web、JPA、Thymeleaf等。
- 生成项目：点击“Generate”按钮，下载生成的压缩包，解压后得到项目。
使用IDE插件
- IntelliJ IDEA：安装并启用Spring Initializr插件，新建项目时选择Spring Boot项目。
- Eclipse：通过Eclipse市场安装Spring Tool Suite插件，新建Spring Boot项目。

示例代码

使用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>demo</artifactId>
   <version>0.0.1-SNAPSHOT</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>
   <build>
       <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
           </plugin>
       </plugins>
   </build>
</project>

使用Gradle创建项目

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

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'

repositories {
   mavenCentral()
}

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

SpringBoot3的核心特性和优势

自动配置

Spring Boot的核心特性之一是自动配置。它通过注解和配置类来自动完成应用中常见的配置，使得开发者能够快速启动并运行应用。自动配置的主要机制是通过@EnableAutoConfiguration和@SpringBootApplication注解来实现的。

自动配置的原理

扫描依赖：Spring Boot会扫描应用中引入的依赖，如Spring Web、JPA等。
配置类：Spring Boot提供了许多配置类，这些类中定义了许多默认配置属性。
条件注解：通过@Conditional注解来决定某个配置是否应该被启用。例如，如果应用中引入了Spring Web依赖，那么Spring Boot将会自动配置一个Tomcat服务器。

实际应用

以下是一个简单的自动配置示例，演示如何使用Spring Boot的自动配置功能：

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

@SpringBootApplication
public class DemoApplication {

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

}

在这个示例中，@SpringBootApplication注解包含了@Configuration、@EnableAutoConfiguration和@ComponentScan三个注解。这意味着Spring Boot将会自动配置应用程序，扫描组件并启用自动配置。

依赖管理和起步依赖

Spring Boot使用Maven或Gradle来管理依赖和构建项目。它通过起步依赖（Starter Dependencies）来简化依赖管理。起步依赖是Spring Boot提供的一组预定义的依赖集合，可以帮助开发者快速集成第三方库。

起步依赖的使用

Web开发：spring-boot-starter-web包含了构建Web应用所需的所有依赖，如Spring MVC、Tomcat等。
数据访问：spring-boot-starter-data-jpa包含了JPA和Hibernate的依赖，简化了数据库访问。

示例代码

以下是一个使用Maven的pom.xml文件，演示如何使用起步依赖来添加Web开发功能：

<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>demo</artifactId>
    <version>0.0.1-SNAPSHOT</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>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </build>
</project>

这段代码中，spring-boot-starter-web依赖包含了构建Web应用所需的所有依赖。

内置开发服务器

Spring Boot内置了一个开发服务器（如Tomcat、Jetty等），能够直接运行应用，无需额外配置。这使得开发者能够快速启动并运行应用，进行调试和测试。

内置服务器的使用

在IDE中运行：在IDE中直接运行主类，例如使用@SpringBootApplication注解标注的DemoApplication类。
使用命令行：通过spring-boot:run命令在命令行中运行应用。

示例代码

以下是在IDE中运行Spring Boot应用的代码：

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

@SpringBootApplication
public class DemoApplication {

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

}

这段代码会启动内置的Tomcat服务器，并监听默认端口（通常为8080）。

SpringBoot3的基本配置

应用配置文件的使用

Spring Boot应用的配置主要通过配置文件来实现。常用的配置文件包括application.properties和application.yml。这些配置文件位于src/main/resources目录下，可以用来配置各种应用属性。

配置文件的基本格式

Properties格式：使用application.properties文件来配置属性。
YAML格式：使用application.yml文件来配置属性。

示例代码

以下是一个application.properties文件的示例，配置了应用的端口和日志级别：

server.port=8080
logging.level.root=WARN

以下是一个application.yml文件的示例，配置了应用的端口和日志级别：

server:
  port: 8080
logging:
  level:
    root: WARN

配置文件属性的覆盖与扩展

Spring Boot允许通过环境变量、命令行参数或外部文件来覆盖配置文件中的属性。

属性覆盖方式

环境变量：通过设置环境变量来覆盖属性，例如SERVER_PORT=8090。
命令行参数：通过命令行参数来覆盖属性，例如java -jar demo-0.0.1-SNAPSHOT.jar --server.port=8090。
外部配置文件：通过引入外部配置文件来覆盖属性，例如spring.config.location=classpath:custom.properties。

示例代码

以下是一个通过命令行参数覆盖属性的示例：

java -jar demo-0.0.1-SNAPSHOT.jar --server.port=8090

在这个示例中，命令行参数覆盖了application.properties文件中配置的端口号。

以下是通过环境变量覆盖属性的示例：

export SERVER_PORT=8090
java -jar demo-0.0.1-SNAPSHOT.jar

在这个示例中，环境变量覆盖了application.properties文件中配置的端口号。

SpringBoot3的常用开发实践

控制器开发与RESTful服务

控制器是Spring Boot应用中最常用的一种组件，用来处理HTTP请求。通过@RestController注解可以将一个类声明为控制器，并使用@RequestMapping和@GetMapping等注解来映射HTTP请求到具体的方法。

控制器开发的基本步骤

创建控制器类：使用@RestController注解标注控制器类。
定义请求处理方法：使用@RequestMapping或@GetMapping等注解映射HTTP请求到具体的方法。
处理请求：在请求处理方法中编写处理逻辑，返回响应。

示例代码

以下是一个简单的控制器示例，用于处理GET请求并返回JSON格式的数据：

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

@RestController
public class HelloController {

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

}

在这个示例中，HelloController类使用了@RestController注解来声明为控制器。hello方法使用了@GetMapping注解来映射/hello路径的GET请求，并返回一个字符串。

数据库集成与JPA操作

Spring Boot提供了对数据库的集成支持，使用JPA（Java Persistence API）来简化数据库操作。通过spring-boot-starter-data-jpa依赖可以快速集成数据库访问功能。

数据库集成的基本步骤

配置数据库连接：在application.properties或application.yml文件中配置数据库连接信息。
定义实体类：使用@Entity注解定义实体类，并映射到数据库表。
定义仓库类：使用@Repository注解定义仓库类，并继承JpaRepository接口。
编写数据库操作代码：在服务类中调用仓库类的方法进行数据库操作。

示例代码

以下是一个使用JPA进行数据库操作的示例：

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import java.util.List;

@SpringBootApplication
@EntityScan("com.example.demo.model")
public class DemoApplication {

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

    @Entity
    public static class User {
        @Id
        @GeneratedValue(strategy = GenerationType.AUTO)
        private Long id;
        private String name;
        private String email;

        public User() {}

        public User(String name, String email) {
            this.name = name;
            this.email = email;
        }

        public Long getId() {
            return id;
        }

        public String getName() {
            return name;
        }

        public String getEmail() {
            return email;
        }
    }

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

    @Service
    public static class UserService {
        private UserRepository userRepository;

        public List<User> findAllUsers() {
            return userRepository.findAll();
        }
    }
}

在这个示例中，定义了一个User实体类和一个UserRepository仓库类。在UserService服务类中，通过调用userRepository.findAll()方法来查询所有用户。

日志管理和异常处理

日志管理

Spring Boot提供了多种日志框架的支持，如Logback和Log4j。默认情况下，Spring Boot使用Logback作为日志框架，并通过application.properties或application.yml文件配置日志级别。

异常处理

Spring Boot支持通过全局异常处理器来集中处理异常。通过@ControllerAdvice注解可以定义全局异常处理器，并使用@ExceptionHandler注解处理具体的异常。

示例代码

以下是一个简单的全局异常处理器示例，用于处理NullPointerException和IllegalArgumentException：

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(NullPointerException.class)
    public ResponseEntity<String> handleNullPointerException() {
        return new ResponseEntity<>("Null pointer exception occurred", HttpStatus.INTERNAL_SERVER_ERROR);
    }

    @ExceptionHandler(IllegalArgumentException.class)
    @ResponseBody
    public String handleIllegalArgumentException(IllegalArgumentException e) {
        return "Illegal argument exception occurred: " + e.getMessage();
    }

}

在这个示例中，GlobalExceptionHandler类使用了@ControllerAdvice注解来声明为全局异常处理器。handleNullPointerException方法使用了@ExceptionHandler注解来处理NullPointerException异常，并返回一个HTTP响应。handleIllegalArgumentException方法也使用了@ExceptionHandler注解来处理IllegalArgumentException异常，并返回一个字符串。

SpringBoot3的测试方法

单元测试和集成测试

测试是软件开发过程中非常重要的一部分，Spring Boot支持多种测试方式，包括单元测试和集成测试。单元测试主要用于测试应用中的单个组件（如服务类），而集成测试则用于测试整个应用的功能。

单元测试的基本步骤

创建测试类：使用@SpringBootTest或@ComponentTest注解创建测试类。
定义测试方法：使用@Test注解定义测试方法。
编写测试代码：在测试方法中编写测试逻辑，使用断言库验证结果。

集成测试的基本步骤

创建测试类：使用@SpringBootTest注解创建测试类。
定义测试方法：使用@Test注解定义测试方法。
编写测试代码：在测试方法中编写测试逻辑，使用断言库验证结果。

示例代码

以下是一个简单的单元测试示例，用于测试UserService服务类：

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;

import java.util.List;

@SpringJUnitConfig
@SpringBootTest
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void testFindAllUsers() {
        List<User> users = userService.findAllUsers();
        Assertions.assertThat(users.size()).isEqualTo(3);
        for (User user : users) {
            Assertions.assertThat(user.getName()).isIn("John", "Jane", "Doe");
        }
    }

}

在这个示例中，UserServiceTest类使用了@SpringBootTest注解来声明为Spring Boot测试类，并通过@Autowired注解注入了UserService服务类。testFindAllUsers方法使用了@Test注解来定义测试方法，并通过断言库验证了结果。

测试SpringBoot应用的基本步骤

创建测试类：使用@SpringBootTest注解创建测试类。
定义测试方法：使用@Test注解定义测试方法。
编写测试代码：在测试方法中编写测试逻辑，使用断言库验证结果。

示例代码

以下是一个简单的集成测试示例，用于测试控制器的GET请求：

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
public class HelloControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testHelloController() throws Exception {
        String response = mockMvc.perform(get("/hello"))
                .andExpect(status().isOk())
                .andExpect(content().string("Hello, World!"))
                .andReturn().getResponse().getContentAsString();

        Assertions.assertThat(response).isEqualTo("Hello, World!");
    }

}

在这个示例中，HelloControllerTest类使用了@SpringBootTest注解来声明为Spring Boot测试类，并通过@Autowired注解注入了MockMvc对象。testHelloController方法使用了@Test注解来定义测试方法，并通过MockMvc对象发送GET请求，验证返回的结果。

SpringBoot3的打包与部署

打包SpringBoot应用

Spring Boot应用可以通过Maven或Gradle来打包成一个独立的可执行JAR文件。这个JAR文件包含了应用的所有依赖，可以在任何支持Java的环境中运行。

打包命令

使用Maven：mvn package命令会打包应用，并生成一个名为demo-0.0.1-SNAPSHOT.jar的文件。
使用Gradle：gradle build命令会打包应用，并生成一个名为build/libs/demo-0.0.1-SNAPSHOT.jar的文件。

示例代码

以下是一个使用Maven打包应用的命令：

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

运行这个命令后，会在target目录下生成一个JAR文件，例如demo-0.0.1-SNAPSHOT.jar。

应用的部署方式与注意事项

部署方式

本地运行：可以使用命令java -jar demo-0.0.1-SNAPSHOT.jar来启动应用。
Docker容器：可以使用Docker来部署应用，例如创建一个Docker镜像并运行容器。
云服务：可以将应用部署到云服务提供商的服务器上，例如AWS、阿里云、华为云等。

注意事项

依赖冲突：确保应用中的所有依赖不会产生冲突。
配置文件：确保生产环境下的配置文件已经正确配置。
日志监控：确保生产环境下的日志能够被正确收集和监控。
安全性：确保应用的安全性，例如使用HTTPS、限制访问等。

示例代码

以下是一个简单的Dockerfile示例，用于部署Spring Boot应用：

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

在这个示例中，Dockerfile指定了使用openjdk:17-jdk-alpine作为基础镜像，并将打包好的JAR文件复制到镜像中。最后，使用ENTRYPOINT指令指定如何启动应用。

通过以上步骤，你可以快速搭建和部署一个Spring Boot应用，并确保它能够稳定运行在生产环境中。