Spring原理分析-Bean后处理器

前置文章：
简单了解BeanFactory和ApplicationContext请阅读：一、Spring原理分析-BeanFactory与ApplicationContext
简单了解Bean生命周期请阅读：二、Spring原理分析-Bean生命周期

零、本文纲要

• 一、Bean后处理器
  1、基础准备
  2、AutowiredAnnotationBeanPostProcessor后处理器
  3、CommonAnnotationBeanPostProcessor后处理器
  4、ConfigurationPropertiesBindingPostProcessor后处理器
  5、总结
• 二、深入AutowiredAnnotationBeanPostProcessor后处理器
  1、基础准备
  2、postProcessProperties方法
  3、按类型查找值
  4、按方法参数类型查找值

一、Bean后处理器

1、基础准备

• ① 编写实体类

public class Bean1 {
    private static final Logger log = LoggerFactory.getLogger(Bean1.class);

    private com.stone.demo04.Bean2 bean2;

    @Autowired
    public void setBean2(com.stone.demo04.Bean2 bean2) {
        log.debug("@Autowired 生效: {}", bean2);
        this.bean2 = bean2;
    }

    @Autowired
    private Bean3 bean3;

    @Resource
    public void setBean3(Bean3 bean3) {
        log.debug("@Resource 生效: {}", bean3);
        this.bean3 = bean3;
    }

    private String home;

    @Autowired
    public void setHome(@Value("${JAVA_HOME}") String home) {
        log.debug("@Value 生效: {}", home);
        this.home = home;
    }

    @PostConstruct
    public void init() {
        log.debug("@PostConstruct 生效");
    }

    @PreDestroy
    public void destroy() {
        log.debug("@PreDestroy 生效");
    }

    @Override
    public String toString() {
        return "Bean1{" +
               "bean2=" + bean2 +
               ", bean3=" + bean3 +
               ", home='" + home + '\'' +
               '}';
    }
}

public class Bean2 {}
public class Bean3 {}

• ② 编写测试类

public class Demo04 {
    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        // 注册bean
        context.registerBean("bean1", Bean1.class);
        context.registerBean("bean2", Bean2.class);
        context.registerBean("bean3", Bean3.class);
        // 初始化容器
        context.refresh();
        // 销毁容器
        context.close();
    }
}

• ③ 测试

仅注册了Bean.png

@Autowired、@Resource、@PostConstruct、@PreDestroy均为生效。

2、AutowiredAnnotationBeanPostProcessor后处理器

解析：@Autowired、@Value 注解，如下配置：

context.getDefaultListableBeanFactory().setAutowireCandidateResolver(
        new ContextAnnotationAutowireCandidateResolver() // @Value 注解值获取
);
// 解析 @Autowired、@Value 注解
context.registerBean(AutowiredAnnotationBeanPostProcessor.class);

AutowiredAnnotationBeanPostProcessor后处理器.png

3、CommonAnnotationBeanPostProcessor后处理器

解析：@Resource、@PostConstruct、@PreDestroy 注解，如下配置：

// 解析 @Resource、@PostConstruct、@PreDestroy 注解
context.registerBean(CommonAnnotationBeanPostProcessor.class);

CommonAnnotationBeanPostProcessor后处理器.png

由此也可以看出，先解析 @Resource，后解析 @Autowired 注解。

4、ConfigurationPropertiesBindingPostProcessor后处理器

解析：@ConfigurationProperties 注解，如下配置：

// 解析 @ConfigurationProperties 注解
ConfigurationPropertiesBindingPostProcessor.register(context.getDefaultListableBeanFactory());

System.out.println("Java_Home is: " + context.getBean(Bean4.class).getHome());
System.out.println("Java_Version is: " + context.getBean(Bean4.class).getVersion());

ConfigurationPropertiesBindingPostProcessor后处理器.png

5、总结

• ① AutowiredAnnotationBeanPostProcessor后处理器

解析@Autowired、@Value 注解；

• ② CommonAnnotationBeanPostProcessor后处理器

解析@Resource、@PostConstruct、@PreDestroy 注解；

• ③ ConfigurationPropertiesBindingPostProcessor后处理器

解析@ConfigurationProperties 注解。

二、深入AutowiredAnnotationBeanPostProcessor后处理器

1、基础准备

编写测试类，如下：

public class DigInAutowired {
    public static void main(String[] args) {
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        beanFactory.registerSingleton("bean2", new Bean2());
        beanFactory.registerSingleton("bean3", new Bean3());
        beanFactory.setAutowireCandidateResolver(
                new ContextAnnotationAutowireCandidateResolver()); // 获取 @Value 注解值

        AutowiredAnnotationBeanPostProcessor postProcessor = new AutowiredAnnotationBeanPostProcessor();
        postProcessor.setBeanFactory(beanFactory);
}

2、postProcessProperties方法

Bean1 bean1 = new Bean1();
System.out.println("BEFORE PARSING: " + bean1);
// 执行依赖注入，@Autowired、@Value 注解
postProcessor.postProcessProperties(null, bean1, "bean1");
System.out.println("AFTER PARSED: " + bean1);

postProcessProperties方法.png

AutowiredAnnotationBeanPostProcessor#postProcessProperties方法源码，如下：

@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    // 先查找带有指定注解的bean
    InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
    try {
        // 再执行依赖注入
        metadata.inject(bean, beanName, pvs);
    }
    catch (BeanCreationException ex) {
        throw ex;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
    }
    return pvs;
}

findAutowiringMetadata方法，如下：

// 反射获取 findAutowiringMetadata 方法对象
Method findAutowiringMetadata = AutowiredAnnotationBeanPostProcessor.class
        .getDeclaredMethod("findAutowiringMetadata", String.class, Class.class, PropertyValues.class);
// 暴力反射，执行 findAutowiringMetadata 方法，获取 bean1 的 metadata
findAutowiringMetadata.setAccessible(true);
InjectionMetadata metadata
        = (InjectionMetadata) findAutowiringMetadata.invoke(postProcessor, "bean1", Bean1.class, null);
System.out.println(metadata);

findAutowiringMetadata方法.png @Autowired注解被识别到.png

inject方法，如下：

System.out.println("BEFORE PARSING: " + bean1);
metadata.inject(bean1, "bean1", null); // 执行依赖注入 @Autowired、@Value 注解
System.out.println("AFTER PARSED: " + bean1);

inject方法.png

补充：${} 的解析器

// ${} 的解析器
beanFactory.addEmbeddedValueResolver(new StandardEnvironment()::resolvePlaceholders);

${} 的解析器.png

3、按类型查找值

// 按照类型查找值
Field bean3 = bean1.getClass().getDeclaredField("bean3");
DependencyDescriptor dd1 = new DependencyDescriptor(bean3, false);
Object obj = beanFactory.doResolveDependency(dd1, null, null, null);
System.out.println(obj);

按照类型查找值.png

4、按方法参数类型查找值

// 按照方法参数类型查找值
Method setBean2 = bean1.getClass().getDeclaredMethod("setBean2", Bean2.class);
DependencyDescriptor dd2
        = new DependencyDescriptor(new MethodParameter(setBean2, 0), false);
Object obj2 = beanFactory.doResolveDependency(dd2, null, null, null);
System.out.println(obj2);

按方法参数类型查找值.png

Method setHome = bean1.getClass().getDeclaredMethod("setHome", String.class);
DependencyDescriptor dd3
        = new DependencyDescriptor(new MethodParameter(setHome, 0), false);
Object obj3 = beanFactory.doResolveDependency(dd3, null, null, null);
System.out.println(obj3);

查找@Value注解注入的值.png

三、结尾

以上即为Spring原理分析-容器&Bean（三）全部内容，感谢阅读。