springboot自动配置原理

1. SpringBoot的自动配置指的是啥

SpringBoot的自动配置：指SpringBoot可以根据应用程序导入的依赖和运行环境，自动配置 Spring 应用程序的组件，从而减少开发者手动配置的工作量。

// 这是一个springboot程序的主启动类
@SpringBootApplication
public class SpringsecurityApplication {
	
	public static void main(String[] args) {
		SpringApplication.run(SpringsecurityApplication.class, args);
	}
	
}

2. 前置知识补充

2.1 ApplicationContext

ApplicationContext(应用上下文)：是 Spring 框架的核心接口之一，它负责在应用运行时管理 Bean 的创建(初始化)、配置、依赖注入以及生命周期，它继承了 BeanFactory 接口，并提供了更丰富的功能，包括国际化支持、事件传播、AOP支持等。

• BeanFactory：默认 懒加载（Lazy Initialization），只有获取 Bean 时才初始化。
  基础容器，提供最基本的依赖注入能力（支持懒加载）。
  只管理 Bean 的生命周期和基础配置。

• ApplicationContext：默认 立即加载（Eager Initialization），启动时预初始化单例 Bean，更早暴露配置问题。是 BeanFactory 的子接口，在基础 DI 功能上扩展了企业级特性：
  ✅ 事件发布机制（ApplicationEventPublisher）
  ✅ 国际化（MessageSource）
  ✅ 资源访问（ResourceLoader）
  ✅ 与 AOP、事务等模块无缝集成
  ✅ 注解支持（如 @Autowired、@Transactional）

Spring时期，是怎么使用ApplicationContext的。

// 假设我们有一个名为 beans.xml 的配置文件，里面定义了一些 Bean：
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">
 
    <bean id="myBean" class="com.example.MyBean"/>
</beans>

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

// 在 Java 代码中，我们可以通过 ClassPathXmlApplicationContext 来加载这个 XML 配置文件，并初始化 ApplicationContext。
// ClassPathXmlApplicationContext 会从类路径下加载 beans.xml 配置文件，并根据文件中的定义创建相应的 Bean。
// 通过 getBean() 方法获取容器中的 Bean 实例。

public class MyApp {
    public static void main(String[] args) {
        // 加载配置文件，初始化 Spring 容器
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
 
        // 获取 Bean
        MyBean myBean = (MyBean) context.getBean("myBean");
 
        // 使用 Bean
        myBean.someMethod();
    }
}

SpringBoot时期，是怎么使用ApplicationContext的。

// Spring Boot 会自动配置并初始化 ApplicationContext，开发者不需要显式创建它。你通常会通过注入依赖（使用 @Autowired）来访问容器中的 Bean，而无需手动获取 ApplicationContext。
@SpringBootApplication
public class MySpringBootApp {
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApp.class, args);
    }
}

// 来看看 SpringApplication.run(MySpringBootApp.class, args); 做了什么？？？？
// SpringApplication.run()，这是一个静态方法。SpringApplication是一个类，run方法是他的静态方法。方法需要2个参数，会返回一个ConfigurableApplicationContext对象(继承ApplicationContext接口)：
//     方法作用：使用指定的源，运行SpringbootApplication。                   ====================== (源码对其的定义：使用指定的源，运行SpringbootApplication) ======================
//     参数一：Class<?>类型的对象。                                        ====================== (源码对其的定义：要加载的主要源) ======================
//     参数二：是一个可变参数，表示可以传入零个或多个 String 类型的参数。        ======================（源码对其的定义：application的参数）======================
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
	return run(new Class<?>[] { primarySource }, args);  // 可以看到这个静态方法，又调用了一个run方法
}

// 可以看到上述方法又调用了这个run方法，而这个run方法，会先创建一个SpringApplication对象，并调用他的run方法
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
	return new SpringApplication(primarySources).run(args);
}

// 这个方法的作用是创建并且刷新一个新的ApplicationContext（来自代码源码的解释）
public ConfigurableApplicationContext run(String... args) {
    long startTime = System.nanoTime();
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    ConfigurableApplicationContext context = null;
    configureHeadlessProperty();
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting(bootstrapContext, this.mainApplicationClass);
    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
        configureIgnoreBeanInfo(environment);
        Banner printedBanner = printBanner(environment);  // =========== 打印springboot启动的那个banner =============
        context = createApplicationContext();  // =========== 创建一个还没刷新的application =============
        context.setApplicationStartup(this.applicationStartup);
        prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
        refreshContext(context); // =========== 刷新application =============
        afterRefresh(context, applicationArguments);
        Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
        }
        listeners.started(context, timeTakenToStartup);
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, listeners);
        throw new IllegalStateException(ex);
    }
    try {
        Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
        listeners.ready(context, timeTakenToReady);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, null);
        throw new IllegalStateException(ex);
    }
    return context;
}

2.2 注解