Spring源码04

第四讲、Bean后处理器

1、常见的Bean后处理器

初步

后处理器的作用：为Bean生命周期的各个阶段提供扩展

源代码：

@SpringBootApplication
public class A05 {
    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();

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

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

        //销毁容器
        context.close();
    }
}

Bean1源码：

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

    private Bean2 bean2;

    @Autowired
    public void setBean2(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 + '\'' +
               '}';
    }
}

Bean2、Bean3的源码：

public class Bean2/Bean3 {
}

直接运行会发现Bean1的代码都没有运行。

是因为这些后置处理器都没有生效，让@Value和@Autowire注解生效：

//解析@Autowired注解和@Value注解
context.registerBean(AutowiredAnnotationBeanPostProcessor.class);
//只写上面代码是不能执行的，因为@Value注解的值不能自动添加，需要下面的代码添加属性值
context.getDefaultListableBeanFactory().setAutowireCandidateResolver(
    new ContextAnnotationAutowireCandidateResolver());

运行发现可以获取了。

让@Resource、@PostConstruct、@PreDestroy生效：

context.registerBean(CommonAnnotationBeanPostProcessor.class);

SpringBoot的一个后处理器，用来处理前缀的，Bean4代码如下：

/*
    java.home=
    java.version=
 */
@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 + '\'' +
               '}';
    }
}

先在销毁之前获取一下Bean4，通过结果可以看到Bean4的属性没有注入：

Bean4{home='null', version='null'}

为了让其生效，需要使用后处理器：

ConfigurationPropertiesBindingPostProcessor.register(context.getDefaultListableBeanFactory());

再次测试：

Bean4{home='C:\Program Files\Java\jdk1.8.0_271\jre', version='1.8.0_271'}

它是用在@ConfigurationProperties注解时，也就是Bean4的@ConfigurationProperties(prefix = "java")时。

AutowiredAnnotationBeanPostProcessor详解

这个后置处理器可以运行@Autowired和@Value注解，前面已经讲过了。

初始代码：

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());
        
        //1，查找那些属性、方法加了@Autowired，着称之为InjectMetadata
        
        //2.调用InjectMetadata来进行依赖注入，注入时该按照类型查找值
        
        //3.如何按类型查找值
    }
}

让Autowired注解生效：

//1，查找那些属性、方法加了@Autowired，着称之为InjectMetadata
//这里等于时不再用DefaultListableBeanFactory的getBean等方法帮我们调用，而是我们直接去调用
AutowiredAnnotationBeanPostProcessor processor = new AutowiredAnnotationBeanPostProcessor();
processor.setBeanFactory(beanFactory);

Bean1 bean1 = new Bean1();
System.out.println(bean1);
processor.postProcessProperties(null,bean1,"bean1");//执行依赖注入，解析@Autowired注解
System.out.println(bean1);

可以看到输出结果,：

Bean1{bean2=null, bean3=null, home='null'}
08:48:47.413 [main] DEBUG com.oliver.spring_source.a04.Bean1 - @Value 生效: ${JAVA_HOME}
08:48:47.423 [main] DEBUG com.oliver.spring_source.a04.Bean1 - @Autowired 生效: com.oliver.spring_source.a04.Bean2@71318ec4
Bean1{bean2=com.oliver.spring_source.a04.Bean2@71318ec4, bean3=null, home='${JAVA_HOME}'}

这里发现JAVA_HOME没加载出来，先注掉一下这些：

//System.out.println(bean1);
//processor.postProcessProperties(null,bean1,"bean1");//执行依赖注入，解析@Autowired注解
//System.out.println(bean1);

然后执行下面这串代码：

Method findAutowiringMetadata = AutowiredAnnotationBeanPostProcessor.class.getDeclaredMethod("findAutowiringMetadata", String.class,Class.class, PropertyValues.class);
findAutowiringMetadata.setAccessible(true);
InjectionMetadata metadata = (InjectionMetadata) findAutowiringMetadata.invoke(processor, "bean1", Bean1.class, null);//获取bean1上加了@Value和@Autowired的变量
System.out.println(metadata);

debug看一下。

依赖注入：

//2.调用InjectMetadata来进行依赖注入，注入时该按照类型查找值
metadata.inject(bean1,"bean1",null);
System.out.println(bean1);

看一下结果：

Bean1{bean2=com.oliver.spring_source.a04.Bean2@5ce81285, bean3=com.oliver.spring_source.a04.Bean3@78c03f1f, home='${JAVA_HOME}'}

发现${}还是不能被解析：

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

看一下结果：

Bean1{bean2=com.oliver.spring_source.a04.Bean2@130161f7, bean3=com.oliver.spring_source.a04.Bean3@f5ac9e4, home='C:\Program Files\Java\jdk1.8.0_271'}

如何通过类型查找：

//3.如何按类型查找值
Field bean3 = Bean1.class.getDeclaredField("bean3");
DependencyDescriptor d1 = new DependencyDescriptor(bean3,false);
Object o = beanFactory.doResolveDependency(d1, null, null, null);
System.out.println(o);

Method setBean2 = Bean1.class.getDeclaredMethod("setBean2", Bean2.class);
DependencyDescriptor d2 = new DependencyDescriptor(new MethodParameter(setBean2,0),false);
Object o1 = beanFactory.doResolveDependency(d2, null, null, null);
System.out.println(o1);