// 在Spring容器刷新之前執(zhí)行
public class MyInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        // 注冊自定義屬性源
        MapPropertySource propertySource = new MapPropertySource("myProperties", 
            Collections.singletonMap("custom.key", "custom-value"));
        applicationContext.getEnvironment().getPropertySources().addFirst(propertySource);
        // 設置一些系統(tǒng)屬性
        System.setProperty("some.key", "some-value");
    }
}
// 使用方式：META-INF/spring.factories
// org.springframework.context.ApplicationContextInitializer=com.example.MyInitializer

@Component
@Order(1)  // 通過@Order注解或實現(xiàn)Ordered接口控制執(zhí)行順序
public class FirstRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) {
        System.out.println("第一個執(zhí)行");
    }
}

public class RemoteConfigProcessor implements EnvironmentPostProcessor {
    @Override
    public void postProcessEnvironment(ConfigurableEnvironment env, SpringApplication app) {
        // 從遠程配置中心獲取配置
        Map<String, Object> remoteConfig = fetchRemoteConfig();
        // 將遠程配置添加到Environment中
        MapPropertySource remoteSource = new MapPropertySource("remoteConfig", remoteConfig);
        env.getPropertySources().addFirst(remoteSource);
        // 動態(tài)激活Profile
        if (remoteConfig.containsKey("active.profiles")) {
            String profiles = (String) remoteConfig.get("active.profiles");
            env.setActiveProfiles(profiles.split(","));
        }
    }
}

Spring容器啟動
    ↓
加載Bean定義
    ↓
BeanDefinitionRegistryPostProcessor執(zhí)行（可注冊新Bean）
    ↓
BeanFactoryPostProcessor執(zhí)行（只能修改已有Bean）
    ↓
Bean實例化

// 1. 定義注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(MyComponentRegistrar.class)
public @interface EnableMyComponents {
    String[] basePackages() default {};
}
// 2. 實現(xiàn)Registrar
public class MyComponentRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, 
                                      BeanDefinitionRegistry registry) {
        // 獲取注解屬性
        Map<String, Object> attrs = metadata.getAnnotationAttributes(
            EnableMyComponents.class.getName());
        String[] packages = (String[]) attrs.get("basePackages");
        // 掃描并注冊Bean
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry);
        scanner.scan(packages);
    }
}
// 3. 使用
@EnableMyComponents(basePackages = "com.example.components")
@Configuration
public class AppConfig {}

public class MyBeanPostProcessor implements BeanPostProcessor {
    // Bean初始化之前調(diào)用（在afterPropertiesSet和init-method之前）
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        // 可以返回包裝對象
        return bean;
    }
    // Bean初始化之后調(diào)用（在afterPropertiesSet和init-method之后）
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        // 通常用于返回代理對象
        if (bean instanceof MyService) {
            return Proxy.newProxyInstance(...); // 創(chuàng)建代理
        }
        return bean;
    }
}

public class MyInstantiationProcessor implements InstantiationAwareBeanPostProcessor {
    // 1. 可以完全接管Bean的實例化過程
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
        if (beanClass == SpecialBean.class) {
            // 返回自定義實例，Spring將跳過默認實例化
            return createSpecialBean();
        }
        return null; // 返回null則繼續(xù)Spring默認實例化
    }
    // 2. 控制是否進行屬性注入
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) {
        if (bean instanceof ReadOnlyBean) {
            return false; // 返回false則跳過屬性注入
        }
        return true;
    }
    // 3. 處理屬性值
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        // 修改或添加屬性值
        MutablePropertyValues mpvs = (pvs instanceof MutablePropertyValues) ?
            (MutablePropertyValues) pvs : new MutablePropertyValues(pvs);
        mpvs.add("customProperty", "customValue");
        return mpvs;
    }
}

@Component
public class LifecycleBean implements InitializingBean, DisposableBean {
    // 方式1：實現(xiàn)接口方法
    @Override
    public void afterPropertiesSet() {
        System.out.println("InitializingBean.afterPropertiesSet()");
    }
    @Override
    public void destroy() {
        System.out.println("DisposableBean.destroy()");
    }
    // 方式2：使用JSR-250注解
    @PostConstruct
    public void init() {
        System.out.println("@PostConstruct");
    }
    @PreDestroy
    public void cleanup() {
        System.out.println("@PreDestroy");
    }
    // 方式3：XML配置的init-method和destroy-method
    public void customInit() {
        System.out.println("custom init-method");
    }
    public void customDestroy() {
        System.out.println("custom destroy-method");
    }
}
// 執(zhí)行順序：@PostConstruct → InitializingBean → init-method
// 銷毀順序：@PreDestroy → DisposableBean → destroy-method

@Component
public class MyService implements ApplicationContextAware, EnvironmentAware {
    private ApplicationContext context;
    private Environment environment;
    @Override
    public void setApplicationContext(ApplicationContext context) {
        this.context = context;
        // 可以動態(tài)獲取其他Bean或發(fā)布事件
        EventPublisher publisher = context.getBean(EventPublisher.class);
        publisher.publishEvent(new MyEvent(this));
    }
    @Override
    public void setEnvironment(Environment env) {
        this.environment = env;
        // 可以讀取配置
        String value = env.getProperty("my.config");
    }
}

public class OnProductionCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment env = context.getEnvironment();
        String profile = env.getProperty("spring.profiles.active", "dev");
        return "prod".equals(profile);
    }
}
// 使用自定義條件
@Configuration
@Conditional(OnProductionCondition.class)
public class ProductionConfig {
    // 只有生產(chǎn)環(huán)境才生效的配置
}

// 1. 創(chuàng)建配置類
@Configuration
@ConditionalOnClass(MyService.class)  // 存在MyService類時才生效
@ConditionalOnMissingBean(MyService.class)  // 容器中沒有MyService Bean時才生效
@EnableConfigurationProperties(MyProperties.class)  // 啟用配置屬性
@AutoConfigureAfter(DataSourceAutoConfiguration.class)  // 在數(shù)據(jù)源配置之后
public class MyAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public MyService myService(MyProperties properties) {
        return new MyService(properties.getUrl());
    }
}
// 2. 在META-INF/spring.factories中注冊
// org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.example.MyAutoConfiguration

// 1. 定義配置類
@ConfigurationProperties(prefix = "app.mail")
@Validated  // 支持JSR-303驗證
public class MailProperties {
    @NotEmpty
    private String host;
    @Min(1025)
    @Max(65535)
    private int port = 25;
    private boolean sslEnabled = false;
    // getter/setter省略
}
// 2. 啟用配置類
@Configuration
@EnableConfigurationProperties(MailProperties.class)
public class AppConfig {
}
// 3. 在application.yml中配置
// app:
//   mail:
//     host: smtp.example.com
//     port: 587
//     ssl-enabled: true

@Configuration
public class WebConfig implements WebMvcConfigurer {
    // 添加攔截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LogInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns("/static/**");
    }
    // 配置跨域
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**")
                .allowedOrigins("https://example.com")
                .allowedMethods("GET", "POST")
                .allowCredentials(true);
    }
    // 添加格式化器
    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addFormatter(new DateFormatter("yyyy-MM-dd"));
    }
    // 配置消息轉換器
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        converters.add(0, new FastJsonHttpMessageConverter());
    }
}

請求到達
    ↓
preHandle() // 返回true繼續(xù)，false中斷
    ↓
Controller執(zhí)行
    ↓
postHandle() // 渲染視圖前
    ↓
渲染視圖
    ↓
afterCompletion() // 請求完成后

@Component
public class MyEventListener {
    // 同步監(jiān)聽
    @EventListener
    public void handleSyncEvent(ContextRefreshedEvent event) {
        // 同步處理
    }
    // 異步監(jiān)聽
    @Async
    @EventListener
    public void handleAsyncEvent(MyCustomEvent event) {
        // 異步處理
    }
    // 條件監(jiān)聽
    @EventListener(condition = "#event.success")
    public void handleConditionalEvent(OrderEvent event) {
        // 條件滿足時處理
    }
    // 監(jiān)聽多個事件
    @EventListener({ContextStartedEvent.class, ContextRefreshedEvent.class})
    public void handleMultipleEvents() {
        // 處理多個事件
    }
}

啟動最早Initializer，
環(huán)境配置PostProcessor。
Bean定義三劍客：
RegistryPost最先到，
FactoryPost緊跟隨，
Import注冊在其中。
實例化時多攔截：
Instantiation最優(yōu)先，
屬性注入前后調(diào)。
初始化時回調(diào)多：
Aware接口先注入，
PostConstruct隨后到，
InitializingBean接著來，
BeanPostProcessor前后包。
全部就緒Singleton，
啟動完成Runner跑。