万字长文解析Spring Boot权威教程：从入门到精通逐步掌握现代Java开发框架

Spring Boot 是 Spring 框架的子项目，旨在简化 Spring 应用的创建和开发。它通过“约定优于配置”的方式，极大地减少了开发人员的工作量，是构建生产级独立应用的理想选择。本文将为初学者提供一个全面的 Spring Boot 入门指南，覆盖从环境搭建到集成常见功能的各个方面。

---

🧑 博主简介：现任阿里巴巴嵌入式技术专家，15年工作经验，深耕嵌入式+人工智能领域，精通嵌入式领域开发、技术管理、简历招聘面试。CSDN优质创作者，提供产品测评、学习辅导、简历面试辅导、毕设辅导、项目开发、C/C++/Java/Python/Linux/AI等方面的服务，如有需要请站内私信或者联系任意文章底部的的VX名片（ID：gylzbk）

💬 博主粉丝群介绍：① 群内初中生、高中生、本科生、研究生、博士生遍布，可互相学习，交流困惑。② 热榜top10的常客也在群里，也有数不清的万粉大佬，可以交流写作技巧，上榜经验，涨粉秘籍。③ 群内也有职场精英，大厂大佬，可交流技术、面试、找工作的经验。④ 进群免费赠送写作秘籍一份，助你由写作小白晋升为创作大佬。⑤ 进群赠送CSDN评论防封脚本，送真活跃粉丝，助你提升文章热度。有兴趣的加文末联系方式，备注自己的CSDN昵称，拉你进群，互相学习共同进步。

1. 🌐 环境搭建

在开始之前，确保你已经安装了以下软件：

1. JDK 8 或更高版本：Spring Boot 需要 JDK 8 及以上版本的支持。你可以从 Oracle 官方网站 下载并安装 JDK。
2. Maven：项目构建工具，虽然可以选择 Gradle，不过本指南使用 Maven。你可以从 Maven 官方网站 下载并安装。
3. IDE：选择一个你喜欢的开发工具，例如 IntelliJ IDEA、Eclipse 或者 VSCode。这里推荐使用 IntelliJ IDEA，它对 Spring Boot 有很好的支持。

1.1 安装步骤

1.1.1 安装 JDK

从 Oracle 官方网站下载所需 JDK 并安装。安装完成后，配置 JAVA_HOME 环境变量，并在终端中运行以下命令，验证安装：

java -version

确保看到类似于以下输出：

java version "11.0.10" 2021-01-19 LTS

1.1.2 安装 Maven

下载 Maven 并安装，配置 MAVEN_HOME 环境变量。验证安装：

mvn -v

确保看到类似于以下输出：

Apache Maven 3.6.3

1.1.3 选择并安装 IDE

根据个人喜好选择合适的 IDE 并安装。这里推荐 IntelliJ IDEA，该 IDE 对 Spring Boot 有很好的支持。你可以从 IntelliJ IDEA 官方网站 下载并安装。

2. 📝 创建第一个 Spring Boot 应用

2.1 使用 Spring Initializr

Spring Initializr 是一个强大的在线工具，能够帮助我们快速生成 Spring Boot 项目。

1. 打开 Spring Initializr

2. 进行项目配置：

   • Project: Maven Project
   • Language: Java
   • Spring Boot: 使用最新稳定版本
   • Group: com.example
   • Artifact: demo
   • Name: demo
   • Description: Demo project for Spring Boot
   • Package name: com.example.demo
   • Packaging: Jar
   • Java: 11
   • 添加依赖：输入并选择以下依赖项：
     • Spring Web：构建 web, 包括 RESTful, 应用程序
     • Spring Data JPA：简化的JPA实现，提供了进程运行的对象-关系映射
     • MySQL Driver：MySQL 数据库驱动

3. 点击 Generate 按钮下载项目模板文件。

2.2 导入项目

下载并解压生成的项目文件，使用 IDE 导入项目。 Spring Boot 默认的项目结构如下：

demo
├── src/main/java
│   └── com/example/demo
│       ├── DemoApplication.java
│       └── controller
│       └── service
│       └── repository
├── src/main/resources
│   ├── application.properties
│   └── static
│   └── templates
└── src/test/java/com/example/demo
    └── DemoApplicationTests.java

2.3 启动应用程序

打开 DemoApplication.java，右键选择 “Run DemoApplication.main()” 启动项目。成功启动后，应该能够看到类似于以下的输出：

2021-03-18 11:11:11.111  INFO 12345 --- [           main] c.e.demo.DemoApplication                 : Started DemoApplication in 5.123 seconds (JVM running for 6.234)

3. 🗂 项目结构介绍

Spring Boot 项目的目录和文件结构设计非常合理，遵循了一套约定俗成的标准：

• src/main/java：存放 Java 源代码。
  • com.example.demo：主应用程序的包路径
    • DemoApplication.java：Spring Boot 应用的启动类
    • controller：放置用于处理客户端请求的控制器类
    • service：放置业务逻辑的实现类
    • repository：放置数据访问层的接口
• src/main/resources：放置配置文件和静态资源，如 HTML 模板、静态 CSS/JS 文件等
  • application.properties：Spring Boot 的主要配置文件
  • static：默认的静态文件目录
  • templates：存放 Thymeleaf 模板文件
• src/test/java：存放测试代码
  • com.example.demo：测试代码所在的包路径
    • DemoApplicationTests.java：测试类

4. ⚙️ 工程配置

Spring Boot 的所有配置文件都保存在 src/main/resources 目录下的 application.properties 或 application.yml 文件中。以下是一个典型的配置例子：

4.1 常见配置参数

4.1.1 服务器配置

# 服务器端口
server.port=8080

# 上下文路径
server.servlet.context-path=/demo

4.1.2 数据源配置

spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase
spring.datasource.username=myuser
spring.datasource.password=mypassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

• spring.datasource.url：数据库连接 URL
• spring.datasource.username：数据库用户名
• spring.datasource.password：数据库密码
• spring.datasource.driver-class-name：数据库驱动类名
• spring.jpa.hibernate.ddl-auto：定义 Hibernate 自动处理数据库表结构的策略
• spring.jpa.show-sql：打印 SQL 语句到控制台

4.2 配置文件格式

Spring Boot 支持两种配置文件格式：application.properties 和 application.yml。功能相同，开发者可以根据个人习惯选择。

4.2.1 properties 格式示例

spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase
spring.datasource.username=myuser
spring.datasource.password=mypassword

4.2.2 yml 格式示例

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydatabase
    username: myuser
    password: mypassword

5. 🌍 构建 RESTful Web 服务

接下来，我们将构建一个简单的 RESTful Web 服务，实现对用户对象的基本增删改查功能（CRUD）。

5.1 创建 Model 类

// src/main/java/com/example/demo/model/User.java
package com.example.demo.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import lombok.Data;

@Data
@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String name;
    private String email;
}

5.2 创建 Repository 接口

// src/main/java/com/example/demo/repository/UserRepository.java
package com.example.demo.repository;

import com.example.demo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

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

5.3 创建 Service 类

// src/main/java/com/example/demo/service/UserService.java
package com.example.demo.service;

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

import java.util.List;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

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

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

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

    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

5.4 创建 Controller 类

// src/main/java/com/example/demo/controller/UserController.java
package com.example.demo.controller;

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

import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

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

    @PostMapping
    public User saveUser(@RequestBody User user) {
        return userService.saveOrUpdateUser(user);
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        return userService.saveOrUpdateUser(user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

5.5 启动应用

创建好上述文件后，运行 DemoApplication.java 中的 main 方法，启动 Spring Boot 应用。访问 http://localhost:8080/api/users 应该能够查看到空列表，说明服务启动成功。

6. 🗃 数据访问

6.1 配置数据源

在 application.properties 文件中，配置数据库连接信息：

spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase
spring.datasource.username=myuser
spring.datasource.password=mypassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

6.2 数据库的 CRUD 操作

在数据访问层，我们使用了 Spring Data JPA 来操作数据库，该框架提供了类似 save(), findAll(), findById() 和 deleteById() 等方法，用来方便地进行增删改查操作。

7. 🌼 Spring Boot 与 Thymeleaf 集成

Spring Boot 自带了对 Thymeleaf 模板引擎的支持，使得开发者可以轻松地创建动态网页。

7.1 添加 Thymeleaf 依赖

在 pom.xml 文件中添加 Thymeleaf 依赖：

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

7.2 创建视图模板

在 src/main/resources/templates 目录下创建一个 index.html 文件：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Spring Boot Thymeleaf Example</title>
</head>
<body>
<h1>Welcome to Spring Boot with Thymeleaf</h1>
<form action="#" th:action="@{/saveUser}" th:object="${user}" method="post">
    <input type="text" th:field="*{name}" placeholder="Name" />
    <input type="text" th:field="*{email}" placeholder="Email" />
    <button type="submit">Save</button>
</form>
</body>
</html>

7.3 创建映射方法

在控制器中添加一个方法来映射到这个 Thymeleaf 模板：

// src/main/java/com/example/demo/controller/HomeController.java
package com.example.demo.controller;

import com.example.demo.model.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HomeController {

    @GetMapping("/")
    public String index(Model model) {
        model.addAttribute("user", new User());
        return "index";
    }
}

7.4 运行项目

启动项目并访问 http://localhost:8080/，应该能看到欢迎页面和表单。

8. 🔍 单元测试

通过单元测试，我们可以验证代码的正确性和稳定性。Spring Boot 提供了非常强大的测试支持。

8.1 添加 Spring Boot 测试依赖

在 pom.xml 文件中添加测试依赖：

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

8.2 创建测试类

可以在 src/test/java/com/example/demo 目录下创建测试类：

package com.example.demo;

import com.example.demo.model.User;
import com.example.demo.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;

@SpringBootTest
class DemoApplicationTests {

    @Autowired
    private UserService userService;

    @Test
    void contextLoads() {
    }

    @Test
    void testUserService() {
        User user = new User();
        user.setName("John Doe");
        user.setEmail("john@example.com");

        userService.saveOrUpdateUser(user);
        List<User> users = userService.getAllUsers();

        assertThat(users).isNotEmpty();
    }
}

8.3 运行测试

可以在 IDE 中右键点击测试类 DemoApplicationTests，选择运行测试。如果所有测试通过，那么就说明我们的代码没有问题。

9. 🔐 安全性配置

为了确保应用的安全性，Spring Boot 提供了 Spring Security，用于身份验证和授权保护。

9.1 添加 Spring Security 依赖

在 pom.xml 文件中添加 Spring Security 依赖：

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

9.2 配置安全性

创建安全配置类 SecurityConfig：

package com.example.demo;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home").permitAll()
                .anyRequest().authenticated()
            .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
            .and()
            .logout()
                .permitAll();
    }
}

9.3 添加登录页面

在 src/main/resources/templates 目录下创建一个 login.html 文件：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Login</title>
</head>
<body>
<h1>Login</h1>
<form th:action="@{/login}" method="post">
    <div>
        <label>Username: <input type="text" name="username" /></label>
    </div>
    <div>
        <label>Password: <input type="password" name="password" /></label>
    </div>
    <div>
        <button type="submit">Login</button>
    </div>
</form>
</body>
</html>

9.4 运行项目

启动项目并访问 http://localhost:8080/，你将看到登录页面，Spring Security 已经自动保护了我们的应用。

10. 🔧 常用工具和插件

在开发过程中，使用一些工具和插件可以提高效率。

10.1 Spring Boot DevTools

Spring Boot DevTools 提供了热部署功能，可以在 pom.xml 中添加：

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

10.2 Lombok

Lombok 可以简化 Java 代码，减少样板代码（如 Java Bean 中的 getters、setters、constructors 等等）。在 pom.xml 中添加 Lombok 依赖：

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>latest.release</version>
    <scope>provided</scope>
</dependency>

10.2.1 使用 Lombok 简化代码

使用 Lombok 注解创建实体类：

import lombok.Data;

@Data
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String name;
    private String email;
}

这里的 @Data 注解会自动生成 getters、setters、toString、equals 和 hashCode 方法。

10.3 Spring Boot Actuator

Spring Boot Actuator 提供了丰富的应用监控和管理功能，包括健康检查、指标统计、审计以及更多的端点配置。

10.3.1 添加 Actuator 依赖

在 pom.xml 文件中添加 Actuator 依赖：

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

10.3.2 启用 Actuator 端点

在 application.properties 中配置 Actuator：

management.endpoints.web.exposure.include=*

10.3.3 访问 Actuator 端点

启动应用并访问以下 URL 进行监控和管理：

• 健康检查: http://localhost:8080/actuator/health
• 指标: http://localhost:8080/actuator/metrics
• 环境信息: http://localhost:8080/actuator/env

10.4 使用 Spring Boot DevTools

Spring Boot DevTools 提供了热部署、自动重启等功能，提高开发效率。

10.4.1 添加 DevTools 依赖

在 pom.xml 文件中添加 DevTools 依赖：

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

10.4.2 使用 DevTools 热部署

添加完依赖后，Spring Boot 会自动检测代码变更并重启应用，实现热部署。

11. 📈 部署到生产环境

将开发好的 Spring Boot 应用部署到生产环境，是将项目真正投入使用的关键步骤。

11.1 使用 Maven 构建项目

通过 Maven 将 Spring Boot 项目打包成 JAR 文件：

mvn clean package

生成的 JAR 文件将在 target 目录下，以 demo-0.0.1-SNAPSHOT.jar 命名。

11.2 运行 JAR 包

使用以下命令运行生成的 JAR 文件：

java -jar target/demo-0.0.1-SNAPSHOT.jar

11.3 使用 Docker 容器化

将 Spring Boot 应用打包成 Docker 容器，以便于部署和管理。

11.3.1 创建 Dockerfile

在项目根目录下创建 Dockerfile 文件：

FROM openjdk:11-jre-slim
VOLUME /tmp
COPY target/demo-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

11.3.2 构建 Docker 镜像

运行以下命令构建 Docker 镜像：

docker build -t demo-app .

11.3.3 运行 Docker 容器

使用以下命令运行 Docker 容器：

docker run -p 8080:8080 demo-app

通过这种方式，可以将 Spring Boot 应用容器化，方便在任何支持 Docker 的环境中部署和运行。

12. 📌 实战示例

为了加深对 Spring Boot 的理解，我们通过一个完整的项目示例来串联前面学习的内容。

12.1 项目需求

构建一个简单的图书管理系统，包括以下功能：

1. 添加图书
2. 查询图书
3. 更新图书信息
4. 删除图书

12.2 项目结构

book-management
├── src/main/java
│   └── com/example/bookmanagement
│       ├── BookManagementApplication.java
│       ├── model
│       │   └── Book.java
│       ├── repository
│       │   └── BookRepository.java
│       ├── service
│       │   └── BookService.java
│       ├── controller
│       │   └── BookController.java
├── src/main/resources
│   ├── application.properties
│   └── templates
│       └── index.html
└── src/test/java/com/example/bookmanagement
    └── BookManagementApplicationTests.java

12.3 实现代码

12.3.1 Book Model

package com.example.bookmanagement.model;

import lombok.Data;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Data
@Entity
public class Book {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String title;
    private String author;
    private String isbn;
    private double price;
}

12.3.2 Book Repository

package com.example.bookmanagement.repository;

import com.example.bookmanagement.model.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
}

12.3.3 Book Service

package com.example.bookmanagement.service;

import com.example.bookmanagement.model.Book;
import com.example.bookmanagement.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class BookService {

    @Autowired
    private BookRepository bookRepository;

    public List<Book> getAllBooks() {
        return bookRepository.findAll();
    }

    public Book getBookById(Long id) {
        return bookRepository.findById(id).orElse(null);
    }

    public Book saveOrUpdateBook(Book book) {
        return bookRepository.save(book);
    }

    public void deleteBook(Long id) {
        bookRepository.deleteById(id);
    }
}

12.3.4 Book Controller

package com.example.bookmanagement.controller;

import com.example.bookmanagement.model.Book;
import com.example.bookmanagement.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import org.springframework.stereotype.Controller;

import java.util.List;

@Controller
@RequestMapping("/books")
public class BookController {

    @Autowired
    private BookService bookService;

    @GetMapping
    public String getAllBooks(Model model) {
        List<Book> books = bookService.getAllBooks();
        model.addAttribute("books", books);
        return "index";
    }

    @GetMapping("/{id}")
    @ResponseBody
    public Book getBookById(@PathVariable Long id) {
        return bookService.getBookById(id);
    }

    @PostMapping
    public String saveBook(@ModelAttribute Book book) {
        bookService.saveOrUpdateBook(book);
        return "redirect:/books";
    }

    @PutMapping("/{id}")
    @ResponseBody
    public Book updateBook(@PathVariable Long id, @RequestBody Book book) {
        book.setId(id);
        return bookService.saveOrUpdateBook(book);
    }

    @DeleteMapping("/{id}")
    @ResponseBody
    public void deleteBook(@PathVariable Long id) {
        bookService.deleteBook(id);
    }
}

12.3.5 Index HTML

在 src/main/resources/templates 目录下创建 index.html 文件：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Book Management</title>
</head>
<body>
<h1>Book Management System</h1>
<form action="#" th:action="@{/books}" th:object="${book}" method="post">
    <input type="text" th:field="*{title}" placeholder="Title" required />
    <input type="text" th:field="*{author}" placeholder="Author" required />
    <input type="text" th:field="*{isbn}" placeholder="ISBN" required />
    <input type="number" th:field="*{price}" placeholder="Price" step="0.01" required />
    <button type="submit">Save</button>
</form>
<table border="1">
    <thead>
        <tr>
            <th>Title</th>
            <th>Author</th>
            <th>ISBN</th>
            <th>Price</th>
        </tr>
    </thead>
    <tbody>
        <tr th:each="book : ${books}">
            <td th:text="${book.title}">Title</td>
            <td th:text="${book.author}">Author</td>
            <td th:text="${book.isbn}">ISBN</td>
            <td th:text="${book.price}">Price</td>
            <!-- 你可以在这里添加修改和删除的链接或按钮 -->
        </tr>
    </tbody>
</table>
</body>
</html>

12.4 运行项目

启动 BookManagementApplication 并访问 http://localhost:8080/books，你应该能看到一个简单的图书管理系统界面，可以进行图书的添加和查看。

13. 🛠 常见问题解决

13.1 常见错误及解决方案

13.1.1 程序启动错误

如果遇到启动错误，可能是以下原因：

1. 端口被占用：更改 application.properties 中的 server.port。
2. 数据库连接失败：检查配置文件中的数据库连接信息是否正确。
3. 依赖冲突：确认 pom.xml 中没有版本冲突的依赖。

13.1.2 数据库连接问题

如果数据库无法连接：

• 检查数据库服务是否启动。
• 确认数据库配置信息正确。
• 确认驱动程序版本与数据库版本兼容。

13.2 性能优化建议

13.2.1 使用 Spring Boot Actuator 监控

Spring Boot Actuator 提供丰富的监控和管理功能，可以帮助诊断和调优应用程序性能。

13.2.2 配置缓存

使用缓存，如 EhCache、Redis 等，可以显著提高读取性能，减少数据库访问次数。