Spring高级篇-Aware接口及InitializingBean接口

Aware接口功能

Aware 接口提供了一种【内置】 的注入手段

InitializingBean 接口提供了一种【内置】的初始化手段

案例演示

1. 创建Bean并继承Aware接口
2. 通过GenericApplicationContext容器演示

public class MyBean implements BeanNameAware, ApplicationContextAware, InitializingBean {private static final Logger log = LoggerFactory.getLogger(MyBean.class);@Overridepublic void setBeanName(String name) {log.debug("当前bean " + this + " 名字叫:" + name);}@Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {log.debug("当前bean " + this + " 容器是:" + applicationContext);}@Overridepublic void afterPropertiesSet() throws Exception {log.debug("当前bean " + this + " 初始化");}@Autowiredpublic void aaa(ApplicationContext applicationContext) {log.debug("当前bean " + this + " 使用@Autowired 容器是:" + applicationContext);}@PostConstructpublic void init() {log.debug("当前bean " + this + " 使用@PostConstruct 初始化");}
}

测试发现Aware、InitializingBean接口的都能正确注入，但是使用@Autowired、@PostConstruct的无法注入。

public static void main(String[] args) {GenericApplicationContext context = new GenericApplicationContext();context.registerBean("myBean", MyBean.class);context.refresh(); // 1. beanFactory 后处理器,  2. 添加 bean 后处理器, 3. 初始化单例context.close();}

为什么@Autowired、@PostConstruct注解没生效？
因为@Autowired、@PostConstruct的解析需要用到 bean 后处理器, 属于扩展功能

为什么有了@Autowired 还要用 Aware 接口

1. @Autowired 的解析需要用到 bean 后处理器, 属于扩展功能
2. 而 Aware 接口属于内置功能, 不加任何扩展, Spring 就能识别
   某些情况下, 扩展功能会失效, 而内置功能不会失效

@Autowired失效案例

1. 分别使用@Autowired、@PostConstruct 和 ApplicationContextAware、InitializingBean的方式定义两个Bean
2. 分析输出日志发现只有MyConfig2的注入和初始化日志能正确打印

@Configuration
public class MyConfig1 {private static final Logger log = LoggerFactory.getLogger(MyConfig1.class);@Autowiredpublic void setApplicationContext(ApplicationContext applicationContext) {log.debug("注入 ApplicationContext");}@PostConstructpublic void init() {log.debug("初始化");}@Bean //  beanFactory 后处理器public BeanFactoryPostProcessor processor1() {return beanFactory -> {log.debug("执行 processor1");};}}

@Configuration
public class MyConfig2 implements InitializingBean, ApplicationContextAware {private static final Logger log = LoggerFactory.getLogger(MyConfig2.class);@Overridepublic void afterPropertiesSet() throws Exception {log.debug("初始化");}@Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {log.debug("注入 ApplicationContext");}@Bean //  beanFactory 后处理器public BeanFactoryPostProcessor processor2() {return beanFactory -> {log.debug("执行 processor2");};}
}

测试发现只打印了processor1的方法

public static void main(String[] args) {GenericApplicationContext context = new GenericApplicationContext();
//        context.registerBean("myBean", MyBean.class);context.registerBean("myConfig1", MyConfig1.class);context.registerBean(AutowiredAnnotationBeanPostProcessor.class);context.registerBean(CommonAnnotationBeanPostProcessor.class);context.registerBean(ConfigurationClassPostProcessor.class);context.refresh(); // 1. beanFactory 后处理器,  2. 添加 bean 后处理器, 3. 初始化单例context.close();}

@Autowired 失效分析

Java 配置类不包含 BeanFactoryPostProcessor 的情况

Java 配置类包含 BeanFactoryPostProcessor 的情况

要创建其中的 BeanFactoryPostProcessor 必须提前创建 Java 配置类，而此时的 BeanPostProcessor 还未准备好，导致 @Autowired 等注解失效

@Autowired 失效解决方法：

1. 用内置依赖注入和初始化取代扩展依赖注入和初始化
2. 用静态工厂方法代替实例工厂方法，避免工厂对象提前被创建

总结

a. Aware 接口提供了一种【内置】 的注入手段, 可以注入 BeanFactory, ApplicationContext
b. InitializingBean 接口提供了一种【内置】的初始化手段
c. 内置的注入和初始化不受扩展功能的影响, 总会被执行, 因此 Spring 框架内部的类常用它们

初始化和销毁的执行顺序

Spring 提供了多种初始化手段，除了 @PostConstruct，@Bean(initMethod) 之外，还可以实现 InitializingBean 接口来进行初始化，如果同一个 bean 用了以上手段声明了 3 个初始化方法，那么它们的执行顺序是什么样的呢？

public class Bean1 implements InitializingBean, DisposableBean {private static final Logger log = LoggerFactory.getLogger(Bean1.class);@PostConstructpublic void init1() {log.debug("初始化1");}@Overridepublic void afterPropertiesSet() throws Exception {log.debug("初始化2");}public void init3() {log.debug("初始化3");}@PreDestroypublic void destroy1() {log.debug("销毁1");}@Overridepublic void destroy() throws Exception {log.debug("销毁2");}public void destroy3() {log.debug("销毁3");}
}

public class A07 {public static void main(String[] args) {GenericApplicationContext context = new GenericApplicationContext();//手动注册的时候 BeanDefinition不会包含注解上的initMethod、destroyMethodcontext.registerBean("bean1", Bean1.class, (e) -> {e.setInitMethodName("init3");e.setDestroyMethodName("destroy3");});context.registerBean(CommonAnnotationBeanPostProcessor.class);context.registerBean(ConfigurationClassPostProcessor.class);context.refresh();context.close();}@Bean(initMethod = "init3", destroyMethod = "destroy3")public Bean1 bean1() {return new Bean1();}}

初始化的执行顺序：

1. @PostConstruct 标注的初始化方法
2. InitializingBean 接口的初始化方法
3. @Bean(initMethod) 指定的初始化方法

销毁方法的执行顺序：

1. @PreDestroy 标注的销毁方法
2. DisposableBean 接口的销毁方法
3. @Bean(destroyMethod) 指定的销毁方法

源码分析

查看org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean初始化Bean的方法：

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {if (System.getSecurityManager() != null) {AccessController.doPrivileged((PrivilegedAction<Object>) () -> {invokeAwareMethods(beanName, bean);return null;}, getAccessControlContext());}else {//执行Aware通知方法invokeAwareMethods(beanName, bean);}Object wrappedBean = bean;if (mbd == null || !mbd.isSynthetic()) {//执行@PostConstruct注解标注的初始化方法wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);}try {//1.执行InitializingBean接口的afterPropertiesSet()方法//2.执行Bean指定的initMethod方法invokeInitMethods(beanName, wrappedBean, mbd);}catch (Throwable ex) {throw new BeanCreationException((mbd != null ? mbd.getResourceDescription() : null),beanName, "Invocation of init method failed", ex);}if (mbd == null || !mbd.isSynthetic()) {wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);}return wrappedBean;}