SpringBoot学习第一天：核心概念+面试考点+Bean生命周期详解

SpringBoot学习第一天：核心概念+面试考点+Bean生命周期详解

大家好，今天开启SpringBoot系列学习的第一天，也是入门最关键的一天。本文将围绕3个核心问题展开，不仅覆盖基础知识点，更融入面试高频考点、易错点，补充Bean生命周期结构图，适合零基础入门，也适合备考面试的同学查漏补缺，内容可直接复制发布到博客园，后续将持续更新系列学习内容~

一、什么是SpringBoot（基础+面试拓展）

首先明确核心定义：SpringBoot是基于Spring框架的快速开发脚手架，由Pivotal团队（后被VMware收购）研发，于2014年首次发布，核心目标是“简化Spring应用开发，快速构建生产级可用的应用”。

很多面试会问：“SpringBoot和Spring的区别是什么？”——这里重点记：SpringBoot不是新框架，而是Spring的“封装与加速工具”，它解决了Spring框架开发中“配置繁琐、依赖管理复杂、部署麻烦”的痛点，相当于给Spring套了一层“便捷外壳”，让开发者无需关注底层配置，专注业务逻辑开发。

1. 核心特性（面试高频考点）

• 约定大于配置（Convention Over Configuration）：这是SpringBoot的核心思想，默认提供一套合理的配置（无需XML配置），覆盖90%以上的开发场景，开发者只需在特殊场景下修改配置，大大减少配置工作量。
  面试延伸：“约定大于配置的优势是什么？”——减少配置冗余、降低学习成本、提升开发效率、避免配置冲突。

• 自动配置（AutoConfiguration）：SpringBoot启动时，会根据项目中引入的依赖，自动装配Spring容器中的Bean，无需手动配置。
  面试延伸：“自动配置的核心原理是什么？”（入门阶段先记结论，后续详解）：@EnableAutoConfiguration注解触发自动配置，通过SpringFactoriesLoader加载META-INF/spring.factories中的配置类，根据条件注解（@Conditional）判断是否需要实例化Bean。

• 内嵌容器：内置Tomcat（默认）、Jetty、Undertow等Web容器，无需额外部署容器，直接将项目打成Jar包，通过java -jar命令即可运行，简化部署流程。

• Starter场景启动器：一站式依赖管理，比如引入spring-boot-starter-web，就会自动导入Web开发所需的所有依赖（SpringMVC、Tomcat、Jackson等），杜绝手动导入依赖导致的版本冲突问题。
  面试延伸：“常用的Starter有哪些？”——spring-boot-starter-web（Web开发）、spring-boot-starter-jdbc（数据库访问）、spring-boot-starter-data-jpa（ORM框架）、spring-boot-starter-test（单元测试）。

• Actuator监控：开箱即用的应用监控功能，可查看应用健康状态、内存使用、请求链路等，方便生产环境排查问题。

2. 核心定位（面试必背）

- 微服务架构的基础框架（SpringCloud依赖SpringBoot实现）；
- Spring生态的快速入口（入门Spring生态，先学SpringBoot）；
- 企业级Java开发的主流选择（目前绝大多数Java后端项目采用SpringBoot开发）。

3. 面试易错点提醒

易错点1：SpringBoot是框架？错！SpringBoot是脚手架（工具），核心还是Spring框架。
易错点2：SpringBoot无需配置？错！是“默认零配置”，特殊场景（如数据库配置、端口配置）仍需手动修改application.yml/properties。

二、SpringBoot什么时候加载依赖（基础+面试细节）

SpringBoot的依赖加载并非“一次性加载”，而是分为构建期加载和运行期加载两个阶段，这是面试中常考的细节题，很多新手容易混淆两个阶段的作用。

1. 构建阶段（基于Maven/Gradle，项目编译打包时）

这个阶段的核心是“下载依赖、导入依赖、打包依赖”，与SpringBoot本身无关，是构建工具（Maven/Gradle）的作用。

• 依赖下载：当我们在pom.xml（Maven）中引入Starter或其他依赖后，点击“刷新项目”、执行mvn clean compile（编译）、mvn package（打包）命令时，Maven会从中央仓库下载对应的依赖包（.jar文件），存入本地仓库。

• 依赖导入：编译阶段，Maven会将下载好的依赖包，加入项目的classpath（类路径），让项目能够识别依赖中的类和方法。

• 依赖打包：执行打包命令时，Maven会将项目代码和所有依赖包，打成一个“胖Jar包”（FatJar），这个Jar包包含了应用运行所需的所有依赖，后续运行时无需额外引入依赖。

2. 运行阶段（应用启动时，SpringBoot核心作用）

当我们执行java -jar 项目.jar启动应用时，SpringBoot会触发依赖的加载和生效，具体流程如下（面试可直接背诵）：

1. 执行SpringApplication.run()方法，启动SpringBoot应用；

2. 加载项目中的配置文件（application.yml/properties、bootstrap.yml等）；

3. 扫描classpath下所有依赖包，识别依赖中的Bean定义、自动配置类；

4. @EnableAutoConfiguration注解触发自动配置，根据依赖类型，实例化对应的Bean；

5. 完成Bean的依赖注入，确保所有依赖的Bean都能正常使用；

6. 应用启动完成，依赖正式生效，支持业务逻辑运行。

3. 面试总结（一句话记牢）

- 依赖下载：构建期（刷新、编译、打包时）；
- 依赖载入JVM：运行期（应用启动时）；
- 依赖生效：运行期（容器初始化、自动配置完成后）。

4. 面试延伸题

问：“SpringBoot启动时，如何排除某个不需要的自动配置类？”
答：使用@SpringBootApplication注解的exclude属性，例如：@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})，排除数据库自动配置（适用于不需要数据库的项目）。

三、SpringBoot Bean生命周期（重点+面试高频+结构图）

SpringBoot的Bean生命周期，完全沿用Spring的Bean生命周期，核心分为5个阶段，是面试重中之重（几乎所有Java后端面试都会考），下面结合流程图、细节、面试考点详细讲解。

1. Bean生命周期完整结构图（面试画图题必备）

graph TD A[容器启动] --> B[Bean实例化（调用无参构造）] B --> C[Bean属性赋值（@Autowired/@Value）] C --> D[初始化前准备] D --> D1[执行Aware接口(BeanNameAware/ApplicationContextAware)] D1 --> E[Bean初始化（按顺序）] E --> E1[执行@PostConstruct注解方法] E1 --> E2[执行InitializingBean#afterPropertiesSet()] E2 --> E3[执行自定义init-method方法] E --> F[Bean使用阶段（容器运行中被调用）] F --> G[Bean销毁前准备] G --> G1[执行@PreDestroy注解方法] G1 --> G2[执行DisposableBean#destroy()] G2 --> G3[执行自定义destroy-method方法] G --> H[容器关闭，Bean被GC回收] ``` ```mermaid graph TD A[容器启动] --> B[Bean实例化（调用构造方法）] B --> C[Bean属性赋值（依赖注入）] C --> D[初始化前准备] D --> D1[执行Aware接口（BeanNameAware、ApplicationContextAware等）] D1 --> E[Bean初始化] E --> E1[执行@PostConstruct注解方法] E1 --> E2[执行InitializingBean接口的afterPropertiesSet()方法] E2 --> E3[执行自定义初始化方法（init-method）] E --> F[Bean使用阶段（容器运行中，被调用）] F --> G[Bean销毁前准备] G --> G1[执行@PreDestroy注解方法] G1 --> G2[执行DisposableBean接口的destroy()方法] G2 --> G3[执行自定义销毁方法（destroy-method）] G --> H[容器关闭，Bean被GC回收] ``` 说明：以上流程图覆盖Bean生命周期的完整流程，面试时能画出这个图，再结合下面的细节讲解，就能拿到满分。 ### 2\. 生命周期5个核心阶段（面试必背细节） #### 阶段1：实例化（Instantiation） 核心：Spring容器调用Bean的构造方法（无参构造为主），创建Bean的实例对象。 细节：此时Bean还未赋值，属性都是默认值（如String为null，int为0），还不能使用。 #### 阶段2：属性赋值（Population） 核心：Spring容器将依赖的Bean，通过@Autowired、@Value等注解，注入到当前Bean的属性中。 面试延伸：“依赖注入的方式有哪些？”——构造器注入、setter方法注入、字段注入（@Autowired），SpringBoot推荐使用构造器注入（更安全，避免循环依赖）。 #### 阶段3：初始化（Initialization） 核心：对Bean进行初始化，确保Bean能够正常使用，这是生命周期中最复杂的阶段，分为3个步骤（按顺序执行）： - 步骤1：执行Aware接口方法（如BeanNameAware、ApplicationContextAware），让Bean获取容器相关信息（如自身BeanName、Spring容器对象）。 - 步骤2：执行@PostConstruct注解标注的方法（JSR\-250规范），这是最常用的初始化方式，在属性赋值完成后执行。 - 步骤3：执行InitializingBean接口的afterPropertiesSet\(\)方法（Spring提供的接口），或自定义的初始化方法（通过init\-method配置）。 面试重点：@PostConstruct和afterPropertiesSet\(\)的执行顺序——@PostConstruct先执行，afterPropertiesSet\(\)后执行；两者的作用都是初始化Bean，推荐使用@PostConstruct（更简洁，无需实现接口）。 #### 阶段4：使用阶段（Usage） 核心：Bean初始化完成后，存入Spring容器（单例Bean存入容器缓存，多例Bean每次获取时重新创建），供项目中的其他Bean调用、使用，直到容器关闭。 #### 阶段5：销毁阶段（Destruction） 核心：Spring容器关闭时，对Bean进行销毁，释放资源，分为3个步骤（按顺序执行）： - 步骤1：执行@PreDestroy注解标注的方法（JSR\-250规范），在Bean销毁前执行，用于释放资源（如关闭数据库连接、关闭流）。 - 步骤2：执行DisposableBean接口的destroy\(\)方法（Spring提供的接口）。 - 步骤3：执行自定义的销毁方法（通过destroy\-method配置）。 ### 3\. 面试高频考点（必背） - 问：“单例Bean和多例Bean的生命周期区别？” 答：单例Bean：容器启动时创建，容器关闭时销毁，生命周期与容器一致；多例Bean：每次从容器中获取时创建，使用完成后由GC（垃圾回收）回收，与容器生命周期无关。 - 问：“Bean生命周期中，初始化和销毁的常用方式有哪些？” 答：初始化：@PostConstruct注解、InitializingBean接口、init\-method配置；销毁：@PreDestroy注解、DisposableBean接口、destroy\-method配置。 - 问：“Bean实例化和初始化的区别？” 答：实例化是创建Bean对象（调用构造方法），此时Bean未赋值；初始化是对实例化后的Bean进行赋值、初始化操作，确保Bean能正常使用。 ### 4\. 代码示例（直观理解，可直接复制运行） ```java import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; import org.springframework.beans.factory.BeanNameAware; import org.springframework.stereotype.Component; // 自定义Bean，演示生命周期 @Component public class UserBean implements BeanNameAware { private String username; // 1. 实例化：构造方法 public UserBean() { System.out.println("1. Bean实例化：调用无参构造方法"); } // 2. 属性赋值：依赖注入（模拟） public void setUsername(String username) { this.username = username; System.out.println("2. Bean属性赋值：username = " + username); } // 3. 初始化前：执行Aware接口方法 @Override public void setBeanName(String s) { System.out.println("3. 执行Aware接口：BeanName = " + s); } // 3. 初始化：@PostConstruct注解方法 @PostConstruct public void postConstruct() { System.out.println("4. 执行@PostConstruct：Bean初始化"); } // 3. 初始化：InitializingBean接口方法 @Override public void afterPropertiesSet() throws Exception { System.out.println("5. 执行afterPropertiesSet：Bean初始化完成"); } // 4. 使用阶段：自定义方法 public void use() { System.out.println("6. Bean使用阶段：username = " + username); } // 5. 销毁：@PreDestroy注解方法 @PreDestroy public void preDestroy() { System.out.println("7. 执行@PreDestroy：Bean准备销毁"); } }

运行结果（按生命周期顺序输出）：
1. Bean实例化：调用无参构造方法
2. Bean属性赋值：username = test
3. 执行Aware接口：BeanName = userBean
4. 执行@PostConstruct：Bean初始化
5. 执行afterPropertiesSet：Bean初始化完成
6. Bean使用阶段：username = test
7. 执行@PreDestroy：Bean准备销毁

第一天学习总结（面试速记版）

• SpringBoot：Spring的快速开发脚手架，核心是约定大于配置、自动配置，简化开发和部署。

• 依赖加载：构建期下载、导入、打包；运行期加载、生效，核心是自动配置触发依赖实例化。

• Bean生命周期（必背）：实例化 → 属性赋值 → 初始化（Aware→@PostConstruct→afterPropertiesSet） → 使用 → 销毁（@PreDestroy→destroy）。

✅ 本文为SpringBoot学习系列第一篇，后续将持续更新：自动配置原理、启动流程、Web开发、数据访问、异常处理等核心知识点，兼顾基础和面试，欢迎关注后续更新~
这里我准备了这个图以及自动装配的原理，同时这个图一定是要背住的，很多面试都会问，同时明天的话我会结合项目进行讲解原理，以及我们以实现一个增删改查为案例，能够更直观的看到流程

如果觉得内容有帮助，记得点赞、收藏，一起打卡SpringBoot学习！

（注：文档部分内容可能由 AI 生成）