Spring Boot 基础教程

Spring Boot 基础教程

带你系统学习Spring Boot 3.5.6，结合JDK 25的新特性，从基础到实践，全面掌握Spring Boot开发技能。

章节规划

1. Spring Boot简介与环境搭建
2. 第一个Spring Boot应用
3. Spring Boot配置体系
4. Spring Boot Web开发
5. 数据库操作 - MyBatis篇
6. 数据库操作 - MyBatis-Plus篇
7. 数据库操作 - JPA篇
8. 服务集成与高级特性
9. 测试与部署

---

第1章：Spring Boot简介与环境搭建

1.1 什么是Spring Boot

Spring Boot是由Pivotal团队开发的Spring框架的子项目，它简化了Spring应用的初始搭建和开发过程。

通过自动配置、起步依赖等特性，Spring Boot让开发者能够快速构建独立运行的、生产级别的Spring应用。

Spring Boot 3.5.6基于Spring Framework 6.2.x，要求JDK 17及以上版本，我们将使用最新的JDK 25进行开发。

1.2 开发环境准备

• JDK 25：确保正确配置JAVA_HOME环境变量
• Maven 3.9.x 或 Gradle 8.7+
• IDE：IntelliJ IDEA 2025.2 或 Eclipse 2025-06
• 数据库：MySQL 8.4.6 或者 MySQL 9.4.0

1.3 环境验证

确认JDK安装成功：

java -version
# 应显示类似：openjdk version "25" 2025-09-16

确认Maven安装成功：

mvn -version
# 应显示Maven版本信息及正确的Java版本

---

第2章：第一个Spring Boot应用

2.1 项目创建

我们将使用Spring Initializr创建项目：

1. 访问 https://start.spring.io/
2. 选择：
   • Project: Maven
   • Language: Java
   • Spring Boot: 3.5.6
   • Group: com.lihaozhe
   • Artifact: springboot-tutorial
   • Name: springboot-tutorial
   • Description: First Spring Boot Application
   • Package name: com.lihaozhe
   • Packaging: Jar
   • Java: 25
3. 添加依赖：Spring Web
4. IntelliJ IDEA 创建工程
   
   

2.2 项目结构解析

生成的项目结构如下：

springboot-tutorial/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── lihaozhe/
│   │   │           └── SpringbootTutorialApplication.java
│   │   └── resources/
│   │       ├── application.yml
│   │       ├── static/
│   │       └── templates/
│   └── test/
│       └── java/
│           └── com/
│               └── lihaozhe/
│                   └── SpringbootTutorialApplicationTests.java
├── pom.xml
└── README.md

2.3 完整的pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <!-- 模型版本，固定为4.0.0 -->
  <modelVersion>4.0.0</modelVersion>

  <!-- 继承Spring Boot的父工程，统一管理依赖版本 -->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.5.6</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <!-- 项目基本信息 -->
  <groupId>com.lihaozhe</groupId>
  <artifactId>springboot-tutorial</artifactId>
  <version>1.0.0</version>
  <name>springboot-tutorial</name>
  <description>springboot-tutorial</description>

  <properties>
    <!-- JDK版本配置 -->
    <java.version>25</java.version>
  </properties>
  <dependencies>
    <!-- Spring Web Starter：包含Spring MVC和嵌入式Tomcat -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- lombok -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <optional>true</optional>
    </dependency>
    
    <!-- 读取配置文件 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-configuration-processor</artifactId>
      <optional>true</optional>
    </dependency>

    <!-- Spring Boot Test Starter：包含测试相关依赖 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <!-- 构建配置 -->
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <annotationProcessorPaths>
            <path>
              <groupId>org.projectlombok</groupId>
              <artifactId>lombok</artifactId>
            </path>
          </annotationProcessorPaths>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
          <excludes>
            <exclude>
              <groupId>org.projectlombok</groupId>
              <artifactId>lombok</artifactId>
            </exclude>
          </excludes>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

2.4 主程序类

package com.lihaozhe;

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

/**
 * Spring Boot应用的主入口类
 * -@SpringBootApplication 是一个组合注解，包含：
 *  - @SpringBootConfiguration：标记此类为配置类
 *  - @EnableAutoConfiguration：启用Spring Boot的自动配置机制
 *  - @ComponentScan：启用组件扫描，自动发现并注册Bean
 */
@SpringBootApplication
public class SpringbootTutorialApplication {

  /**
   * 程序入口方法
   *
   * @param args 命令行参数
   */
  public static void main(String[] args) {
    // 启动Spring Boot应用
    // SpringApplication.run()方法会创建Spring容器，启动嵌入式服务器
    SpringApplication.run(SpringbootTutorialApplication.class, args);
  }

}

2.5 创建第一个控制器

package com.lihaozhe.controller;

import org.springframework.web.bind.annotation.*;

/**
 * 第一个控制器类
 * -@RestController 是一个组合注解，包含：
 * - @Controller：标记此类为控制器
 * - @ResponseBody：将方法返回值直接作为HTTP响应体
 *
 * @author 李昊哲
 * @version 1.0.0
 */
@RestController
@RequestMapping("/hello")
public class HelloController {
  /**
   * 处理根路径的GET请求
   *
   * @return 响应消息
   */
  @GetMapping("/home")
  public String home() {
    // 返回简单字符串，将直接作为HTTP响应体
    return "Hello, Spring Boot 3.5.6!";
  }

  /**
   * 处理带路径变量的GET请求
   *
   * @param name 路径中的变量
   * @return 包含名称的问候消息
   */
  @GetMapping("/helloWithPath/{name}")
  public String helloWithPath(@PathVariable String name) {
    // 使用JDK 21引入的文本块特性，使字符串更易读
    return """
           Hello, %s!
           Welcome to Spring Boot 3.5.6 tutorial.
           """.formatted(name);
  }

  /**
   * 处理带查询参数的GET请求
   *
   * @param name 查询参数，可以为null
   * @return 包含名称的问候消息
   */
  @GetMapping("/greet")
  public String greet(@RequestParam(required = false) String name) {
    // 如果没有提供name参数，使用默认值
    String actualName = (name == null || name.isEmpty()) ? "Guest" : name;
    return "Greetings, " + actualName + "!";
  }
}

2.6 配置文件

application.properties（除springcloud工程外 单体 springboot工程使用的人已经不多了 不推荐 ）

# 服务器端口配置，默认为8080
server.port=8080

# 应用名称
spring.application.name=springboot-tutorial

# 日志级别配置
logging.level.root=INFO
logging.level.com.lihaozhe=DEBUG

application.yaml 或者 application.yml（推荐）

server:
  # 服务器端口配置，默认为8080
  port: 8080

spring:
  application:
    # 应用名称
    name: springboot-tutorial

# 日志级别配置
logging:
  level:
    root: INFO
    com:
      lihaozhe: DEBUG

2.7 前端页面

我们创建一个简单的HTML页面，放在src/main/resources/static目录下：

index.html

<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Spring Boot tutorial</title>
  <!-- 使用Tailwind CSS进行样式设计 -->
  <script src="https://cdn.tailwindcss.com"></script>
</head>
<body class="bg-gray-100 min-h-screen flex items-center justify-center">
<div class="bg-white p-8 rounded-lg shadow-lg max-w-md w-full">
  <h1 class="text-3xl font-bold text-center text-blue-600 mb-6">
    Spring Boot 3.5.6 tutorial
  </h1>

  <div class="mb-6">
    <p class="text-gray-700 mb-4">
      This is a simple Spring Boot application demonstrating basic features.
    </p>

    <div class="space-y-3">
      <a href="/hello/home" class="block px-4 py-2 bg-blue-500 text-white rounded hover:bg-blue-600 transition-colors text-center">
        Home
      </a>
      <a href="/hello/helloWithPath/World" class="block px-4 py-2 bg-green-500 text-white rounded hover:bg-green-600 transition-colors text-center">
        Hello World
      </a>
      <a href="/hello/greet?name=Spring" class="block px-4 py-2 bg-purple-500 text-white rounded hover:bg-purple-600 transition-colors text-center">
        Greet Spring
      </a>
    </div>
  </div>

  <div class="text-center text-gray-500 text-sm">
    <p>Running on Spring Boot 3.5.6 with JDK 25</p>
  </div>
</div>
</body>
</html>

2.8 测试类

package com.lihaozhe;

import static org.hamcrest.Matchers.equalTo;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;

/**
 * Spring Boot应用的测试类
 * - @SpringBootTest 表示这是一个Spring Boot测试类，会加载完整的应用上下文
 * - @AutoConfigureMockMvc 自动配置MockMvc，用于模拟HTTP请求
 */
@SpringBootTest
@AutoConfigureMockMvc
class SpringbootTutorialApplicationTests {

  /**
   * 注入MockMvc实例，用于模拟HTTP请求和验证响应
   */
  @Autowired
  private MockMvc mvc;

  /**
   * 测试根路径的GET请求
   */
  @Test
  void testHome() throws Exception {
    // 模拟GET请求访问根路径，并验证响应状态和内容
    mvc.perform(MockMvcRequestBuilders.get("/hello/home").accept(org.springframework.http.MediaType.TEXT_PLAIN))
        .andExpect(status().isOk())
        .andExpect(content().string(equalTo("Hello, Spring Boot 3.5.6!")));
  }

  /**
   * 测试带路径变量的请求
   */
  @Test
  void testHelloWithPath() throws Exception {
    mvc.perform(MockMvcRequestBuilders.get("/hello/helloWithPath/Test").accept(org.springframework.http.MediaType.TEXT_PLAIN))
        .andExpect(status().isOk())
        .andExpect(content().string(equalTo("Hello, Test!\nWelcome to Spring Boot 3.5.6 tutorial.\n")));
  }

  /**
   * 测试带查询参数的请求
   */
  @Test
  void testGreet() throws Exception {
    // 测试带参数的情况
    mvc.perform(MockMvcRequestBuilders.get("/hello/greet").param("name", "JUnit")
            .accept(org.springframework.http.MediaType.TEXT_PLAIN))
        .andExpect(status().isOk())
        .andExpect(content().string(equalTo("Greetings, JUnit!")));

    // 测试不带参数的情况
    mvc.perform(MockMvcRequestBuilders.get("/hello/greet")
            .accept(org.springframework.http.MediaType.TEXT_PLAIN))
        .andExpect(status().isOk())
        .andExpect(content().string(equalTo("Greetings, Guest!")));
  }
}

2.9 运行与测试

1. 运行应用：

   • 方式1：在IDE中运行SpringbootTutorialApplication类的main方法
   • 方式2：使用Maven命令：mvn spring-boot:run

2. 访问应用：

   • 打开浏览器，访问 http://localhost:8080/hello/home 查看根路径响应
   • 访问 http://localhost:8080/hello/helloWithPath/YourName 测试路径变量
   • 访问 http://localhost:8080/hello/greet?name=YourName 测试查询参数
   • 访问 http://localhost:8080/index.html 查看前端页面

3. 运行测试：

   • 在IDE中运行测试类
   • 或使用Maven命令：mvn test

2.10 开发思路总结

1. 项目初始化：使用Spring Initializr快速创建项目结构，选择合适的依赖
2. 主程序类：通过@SpringBootApplication注解标识，作为应用入口
3. 控制器开发：使用@RestController创建REST接口，通过@RequestMapping系列注解映射请求
4. 配置管理：使用application.properties配置应用参数
5. 前端页面：将静态资源放在static目录下，Spring Boot会自动映射
6. 测试策略：使用MockMvc模拟HTTP请求，验证接口功能

通过这个简单的示例，我们已经掌握了Spring Boot的基本开发流程。下一章我们将深入学习Spring Boot的配置体系。

---

第3章：Spring Boot配置体系

3.1 配置文件类型

Spring Boot支持多种配置文件格式，最常用的有两种：

• properties格式：传统的键值对格式
• YAML格式：层次结构清晰，更易读

3.1.1 YAML配置文件示例

​

3.1.2 两种配置文件的对比

特性	properties	YAML
语法	键值对，使用.分隔	层次结构，使用缩进
可读性	中等	高，尤其对于复杂配置
列表支持	繁琐	简洁
多环境支持	支持	支持
流行度	传统，应用广泛	现代，越来越流行

3.2 配置注入方式

Spring Boot提供了多种方式将配置注入到Bean中：

3.2.1 使用@Value注解

​

3.2.2 使用@ConfigurationProperties

​

3.2.3 配置注入控制器示例

​

3.3 多环境配置

Spring Boot支持为不同环境（开发、测试、生产等）提供不同的配置。

3.3.1 多环境配置文件命名

• 开发环境：application-dev.yml
• 测试环境：application-test.yml
• 生产环境：application-prod.yml

3.3.2 开发环境配置

​

3.3.3 生产环境配置

​

3.3.4 激活特定环境

在主配置文件中指定激活的环境：

# 在application.yml中添加
spring:
  profiles:
    active: dev  # 激活开发环境

或者通过命令行参数指定：

# 运行时指定生产环境
java -jar demo.jar --spring.profiles.active=prod

3.4 外部化配置

Spring Boot支持多种外部化配置方式，优先级从高到低：

1. 命令行参数
2. 操作系统环境变量
3. application-{profile}.properties/yaml
4. application.properties/yaml

3.4.1 命令行参数示例

# 运行时指定端口和环境
java -jar demo.jar --server.port=8888 --spring.profiles.active=test

3.4.2 环境变量示例

在Linux/Mac中：

# 设置环境变量
export SPRING_PROFILES_ACTIVE=prod
export SERVER_PORT=8081

# 运行应用
java -jar demo.jar

在Windows中：

# 设置环境变量
set SPRING_PROFILES_ACTIVE=prod
set SERVER_PORT=8081

# 运行应用
java -jar demo.jar

3.5 配置优先级演示控制器

​

3.6 本章pom.xml文件

​

3.7 前端页面展示配置信息

​

3.8 测试配置注入

​

3.9 开发思路总结

1. 配置文件选择：根据项目复杂度选择properties或YAML格式，复杂配置优先选择YAML
2. 配置注入策略 ：
   • 简单配置使用@Value注解
   • 复杂配置或相关配置组使用@ConfigurationProperties
3. 多环境管理 ：
   • 为不同环境创建独立配置文件
   • 通过spring.profiles.active指定激活环境
   • 敏感信息（如密码）应使用环境变量或配置中心
4. 配置优先级：了解不同配置方式的优先级，避免配置冲突
5. 配置验证：编写测试验证配置是否正确注入

通过本章学习，你应该掌握了Spring Boot的配置体系，能够根据实际需求选择合适的配置方式，并能灵活管理不同环境的配置。

---

第4章：Spring Boot Web开发

4.1 Spring Boot Web核心组件

Spring Boot Web基于Spring MVC，提供了以下核心组件：

• 控制器（Controller）：处理HTTP请求
• 处理器映射（Handler Mapping）：将请求映射到控制器方法
• 视图解析器（View Resolver）：解析视图
• 拦截器（Interceptor）：处理请求前后的逻辑
• 过滤器（Filter）：对请求进行过滤处理

4.2 RESTful API开发

RESTful API是一种软件架构风格，用于创建可扩展的Web服务。

4.2.1 创建实体类

​

4.2.2 创建服务层

​

​

4.2.3 创建REST控制器

​

4.3 请求参数处理

Spring Boot提供了多种处理请求参数的方式：

​

4.4 全局异常处理

​

​

4.5 数据验证

使用JSR-303/JSR-380进行数据验证：

​

​

4.6 本章pom.xml文件

​

4.7 前端页面测试REST API

​

4.8 测试Web控制器

​

4.9 开发思路总结

1. RESTful API设计：

   • 使用合适的HTTP方法（GET、POST、PUT、DELETE）表示操作类型
   • 使用URL路径表示资源
   • 使用HTTP状态码表示请求结果
   • 返回一致的JSON响应格式

2. 分层架构：

   • 控制器（Controller）：处理HTTP请求，返回响应
   • 服务层（Service）：包含业务逻辑
   • 实体类（Entity）：表示数据模型

3. 异常处理：

   • 使用@ControllerAdvice创建全局异常处理器
   • 自定义异常类表示特定业务异常
   • 返回包含详细信息的错误响应

4. 数据验证：

   • 使用JSR-303/JSR-380注解进行数据验证
   • 在控制器方法参数上使用@Valid触发验证
   • 统一处理验证失败的异常

5. 测试策略：

   • 使用@WebMvcTest测试控制器层
   • 使用MockMvc模拟HTTP请求
   • 使用Mockito模拟服务层依赖

通过本章学习，你应该掌握了Spring Boot Web开发的核心技能，能够设计和实现RESTful API，处理请求参数，进行数据验证，并编写相应的测试。

---

第5章：数据库操作 - MyBatis篇

5.1 MyBatis简介

MyBatis是一款优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。

Spring Boot通过spring-boot-starter-mybatis提供了对MyBatis的自动配置支持。

5.2 准备工作

5.2.1 创建数据库和表

首先，我们需要创建一个MySQL数据库和用户表：

​

5.2.2 配置文件

​

5.2.3 pom.xml文件

​

5.3 实现数据库操作

5.3.1 实体类

​

5.3.2 Mapper接口

​

5.3.3 Mapper XML文件

​

5.3.4 服务层

​

​

5.3.5 控制器

​

5.4 前端页面

​

5.5 MyBatis测试类

​

​

5.6 MyBatis分页查询实现

​

​

​

​

​

​

5.7 MyBatis动态SQL示例

​

​

​

​

5.8 开发思路总结

1. MyBatis核心组件

   • Mapper接口：定义数据库操作方法
   • Mapper XML文件：编写SQL语句，实现接口方法
   • SqlSession：MyBatis核心，用于执行SQL命令

2. 数据库操作最佳实践

   • 使用接口和XML分离的方式组织代码
   • 对数据库操作添加事务管理（@Transactional）
   • 对查询结果使用POJO对象封装
   • 使用resultMap定义结果映射关系
   • 对表字段和Java对象属性进行驼峰命名转换

3. 动态SQL使用场景

   • 多条件组合查询
   • 选择性更新字段
   • 动态生成排序和分页条件
   • 批量操作

4. 分页查询实现

   • 基于LIMIT关键字实现基础分页
   • 计算总记录数实现完整分页功能
   • 封装分页结果（当前页、每页条数、总记录数、总页数）

5. 测试策略

   • 对Mapper接口进行集成测试，验证SQL正确性
   • 对Service层进行单元测试，使用Mock隔离数据库
   • 测试异常情况和边界条件

通过本章学习，你应该掌握了Spring Boot整合MyBatis进行数据库操作的方法，包括基本CRUD操作、分页查询、动态SQL等核心功能，能够根据实际需求设计和实现数据库访问层。

第6章. MyBatis高级特性

6.1 MyBatis缓存机制

MyBatis提供了两级缓存机制，用于提高查询性能：

• 一级缓存：SqlSession级别的缓存，默认开启
• 二级缓存：Mapper级别的缓存，需要手动配置开启

​

​

​

6.2 MyBatis类型处理器

类型处理器用于Java类型与数据库JDBC类型之间的转换，MyBatis提供了默认的类型处理器，也支持自定义。

​

​

​

6.3 MyBatis调用存储过程

MyBatis支持调用数据库存储过程，适用于复杂的业务逻辑实现。

​

​

​

​

第7章. 项目整合与部署

7.1 整合Spring Security

为用户管理系统添加认证和授权功能。

​

​

7.2 项目打包与部署

​

​

​

第8章. 总结与扩展

8.1 项目总结

本项目实现了一个基于Spring Boot和MyBatis的用户管理系统，包含以下核心功能：

1. 基础CRUD操作：实现了用户的增删改查功能
2. 分页查询：支持按页获取用户数据，提高大数据量下的查询效率
3. 动态SQL：根据不同条件动态生成SQL语句，灵活应对复杂查询需求
4. 缓存机制：利用MyBatis的一级和二级缓存，减少数据库访问次数
5. 类型转换：通过自定义类型处理器，实现Java类型与数据库类型的灵活转换
6. 存储过程调用：演示了如何调用数据库存储过程处理复杂业务逻辑
7. 安全认证：整合Spring Security实现用户认证和权限控制
8. 项目部署：提供了生产环境配置和部署脚本

8.2 扩展方向

1. 添加Redis缓存：整合Redis实现分布式缓存，提高系统性能
2. 实现接口限流：使用令牌桶算法或漏桶算法，防止接口被恶意调用
3. 添加API文档：整合Swagger/OpenAPI，自动生成API文档
4. 实现数据导出：支持将用户数据导出为Excel或CSV格式
5. 添加全文搜索：整合Elasticsearch实现用户信息的全文检索
6. 实现异步任务：使用Spring的异步功能处理耗时操作
7. 添加消息队列：整合RabbitMQ或Kafka，实现系统解耦
8. 实现分布式事务：使用Seata等框架处理分布式环境下的事务一致性

通过本项目的学习，你应该掌握了Spring Boot整合MyBatis开发数据库应用的核心技能，能够根据实际需求进行扩展和优化，开发出高性能、可维护的企业级应用。