Spring中常见的Bean后处理器

Bean后处理器的作用：为Bean生命周期各个阶段提供扩展。接下来我们查看一个案例

public class TestBeanPostProcessor {
    public static void main(String[] args) {
        //该容器不存在任何Spring中的bean对象，是一个干净的容器，且提供了正常容器中的refresh方法，方便我们测试
        GenericApplicationContext context = new GenericApplicationContext();

        context.registerBean("bean1", Bean1.class);
        context.registerBean("bean2", Bean2.class);
        context.registerBean("bean3", Bean3.class);

        context.refresh();//去执行BeanFactory后处理器，添加Bean后处理器，初始化所有单例bean

        context.close();

    }
}

而Bean1与Bean2类什么也没有编写，主要是Bean3中存在一些注解

public class Bean3 {
    private Bean1 bean1;

    @Autowired
    public void setBean1(Bean1 bean1) {
        System.out.println("@Autowired注解生效");
        this.bean1 = bean1;
    }

    private Bean2 bean2;

    @Resource
    public void setBean2(Bean2 bean2) {
        System.out.println("@Resource注解生效");
        this.bean2 = bean2;
    }

    private String home;

    @Autowired
    private void setHome(@Value("${JAVA_HOME}") String home) {
        System.out.println("@Value注解生效");
        this.home = home;
    }

    @PostConstruct
    private void init(){
        System.out.println("初始化注解生效");
    }

    @PreDestroy
    private void destroy(){
        System.out.println("销毁注解生效");
    }
}

我们执行后发现结果如下

20:57:03.786 [main] DEBUG org.springframework.context.support.GenericApplicationContext - Refreshing org.springframework.context.support.GenericApplicationContext@4361bd48
20:57:03.811 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'bean1'
20:57:03.827 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'bean2'
20:57:03.827 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'bean3'
20:57:03.857 [main] DEBUG org.springframework.context.support.GenericApplicationContext - Closing org.springframework.context.support.GenericApplicationContext@4361bd48, started on Mon Dec 25 20:57:03 CST 2023

没有输出任何的打印语句，因此我们可以得知注解都没有生效，接下来我们测试添加Spring中常用的Bean后处理器后结果会有什么不同

添加图中的代码，红框中的第一行代码是修改beanFactory的自动装配的解析器，修改过后可以获取@Value中的属性，这个东西我会在后续的文章中解释

添加完这两个Bean后处理器之后再次执行后控制台信息如下

21:21:19.937 [main] DEBUG org.springframework.context.support.GenericApplicationContext - Refreshing org.springframework.context.support.GenericApplicationContext@2401f4c3
21:21:19.955 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor'
21:21:19.969 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.annotation.CommonAnnotationBeanPostProcessor'
21:21:19.976 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'bean1'
21:21:19.986 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'bean2'
21:21:20.006 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'bean3'
@Resource注解生效
@Autowired注解生效
21:21:20.035 [main] DEBUG org.springframework.core.env.PropertySourcesPropertyResolver - Found key 'JAVA_HOME' in PropertySource 'systemEnvironment' with value of type String
@Value注解生效
D:\Java
初始化注解生效
21:21:20.047 [main] DEBUG org.springframework.context.support.GenericApplicationContext - Closing org.springframework.context.support.GenericApplicationContext@2401f4c3, started on Mon Dec 25 21:21:19 CST 2023
销毁注解生效

另一个需要注意的是，在多个Bean后处理器时，Spring会对Bean后处理器进行一个排序，在不更改排序规则前提下，优先解析@Resource注解再解析@Autowired注解

接下来我们查看另一种Bean后处理器，首先给出Bean4中的代码

/**
 * 会从配置文件中获取java.home与java.version两个k得到v注入对象中的属性
 */
@ConfigurationProperties(prefix = "java")
public class Bean4 {
    private String home;
    private String version;

    public String getHome() {
        return home;
    }

    public void setHome(String home) {
        this.home = home;
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }

    @Override
    public String toString() {
        return "Bean4{" +
                "home='" + home + '\'' +
                ", version='" + version + '\'' +
                '}';
    }
}

我们测试之前的两个Bean后处理器能否获取到环境中的信息并将值赋值给类中的属性，运行结果如下

可以看到无法之前添加的Bean后处理器无法处理该注解，因此我们需要再次添加另一个Bean后处理器，也就是下图中红框中的内容

执行结果如下

接下来我们分析@Autowired是如何解析的，新建一个类我们自己手动调用Bean后处理器中的注入部分的方法

public class TestAutowiredBeanPostProcessor {
    public static void main(String[] args) throws Throwable {
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        //这里使用registerSingleton方式是省去了bean的声明周期的流程，直接创建一个对象存放在单例池中。
        beanFactory.registerSingleton("bean1", new Bean1());
        beanFactory.registerSingleton("bean2", new Bean2());

        beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
        //探究该Bean后处理器是如何解析Autowired注解的
        AutowiredAnnotationBeanPostProcessor processor = new AutowiredAnnotationBeanPostProcessor();
        //该处理器要注入对象，对象的获取来自于beanFactory因此，需要给处理器BeanFactory属性
        processor.setBeanFactory(beanFactory);

        Bean3 bean3 = new Bean3();
        System.out.println(bean3);//此时注解一定不会被执行
        //暴力反射
        Method method = AutowiredAnnotationBeanPostProcessor.class.getDeclaredMethod("findAutowiringMetadata", String.class, Class.class, PropertyValues.class);
        method.setAccessible(true);
        //得到该类中有多少需要被解析的注解以及注解信息
        InjectionMetadata metadata = (InjectionMetadata) method.invoke(processor, "bean3", Bean3.class, null);

        metadata.inject(bean3,"bean3",null);
        System.out.println(bean3);
    }
}

上述代码中的metadata对象存储的信息如下

程序直接结果如下

Bean3{bean1=null, bean2=null, home='null'}
@Autowired注解生效
@Value注解生效
Bean3{bean1=com.zmt.test3.Bean1@3fee9989, bean2=null, home='${JAVA_HOME}'}

由于bean2上注解添加的是@Resource注解，因此不会被填充到bean3当中，那么接下来我们讲bean2字段上添加注解修@Autowired的同时注释掉setBean2方法上的@Resource注解，然后通过代码查看@Autowired注解是如何通过类型注入的

public class TestAutowiredBeanPostProcessor {
    public static void main(String[] args) throws Throwable {
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        //这里使用registerSingleton方式是省去了bean的声明周期的流程，直接创建一个对象存放在单例池中。
        beanFactory.registerSingleton("bean1", new Bean1());
        beanFactory.registerSingleton("bean2", new Bean2());

        //inject方法中如何通过类型获取值
        //如果是通过在字段上添加的注解，先获取对应的字段对象
        Field bean2 = Bean3.class.getDeclaredField("bean2");
        //Spring会将获取到的字段封装成如下对象
        DependencyDescriptor dd2 = new DependencyDescriptor(bean2, false);
        //封装结束后inject内部会接着调用如下方法,根据字段对象获取到字段对象的类类型然后从单例池中获取到相同类型的对象
        Object o = beanFactory.doResolveDependency(dd2, null, null, null);
        System.out.println(o);

        //如果注解添加在方法上
        Method setBean1 = Bean3.class.getDeclaredMethod("setBean1", Bean1.class);
        DependencyDescriptor dd1 = new DependencyDescriptor(new MethodParameter(setBean1, 0), false);
        Object o1 = beanFactory.doResolveDependency(dd1, null, null, null);
        System.out.println(o1);
    }
}

可以看到成功获取到了bean1与bean2对象，然后通过反射的方法将值set到bean3的属性当中即可，需要注意的是，在创建DependencyDescriptor时，第二个参数为false的意思如果单例池中找不到对应的类型时不报错，如果为true，那么单例池中不存在对应类型的对象时会报错