10-SpringBoot 分类

SpringBoot自动装配原理

@SpringBootApplication注解是一个复合注解，包含@EnableAutoConfiguration注解,@EnableAutoConfiguration注解中会有@import注解。@import注解解析是在，inoverBeanfactoryPostProcess中解析注解。@import注解引入了AutoConfigurationImportSelector类

AutoConfigurationImportSelector 实现 DeferredImportSelector 接口：又2个比较重要的方法，一个是process() 方法目的是，会获取到META-INF/spring.factories中的配置类，EnableAutoConfiguration然后 @ConditionalOnClass加载配置类。一个是selectImports()会做一些排序，然后统一返回。

DeferredImportSelector接口重写 getImportGroup()

调用 getImportGroup() -> 返回 AutoConfigurationGroup.class
   ↓
 等Spring 延迟到所有 @Configuration 加载完后：
   ↓
创建 AutoConfigurationGroup 实例
   ↓
调用 Group.process() 
   ├── 读取 META-INF/spring.factories
   ├── 应用 @Conditional 过滤（部分）
   └── 收集所有配置类到 entries Map
   ↓
调用 Group.selectImports()
   ├── AutoConfigurationSorter 排序
   │   ├── @AutoConfigureOrder (数值越小越优先)
   │   ├── @AutoConfigureBefore (必须在此之前)
   │   └── @AutoConfigureAfter (必须在此之后)
   └── 返回排序后的 Entry 列表

Ms.Zyh2026/9/27大约 4 分钟

01-SpringBoot注册Bean的6种方式

一、常用注册Bean的6种方式

1.1 @Component及其派生注解

实现方式:在类上添加@Component、@Service、@Controller、@Repository等注解，配合@ComponentScan扫描包路径。

@Service
public class UserService {
    // 业务逻辑
}

Ms.Zyh2026/9/27大约 3 分钟

04-SpringBoot外置tomcat原理解析

一，SpringBoot外置tomcat原理解析

1.1 如何使用外置的tomcat

第一步：修改pom文件：

<!--打包方式  默认是jar-->
<packaging>war</packaging>
<!--让它不参与打包部署-->
<dependency>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <groupId>org.springframework.boot</groupId>
    <scope>provided</scope>
</dependency>

Ms.Zyh2026/9/27大约 6 分钟

05-SpringBoot自动装配原理

│  ┌──────────────────────────┐        
│  │   ImportSelector    │        │   Aware 接口家族         
│  │   (接口)            │            │  - EnvironmentAware       
│  │                     │                │  - BeanFactoryAware     
│  │ + selectImports()   │        │  - BeanClassLoaderAware
│  │					           |        │  - ResourceLoaderAware 
│  └──────────────────────────┘       
│             │ extends           
│             ▼                                             
│  ┌──────────────────────┐   
│  │           DeferredImportSelector                                    
│  │           (接口)                                                         
│  │                                                                          
│  │  + selectImports()          ← 继承自 ImportSelector    
│  │  + getImportGroup()         ← 新增方法                   
│  └──────────────────────┘   
│                        │ implements                            
│                        ▼                                        
│  ┌───────────────────────────┐   
│  │         AutoConfigurationImportSelector                
│  │         (类)  ★ 核心实现类                                
│  │                                                         
│  │  实现接口方法：                                          
│  │  ├── getImportGroup()           → 返回 AutoConfigGroup    
│  │  ├── selectImports()            → 实际不直接使用ConfigurationClassParser.java的processImports方法有体现       
│  │  ├── setEnvironment()           → EnvironmentAware       
│  │  ├── setBeanFactory()           → BeanFactoryAware   
│  │  ├── setBeanClassLoader()       → BeanClassLoaderAware 
│  │  └── setResourceLoader()        → ResourceLoaderAware 
│  │                                                         
│  │  内部类：★ 核心逻辑所在                            
│  │  └── AutoConfigurationGroup implements ImportGroup     
│  └──────────────────────────┘  
                              │
                              │ 内部类实现
                              ▼
┌──────────────────────────────┐
│                     DeferredImportSelector 内部                 
├───────────────────────────
│  ┌─────────────────────────┐   
│  │           ImportGroup (接口)                          
│  │                                                        
│  │  + process(metadata, selector)    ← 收集候选配置类   
│  │  + selectImports()                ← 排序并返回        
│  └─────────────────────────┘   
│                        │ implements                           
│                        ▼                                     
│  ┌─────────────────────────┐   
│  │         AutoConfigurationGroup                      
│  │         (静态内部类)                                
│  │                                                        
│  │  实现方法：                                           
│  │  ├── process(metadata, selector)                    
│  │  │   └── 读取 spring.factories / AutoConfiguration.imports
│  │  │   └── 应用 AutoConfigurationImportFilter 初步过滤  
│  │  │   └── 存入 autoConfigurationEntries 集合            
│  │  │                                                      
│  │  └── selectImports()                                
│  │      └── 按 @AutoConfigureBefore/After/Order 排序     
│  │      └── 返回排序后的 Entry 列表                       
│  │                                                         
│  │  内部属性：                                          
│  │  ├── autoConfigurationEntries (List)                   
│  │  └── entries (Map)                                    
│  └─────────────────────────┘   
│                                                                 
└─────────────────────────────┘

Ms.Zyh2026/9/27大约 13 分钟

06-SpringBoot自定义starter

在一个空Maven项目中，新增xxxx-spring-boot-starter和xxxx-spring-boot-autoconfigure两个模块，xxxx是你这个starter是做什么的，模块xxxx-spring-boot-starter主要是作依赖管理，外界使用我们自定义的starter只需要导入我们xxxx-spring-boot-starter模块即可。自定义的xxxx-spring-boot-autoconfigure模块，是我们编写自动注入的地方，需要引入了Spring的spring-boot-starter模块，这个模块在创建SpringBoot项目的时候会自动引入的，也是必须引入的，通过加载META-INF文件夹下的spring.factories文件完成自动配置的功能以及开箱即用的效果。

Ms.Zyh2026/9/27大约 3 分钟

07-SpringBoot事件监听

一，自定义事件

事件：

public class CustomEvent extends ApplicationEvent {
    private String name;
    public CustomEvent(Object source,String name) {
        super(source);
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

Ms.Zyh2026/9/27大约 8 分钟

08-Resilience4j

Resilience4j是一个轻量级、高性能并易于使用容错框架，设计灵感来源于Netflix 的Hystrix框架，采用广受欢迎的函数式编程风格。
第一步：导入jar
spring boot环境：

<!-- springboot3.x 使用resilience4j-spring-boot3-->
<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot2</artifactId>
    <version>2.3.0</version>
</dependency>

Ms.Zyh2026/9/27大约 14 分钟

02-SpringBoot的run方法

┌──────────────────────────────
│                           SpringApplication.run() 启动全链路                        
│                          (基于 Spring Boot 2.x / 3.x 核心逻辑)                     
└──────────────────────────────┘

  【阶段0：初始化与准备】
  │
  ├─ 1. new SpringApplication(primarySources)
  │      ├─ 推断 WebApplicationType (SERVLET/REACTIVE/NONE)
  │      ├─ 从 spring.factories 加载 BootstrapRegistryInitializer
  │      ├─ 从 spring.factories 加载 ApplicationContextInitializer
  │      └─ 从 spring.factories 加载 ApplicationListener
  │
  ├─ 2. run(args)
  │      ├─ 启动计时器 (StopWatch)
  │      ├─ 配置 Headless 属性
  │      ├─ 获取 SpringApplicationRunListeners (从 spring.factories 加载)
  │      └─ 调用 listeners.starting() 广播启动事件
  │
  ├─ 3. 准备 Environment 环境
  │      ├─ 创建 ApplicationArguments (封装命令行参数)
  │      ├─ 创建并配置 ConfigurableEnvironment
  │      │      ├─ 加载 PropertySource (系统属性、环境变量、配置文件等)
  │      │      └─ 调用 listeners.environmentPrepared() 广播环境就绪事件
  │      ├─ 绑定 spring.main.* 配置到 SpringApplication 自身
  │      └─ 打印 Banner (banner.txt / 控制台logo)
  │
  └─ 4. 创建 ApplicationContext (容器)
         ├─ 根据 WebApplicationType 决定创建类型：
         │      ├─ SERVLET    → AnnotationConfigServletWebServerApplicationContext 基于Servlet的Web应用启动Tomcat/Jetty/Undertow
         │      ├─ REACTIVE   → AnnotationConfigReactiveWebServerApplicationContext 于Reactive的Web应用Netty
         │      └─ NONE       → AnnotationConfigApplicationContext 非Web应用，不启动任何Web服务器
         └─ 调用 context.setEnvironment() 注入环境
	

  ══════════════════════════════════════════════════════════
  【阶段1：Context 刷新前准备】
  ══════════════════════════════════════════════════════════
  │
  ├─ 5. 执行 ApplicationContextInitializer
  │      └─ 对所有 Initializer 调用 initialize(context)（如设置 profile、添加转换器等）
  │
  ├─ 6. 调用 listeners.contextPrepared() 广播上下文准备完成事件
  │
  ├─ 7. 将 primarySources (主启动类) 注册为 BeanDefinition
  │      └─ 此时主类上的 @SpringBootApplication 注解生效，触发 @ComponentScan
  │
  └─ 8. 调用 listeners.contextLoaded() 广播上下文加载完成事件


  ═══════════════════════════════════════════════════════
  【阶段2：核心刷新 —— AbstractApplicationContext.refresh() (12个关键子步骤)】
  ══════════════════════════════════════════════════════════
  │
  ├─ 9.  refresh() 启动 (同步锁开始)
  │
  ├─ 10. prepareRefresh()
  │       ├─ 设置容器启动时间、状态标志
  │       └─ 初始化 PropertySources 占位符
  │
  ├─ 11. obtainFreshBeanFactory()
  │       └─ 刷新并获取 BeanFactory (DefaultListableBeanFactory)
  │
  ├─ 12. prepareBeanFactory(beanFactory)
  │       ├─ 设置 ClassLoader
  │       ├─ 添加 BeanPostProcessor (ApplicationContextAwareProcessor 等)
  │       └─ 忽略特定依赖接口（如 EnvironmentAware 不通过自动注入）
  │
  ├─ 13. postProcessBeanFactory(beanFactory)
  │       └─ 子类扩展点（如 Web 环境下注册 ServletContext 相关 Bean）
  │
  ├─ 14. invokeBeanFactoryPostProcessors(beanFactory)  ← 【你的第一阶段：BeanDefinition 注册】
  │       ├─ 执行 BeanDefinitionRegistryPostProcessor
  │       └─ 执行 BeanFactoryPostProcessor
  │              └─ 核心：ConfigurationClassPostProcessor
  │                     ├─ @ComponentScan 扫描包 → 生成 BeanDefinition
  │                     ├─ @Import / @ImportResource 解析
  │                     └─ @Bean 方法解析 → 生成 BeanDefinition
  │
  ├─ 15. registerBeanPostProcessors(beanFactory)
  │       └─ 注册所有 BeanPostProcessor（如 AutowiredAnnotationBeanPostProcessor）
  │
  ├─ 16. initMessageSource()   → 国际化资源初始化
  │
  ├─ 17. initApplicationEventMulticaster() → 事件广播器初始化
  │
  ├─ 18. onRefresh()  ← 【🔥 内嵌 Tomcat 启动点 —— 见下方详解 🔥】
  │       └─ 子类 (ServletWebServerApplicationContext) 重写
  │              └─ createWebServer() → 创建并启动 Tomcat
  │
  ├─ 19. registerListeners()
  │       └─ 将静态 ApplicationListener 注册到广播器
  │
  ├─ 20. finishBeanFactoryInitialization(beanFactory)  ← 【你的第二阶段：实例化非懒加载单例 Bean】
  │       ├─ 实例化所有非懒加载的单例 Bean（Service、DAO、Controller 等）
  │       ├─ 执行依赖注入 (属性填充)
  │       ├─ 执行初始化回调 (@PostConstruct、InitializingBean)
  │       └─ 注意：此时 DispatcherServlet 尚未实例化（默认懒加载）
  │
  └─ 21. finishRefresh()
          ├─ 清理资源缓存
          ├─ 初始化 LifecycleProcessor (启动所有 SmartLifecycle)
          ├─ 发布 ContextRefreshedEvent 事件
          └─ 调用 listeners.started() 广播启动完成事件


  ════════════════════════════════════════════════════════════════════════════════════
  【阶段3：启动后收尾】
  ════════════════════════════════════════════════════════════════════════════════════
  │
  ├─ 22. 调用 listeners.running() 广播运行中事件
  │
  └─ 23. 返回 ConfigurableApplicationContext (容器启动完成，阻塞主线程等待结束)

Ms.Zyh2026/9/27大约 24 分钟

03-SpringBoot内嵌tomcat原理解析

一，SpringBoot内嵌tomcat原理解析

【第1层】ServletWebServerApplicationContext.onRefresh()
         │
         ├── super.onRefresh()  // 空实现，留作扩展
         │
         └── createWebServer()  // ★ 核心方法
                  │
                  ▼
【第2层】createWebServer() 源码逻辑 (简化解构)
         ┌──────────────────────────────────────┐
         │   if (this.webServer == null) {                        │
         │       // 1. 获取 ServletWebServerFactory              │
         │       ServletWebServerFactory factory =               │
         │           getWebServerFactory();                      │
         │       // 2. 通过工厂创建 WebServer (此处启动Tomcat)   │
         │       this.webServer = factory.getWebServer(          │
         │           getServletContextInitializerBeans());       │
         │   }                                                    │
         │   // 3. 触发 ServletContext 初始化回调                 │
         │   initPropertySources();                               │
         └──────────────────────────────────────┘
                  │
                  ▼
【第3层】TomcatServletWebServerFactory.getWebServer() (真正启动)
         ┌─────────────────────────────────────┐
         │   1. 创建 Tomcat 原生对象                                   │
         │      Tomcat tomcat = new Tomcat();                         │
         │      tomcat.setBaseDir(baseDir);                           │
         │                                                             │
         │   2. 创建 Connector (默认协议: HTTP/1.1)                    │
         │      Connector connector = new Connector("HTTP/1.1");      │
         │      connector.setPort(port); // 从配置读取, 默认 8080     │
         │      tomcat.getService().addConnector(connector);          │
         │                                                             │
         │   3. 创建 Host + Context (应用上下文路径)                   │
         │      tomcat.addContext(contextPath, docBase);              │
         │                                                             │
         │   4. 准备 Servlet 容器初始化器 (包含 DispatcherServlet)     │
         │      for (ServletContextInitializer initializer :           │
         │           initializers) {                                  │
         │           // 注册 Servlet、Filter、Listener                │
         │           initializer.onStartup(servletContext);           │
         │      }                                                     │
         │      // 注意：此处只是注册了 DispatcherServlet 的配置，     │
         │      // 并未实例化 DispatcherServlet 对象                   │
         │                                                             │
         │   5. ★ 启动 Tomcat (核心启动命令) ★                         │
         │      tomcat.start();  // 启动后台线程监听端口              │
         │      // 此时端口已绑定，可接收HTTP请求                     │
         │                                                             │
         │   6. 返回 TomcatWebServer 对象（包装了原生 Tomcat）         │
         └────────────────────────────────────┘

Ms.Zyh2026/9/27大约 9 分钟