深入理解 Spring Bean 后处理器@Autowired 等注解的本质(示例demo)_Java

在日常开发中，我们几乎每天都会用到 @autowired、@value、@resource、@postconstruct 等注解。
但你是否想过，这些“神奇”的注入和生命周期回调机制，是谁在幕后完成的？
今天我们通过一个非常简洁的 demo，一步步揭开 spring bean 后处理器的秘密。

一、代码示例

package com.itheima.a04;
import org.springframework.beans.factory.annotation.autowiredannotationbeanpostprocessor;
import org.springframework.beans.factory.support.defaultlistablebeanfactory;
import org.springframework.boot.context.properties.configurationpropertiesbindingpostprocessor;
import org.springframework.context.annotation.commonannotationbeanpostprocessor;
import org.springframework.context.annotation.contextannotationautowirecandidateresolver;
import org.springframework.context.support.genericapplicationcontext;
/*
 * bean 后处理器的作用演示
 */
public class a04 {
    public static void main(string[] args) {
        // 1️⃣ 创建一个“干净”的容器（没有任何自动注册的组件）
        genericapplicationcontext context = new genericapplicationcontext();
        // 2️⃣ 手动注册一些普通 bean
        context.registerbean("bean1", bean1.class);
        context.registerbean("bean2", bean2.class);
        context.registerbean("bean3", bean3.class);
        context.registerbean("bean4", bean4.class);
        // 3️⃣ 配置容器的自动注入解析策略（支持 @value）
        context.getdefaultlistablebeanfactory()
                .setautowirecandidateresolver(new contextannotationautowirecandidateresolver());
        // 4️⃣ 手动注册各种 bean 后处理器
        context.registerbean(autowiredannotationbeanpostprocessor.class); // 负责解析 @autowired 和 @value
        context.registerbean(commonannotationbeanpostprocessor.class);   // 负责解析 @resource、@postconstruct、@predestroy
        configurationpropertiesbindingpostprocessor.register(context.getdefaultlistablebeanfactory()); // 负责解析 @configurationproperties
        // 5️⃣ 初始化容器（执行 beanfactory 后处理器、添加 beanpostprocessor、初始化所有单例 bean）
        context.refresh();
        system.out.println(context.getbean(bean1.class));
        // 6️⃣ 关闭容器，触发销毁回调
        context.close();
        /*
            学到什么？
            ✅ 1. @autowired、@value、@resource、@postconstruct 等注解的功能，
                   都是由 bean 后处理器在 bean 生命周期阶段完成的。
            ✅ 2. bean 后处理器本身也是一种“插件机制”，可以扩展 spring 的核心行为。
         */
    }
}

二、demo 核心逻辑解析

这段代码其实干了三件事：

1️⃣ 创建一个干净的容器

genericapplicationcontext 是 spring 提供的一个空白容器实现。
它不像 annotationconfigapplicationcontext 那样自动注册注解处理器、扫描包路径或加载配置类。
换句话说，它是“白纸一张”，这就让我们可以手动控制 spring 容器内部机制。

genericapplicationcontext context = new genericapplicationcontext();

2️⃣ 手动注册 bean 与处理器

正常情况下，spring 会自动帮你注册 autowiredannotationbeanpostprocessor、commonannotationbeanpostprocessor 等组件。
但这里我们手动注册它们，以便更清楚地看到它们的作用：

注册组件	功能说明
`autowiredannotationbeanpostprocessor`	解析 `@autowired`、`@value`
`commonannotationbeanpostprocessor`	解析 `@resource`、`@postconstruct`、`@predestroy`
`configurationpropertiesbindingpostprocessor`	解析 `@configurationproperties`
`contextannotationautowirecandidateresolver`	支持 `@value("${}")` 等表达式解析

这几行代码告诉我们：
👉 spring 并没有“魔法”地识别这些注解，而是通过后处理器扩展点去实现的。

3️⃣ 初始化容器与销毁

context.refresh() 会触发以下流程：

执行 beanfactorypostprocessor（工厂级别的增强）
注册所有 beanpostprocessor
实例化所有单例 bean
在创建 bean 的过程中，各个后处理器开始发挥作用，完成依赖注入与生命周期方法调用。

随后，context.close() 会触发销毁阶段，执行：

@predestroy 注解的方法
disposablebean 接口方法
自定义销毁回调

三、结论：后处理器是 spring 的灵魂

这个 demo 的意义非常深刻，它揭示了一个关键真相：

spring 框架中几乎所有“魔法”都是通过 bean 后处理器（beanpostprocessor）实现的。

下面是一个简单的关系图，帮助理解：

spring bean 生命周期（精简版）
      实例化前 → [instantiationawarebeanpostprocessor]
      构造方法执行（实例化）
      属性注入 → [autowiredannotationbeanpostprocessor]
      初始化前 → [commonannotationbeanpostprocessor 处理 @postconstruct]
      初始化后 → [aop、代理增强等]
      销毁前 → [commonannotationbeanpostprocessor 处理 @predestroy]

四、总结

关键点	说明
后处理器是 spring 可扩展机制的核心	所有注解的功能其实都是“插件化”的
`@autowired` 等注解不是语法糖，而是由后处理器解释执行的	运行期反射完成依赖注入
容器生命周期由 `refresh()` 驱动	包括 bean 定义加载、处理器注册、bean 实例化、初始化等步骤
你也可以编写自己的 beanpostprocessor	比如自定义注解、监控 bean 加载时间、实现 aop 增强等