SpringBoot - 快速开发框架

• Spring 中配置类、@Bean、组件扫描的基本概念
• SpringMVC 中 WebMvcConfigurer、静态资源映射、Filter 的基础作用
• Maven 父工程、dependencyManagement 的基本含义
• MyBatis、数据源、数据库连接配置的基本概念

如果这些内容还不熟，建议先回看 11-Spring-IOC、13-Spring-MyBatis、14-SpringMVC 三章。

1.1 为什么需要 SpringBoot

前面我们已经学过 Spring、SpringMVC、MyBatis 以及它们之间的整合。真正让初学者头疼的，往往不是业务代码，而是“把项目搭起来”这件事：

所以，SpringBoot 的核心价值不是“替代 Spring”，而是让 Spring 生态更容易被使用。

1.2 核心思想：约定大于配置

SpringBoot 最重要的设计理念，就是“约定大于配置”。

它的意思不是不要配置，而是先给你一套合理默认值。只要你的项目遵守常见约定，很多事情框架就会直接帮你做掉；只有在默认值不满足需求时，开发者才自己覆盖。

传统方式                           SpringBoot 方式
-------------------------------------------------------------
手动注册数据源                     配置连接参数，自动创建 DataSource
手动整合 SpringMVC                 引入 starter 后自动准备 MVC 基础设施
手动引入一串依赖                   引入一个 starter 聚合依赖
手动部署到外部 Tomcat              内嵌 Tomcat，运行启动类或 java -jar

1.3 SpringBoot 到底帮我们省掉了什么

• 提供默认配置类、默认配置参数和默认目录约定
• 自动管理主流框架的依赖版本
• 自动完成大量常见 Bean 的注册
• 内嵌 Web 容器，降低部署门槛

1.4 本章小结

本章核心概念：SpringBoot 的目标不是替换 Spring，而是用默认约定、自动配置、依赖聚合和内嵌容器，把项目搭建和整合成本压下来。

2.1 创建 SpringBoot 工程

常见的创建方式有两种。

方式一：IDEA 中使用 Spring Initializr

1. File -> New -> Project
2. 选择 Spring Initializr
3. 填写 GroupId、ArtifactId、JDK、Spring Boot 版本
4. 勾选依赖，例如 Spring Web、MyBatis Framework、MySQL Driver
5. 完成创建

方式二：使用官网生成

访问 start.spring.io，选择版本与依赖后下载项目压缩包。

实战提示：如果课堂环境访问官方初始化站点较慢，可以切换到国内镜像源。

选择项目基础信息、JDK 和 Spring Boot 版本后，再继续勾选本次开发需要的依赖。

2.2 项目结构

springboot-demo/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/
│   │   │       └── DemoApplication.java
│   │   └── resources/
│   │       ├── application.yml
│   │       ├── static/
│   │       └── templates/
│   └── test/
└── pom.xml

其中最关键的目录有三个：

• java/：放启动类、Controller、Service、Mapper 等 Java 代码
• resources/：放配置文件、静态资源、模板文件
• test/：放测试代码

2.3 启动类

每个 SpringBoot 工程都需要一个启动类。它既是应用入口，也是自动配置的触发入口。

@SpringBootApplication
public class DemoApplication {

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

这里有三个要点：

1. 自定义类上加 @SpringBootApplication，它就成了启动类
2. 启动类必须包含 main 方法
3. 在 main 方法中调用 SpringApplication.run(...) 启动应用

2.4 @SpringBootApplication 是什么

它本质上是一个组合注解：

@SpringBootApplication
= @Configuration
+ @EnableAutoConfiguration
+ @ComponentScan

• @Configuration：说明这是一个配置类
• @EnableAutoConfiguration：开启自动配置
• @ComponentScan：扫描当前包及其子包中的组件

启动类建议放在项目根包下。这样默认扫描范围最合适，能覆盖项目中的 Controller、Service、Mapper 等组件。

2.5 第一个 Controller

@RestController
@RequestMapping("/hello")
public class HelloController {

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

这说明：只要 Web 相关依赖已经就位，SpringBoot 就能帮我们把请求分发、JSON 转换、内嵌 Tomcat 等基础设施准备好。

2.6 运行应用

# 方式一：IDEA 中直接运行 main 方法

# 方式二：Maven 方式运行
mvn spring-boot:run

# 方式三：打包后运行
mvn clean package
java -jar target/demo-0.0.1-SNAPSHOT.jar

2.7 本章小结

本章核心概念：创建 SpringBoot 项目时，最关键的入口是启动类；启动类一旦运行，SpringBoot 就开始做组件扫描和自动配置。

3.1 Parent 机制

SpringBoot 项目通常会继承如下父工程：

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

这个 Parent 的核心作用有三个：

• 统一管理大量主流依赖的版本
• 提供默认的 Maven 插件配置
• 约定常见构建参数，例如 Java 版本、编码等

3.2 为什么很多依赖可以不写版本

很多同学第一次看到下面这种写法会疑惑：为什么没写 version 也能用？

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
</dependency>

原因是 spring-boot-starter-parent 还会继续继承 spring-boot-dependencies，而这个依赖管理 POM 中通过 dependencyManagement 提前声明了很多依赖的版本。

你可以把这件事理解成：

• dependencyManagement 负责“统一声明版本”
• dependency 负责“真正引入 jar 包”

因此：

• 如果某个依赖版本已经在父工程的 dependencyManagement 中声明，子工程里可以省略 version
• 如果父工程没有管理这个依赖的版本，子工程就需要手动写 version

3.3 Starter 依赖是什么

SpringBoot 里非常常见的一类依赖叫 Starter。

通常在 SpringBoot 中，要使用某项技术，优先找它对应的 Starter。

3.4 为什么引入 Starter 就够了

一个 Starter 往往同时做两件事：

1. 聚合这项技术需要的一组依赖
2. 引入自动配置模块，把常用对象自动注册到 Spring 容器中

比如引入 mybatis-spring-boot-starter 后，往往会一起带来：

• mybatis
• mybatis-spring
• spring-jdbc
• 对应的自动配置能力

这就是为什么很多时候我们只需要“引一个 starter”，就能直接开始写业务代码。

3.5 本章小结

本章核心概念：Parent 解决的是“版本怎么统一管理”，Starter 解决的是“相关依赖怎么一起带进来，以及常用对象怎么自动准备好”。

4.1 默认配置文件

SpringBoot 约定的默认配置文件名称通常是：

• application.properties
• application.yml
• application.yaml

它们通常放在 src/main/resources/ 目录下。

4.2 properties 与 yml

properties 用的是 key=value 格式：

server.port=8080
spring.jackson.time-zone=GMT+8

yml 用的是层级结构：

server:
  port: 8080

spring:
  jackson:
    time-zone: GMT+8

对于多层对象和列表，YAML 往往更易读。

person:
  name: zhangsan
  age: 20

hobbies:
  - basketball
  - swim
  - coding

4.3 读取配置：@Value

如果只是读取少量单个配置项，可以使用 @Value。

@Component
public class AppConfig {

    @Value("${server.port}")
    private Integer port;

    @Value("${person.name}")
    private String name;
}

它适合简单场景，但当配置项较多、前缀一致时会显得零散。

4.4 批量绑定：@ConfigurationProperties

如果多个配置项属于同一组，推荐使用 @ConfigurationProperties。

@Component
@ConfigurationProperties(prefix = "person")
public class PersonProperties {
    private String name;
    private Integer age;
    // getter / setter
}

它的优势是：

• 可以按前缀一次性绑定一组配置
• 更适合封装成配置对象
• 代码可维护性更高

如果不希望这个类自己声明为组件，也可以在配置类上使用 @EnableConfigurationProperties 来统一启用。

4.5 常见配置项

server:
  port: 9111
  servlet:
    context-path: /demo2

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/demo_db?useUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456

  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8

这里最常见的三类配置分别是：

• server.*：服务端口、上下文路径等
• spring.datasource.*：数据源连接参数
• spring.jackson.*：JSON 时间格式、时区等

4.6 本章小结

本章核心概念：SpringBoot 默认会自动读取资源目录中的配置文件；单个属性适合用 @Value，一组相关属性更适合用 @ConfigurationProperties。

5.1 spring-boot-starter-web

如果项目要做 Web 开发，通常先引入：

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

这个 Starter 一般会带来：

• SpringMVC
• JSON 处理能力
• 内嵌 Tomcat

因此，很多 Web 项目不再需要外部单独部署 Tomcat，只要运行启动类或执行 java -jar 即可。

5.2 自定义 MVC 配置

大多数情况下，SpringBoot 已经把 SpringMVC 的默认配置准备好了。

如果你需要自定义拦截器、静态资源映射等，可以补充一个配置类：

@Configuration
public class WebConfiguration implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
    }

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
    }
}

这里体现的正是“约定大于配置”：默认能用，按需扩展。

5.3 静态资源处理

SpringBoot 对静态资源提供了默认支持，常见目录包括：

• classpath:/META-INF/resources/
• classpath:/resources/
• classpath:/static/
• classpath:/public/

如果默认规则不够用，也可以自己扩展：

@Configuration
public class WebConfiguration implements WebMvcConfigurer {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/pic/**")
                .addResourceLocations("file:d:/tmp/", "classpath:/custom-static/");
    }
}

也可以通过配置文件修改静态资源规则：

spring:
  web:
    resources:
      static-locations:
        - file:d:/tmp/
        - classpath:/custom-static/
  mvc:
    static-path-pattern: /pic/**

要注意两点：

• static-locations 可以配置多个资源目录
• 一旦显式改了这套配置，要清楚自己是在覆盖默认行为

5.4 Filter 注册

在 SpringBoot 中，Filter 既可以像传统 Web 项目一样写，也可以通过注册 Bean 的方式更灵活地控制路径和顺序。

public class MyFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain)
            throws ServletException, IOException {
        System.out.println("myFilter");
        filterChain.doFilter(request, response);
    }
}

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<MyFilter> myFilter() {
        FilterRegistrationBean<MyFilter> bean = new FilterRegistrationBean<>();
        bean.setFilter(new MyFilter());
        bean.addUrlPatterns("/*");
        bean.setOrder(2);
        return bean;
    }
}

这里可以控制：

• 拦截哪些路径
• 多个 Filter 的执行顺序

5.5 测试支持

SpringBoot 也提供了很方便的测试 Starter：

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

测试类一般写在 src/test/java 下：

@SpringBootTest
class DemoApplicationTests {

    @Test
    void contextLoads() {
    }
}

有了 @SpringBootTest 之后，可以直接基于 Spring 容器做集成测试。

下面这张图可以帮助你直观看到测试类所在包路径与启动类之间的典型组织方式：

5.6 本章小结

本章核心概念：引入 spring-boot-starter-web 后，SpringBoot 会把 Web 基础设施和内嵌 Tomcat 准备好；只有在默认配置不满足需求时，才补充 MVC、静态资源、Filter 等自定义配置。

6.1 引入依赖

<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>3.0.4</version>
</dependency>

<dependency>
  <groupId>com.mysql</groupId>
  <artifactId>mysql-connector-j</artifactId>
  <scope>runtime</scope>
</dependency>

6.2 为什么一启动就可能报错

很多同学第一次引入 mybatis-spring-boot-starter 后，会遇到启动报错。

根本原因通常不是 MyBatis 本身坏了，而是：

• Starter 已经触发了自动配置
• 自动配置过程中需要创建数据源
• 但你的数据库地址、用户名、密码还没有提供

所以数据源这部分参数必须由你自己补上。

6.3 配置数据源

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/cskaoyan_db?useUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456

SpringBoot 会根据这些参数自动创建数据源。默认常见实现是 HikariCP。

如果要切换数据源类型，也可以显式指定：

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

6.4 扫描 Mapper

除了数据源，还需要告诉 SpringBoot：Mapper 接口在哪个包下。

@SpringBootApplication
@MapperScan("com.example.mapper")
public class DemoApplication {
}

这里的包路径要写 Mapper 接口所在包，不要图省事直接写一个过大的顶层包。

6.5 使用 Mapper

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public User getById(Integer id) {
        return userMapper.selectById(id);
    }
}

6.6

如果要使用MyBatis的其他配置，可以在application配置文件中使用mybatis的前缀来配置

# mybatis. 做mybatis的配置
mybatis:
  configuration:
    lazy-loading-enabled: true
    cache-enabled: true

可以直接这样使用，是因为MyBatis提供了参数类，参数类注册为容器中的组件，使用了mybatis这样的前缀

@ConfigurationProperties(
    prefix = "mybatis"
)
public class MybatisProperties {}

6.7 本章小结

本章核心概念：SpringBoot 整合 MyBatis 的最短路径是“引 Starter、配数据源、扫 Mapper、直接注入使用”。启动报错往往来自数据源参数缺失，而不是 Starter 不能用。

7.1 自动配置是什么

自动配置就是：SpringBoot 在启动阶段，根据你引入的依赖、当前类路径中的类、配置文件中的参数，判断哪些配置类应该生效，然后把对应的 Bean 自动注册到 Spring 容器里。

所以“自动配置”不是魔法，而是“按条件决定注册哪些配置类”。

7.2 从启动类到自动配置

可以把自动配置入口理解成下面这条链：

@SpringBootApplication
    -> @EnableAutoConfiguration
        -> @Import(AutoConfigurationImportSelector.class)
            -> 读取自动配置清单
            -> 按条件筛选可用配置类
            -> 导入并注册这些配置类

7.3 spring.factories 与 AutoConfiguration.imports

自动配置要先解决一个问题：框架怎么知道“有哪些自动配置类可选”？

答案是在自动配置模块的 META-INF 目录下放特殊清单文件。

常见有两种形式：

• 老一些的写法：spring.factories
• 新一些的写法：META-INF/spring/...AutoConfiguration.imports

它们的共同目标都是：列出一批自动配置类的全限定类名，供 SpringBoot 启动时读取。

下面这个例子展示的是新一些的 AutoConfiguration.imports 形式：

而下面这个例子展示的是较早期常见的 spring.factories 形式：

7.4 自动配置的加载过程

SpringBoot 启动时，大致会做这些事：

1. 读取自动配置清单文件中的类名
2. 逐个检查这些配置类上的条件注解
3. 只有条件满足的配置类才会生效
4. 生效的配置类再向 Spring 容器中注册 Bean

也就是说，Starter 并不是“无脑全部生效”，而是“候选配置很多，最终按条件生效”。

7.5 常见条件注解

示例：

@Configuration
@ConditionalOnClass(DataSource.class)
@ConditionalOnMissingBean(DataSource.class)
public class DataSourceAutoConfiguration {
}

这段配置的含义是：

• 类路径里得先有 DataSource
• 容器里当前还没有自己定义的 DataSource

只有都满足，SpringBoot 才会帮你自动配置数据源。

7.6 为什么开发者能覆盖默认配置

SpringBoot 自动配置从来不是强行写死的。开发者一般可以通过两种方式覆盖它：

1. 在配置文件中修改参数
2. 自己声明同类型 Bean，让默认配置“让位”

例如：

server:
  port: 9090

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/custom_db

7.7 本章小结

本章核心概念：自动配置的本质是“读取候选配置类清单 + 结合条件注解筛选 + 把满足条件的配置导入容器”。Starter 之所以好用，核心就在于它背后通常带着自动配置模块。

8.1 什么是 Profile

Profile 是 Spring 用来区分不同运行环境配置的一种机制，常见环境有：

• 开发环境 dev
• 测试环境 test
• 生产环境 prod

它的目的很直接：不要把不同环境的配置全堆在同一个文件里。

8.2 常见命名方式

resources/
├── application.yml
├── application-dev.yml
├── application-test.yml
└── application-prod.yml

一般约定：

• application.yml 放公共配置
• application-{profile}.yml 放环境专属配置

8.3 激活方式

方式一：在主配置文件中激活

spring:
  profiles:
    active: dev

方式二：命令行激活

java -jar app.jar --spring.profiles.active=prod

方式三：IDEA 运行参数激活

在运行配置中加入：

-Dspring.profiles.active=dev

8.4 配置覆盖关系

同名配置项出现冲突时，环境配置会覆盖主配置。

application-{profile}.yml > application.yml

除了配置文件外，@Profile 还可以直接标在类或方法上，让某些 Bean 只在指定环境下生效。

8.5 本章小结

本章核心概念：Profile 的作用是把不同环境的配置隔离开，避免开发、测试、生产混在一起。激活某个环境后，SpringBoot 会优先加载并覆盖对应环境的配置。

9.1 开启定时任务

SpringBoot 中使用定时任务，先开启调度支持：

@SpringBootApplication
@EnableScheduling
public class DemoApplication {

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

9.2 定义任务

@Component
public class ScheduledTasks {

    @Scheduled(cron = "0 * * * * ?")
    public void task1() {
        System.out.println("每分钟执行一次");
    }

    @Scheduled(fixedRate = 5000)
    public void task2() {
        System.out.println("每 5 秒按固定频率执行");
    }

    @Scheduled(fixedDelay = 5000)
    public void task3() {
        System.out.println("上一次结束 5 秒后再执行");
    }
}

三种常见方式分别表示：

• cron：按表达式调度
• fixedRate：按固定频率执行
• fixedDelay：上次结束后延迟多久再执行

9.3 Cron 表达式

Cron 常见顺序是：

秒 分 时 日 月 周

常见示例：

一些常见符号含义：

• *：任意值
• ,：枚举多个值
• -：范围
• /：步进

9.4 本章小结

本章核心概念：SpringBoot 中使用定时任务并不复杂，关键是先开启 @EnableScheduling，再根据业务需要选择 cron、fixedRate 或 fixedDelay。

<!-- 实战练习内容已分离到 practices/15-spring-boot-practice.md -->

建议先完成本章重点内容复习，再进入配套练习。 练习建议按照：基础 -> 进阶 -> 综合挑战 的顺序完成。

• 能解释 SpringBoot 为什么出现，以及“约定大于配置”解决了什么问题
• 能创建 SpringBoot 工程、写启动类并跑起来
• 能说清 Parent、dependencyManagement 和 Starter 的关系
• 能使用 application.yml / application.properties，并理解 @Value 与 @ConfigurationProperties
• 能完成 SpringMVC、MyBatis、测试框架的基础整合
• 能说明自动配置的入口、清单文件和条件注解
• 能完成 Profile 多环境配置和定时任务的基本使用
• 能在项目中定位常见的启动、配置和依赖问题