Spring钩子接口Aware

前言

我们在编写代码的时候，有的时候想要使用Spring的底层组件，类似于 ApplicationContext, BeanFactory等等

那我们实现Spring提供的钩子方法xxxAware。在创建对象的时候，会调用接口规定的方法注入相关的组件。

Aware接口

 /**
  * A marker superinterface indicating that a bean is eligible to be notified by the
  * Spring container of a particular framework object through a callback-style method.
  * The actual method signature is determined by individual subinterfaces but should
  * typically consist of just one void-returning method that accepts a single argument.
  *
  * <p>Note that merely implementing {@link Aware} provides no default functionality.
  * Rather, processing must be done explicitly, for example in a
  * {@link org.springframework.beans.factory.config.BeanPostProcessor}.
  * Refer to {@link org.springframework.context.support.ApplicationContextAwareProcessor}
  * for an example of processing specific {@code *Aware} interface callbacks.
  *
  * @author Chris Beams
  * @author Juergen Hoeller
  * @since 3.1
  */
 public interface Aware {}

一个标记的超级接口，表明这个bean会被spring容器注意到，通过一个回调的风格。这个我也称之为钩子方法。

我们可以看到如下图片，实现了Aware的接口的接口特别多，他们都是Spring自带的组件，我们通过Aware可以很方便的使用他们。

在此列举几个比较重要的接口，都是我经常用到的。

Aware子接口	描述
BeanNameAware	获取容器中 Bean 的名称
BeanFactoryAware	获取当前 BeanFactory ，这样可以调用容器的服务
ApplicationContextAware	注入IOC容器的，可以使用容器绝大部分功能
MessageSourceAware	获取 Message Source 相关文本信息
EmbeddedValueResolverAware	值解析器，比如{}  #{}等等
EnvironmentAware	环境解析器，可以拿properties的时候挺好用的

ApplicationContextAware接口

 public interface ApplicationContextAware extends Aware {

     /**
      * Set the ApplicationContext that this object runs in.
      * Normally this call will be used to initialize the object.
      * <p>Invoked after population of normal bean properties but before an init callback such
      * as {@link org.springframework.beans.factory.InitializingBean#afterPropertiesSet()}
      * or a custom init-method. Invoked after {@link ResourceLoaderAware#setResourceLoader},
      * {@link ApplicationEventPublisherAware#setApplicationEventPublisher} and
      * {@link MessageSourceAware}, if applicable.
      * @param applicationContext the ApplicationContext object to be used by this object
      * @throws ApplicationContextException in case of context initialization errors
      * @throws BeansException if thrown by application context methods
      * @see org.springframework.beans.factory.BeanInitializationException
      */
     void setApplicationContext(ApplicationContext applicationContext) throws BeansException;

 }

这个可以获取Spring的IOC容器。拿到这个IOC容器，你可以拥有Spring的绝大多数功能。

我们以ApplicationContextAware为例。直接继承XxxAware接口，就可以拿到他的相应字段了。

 @Component
 @Slf4j
 public class Person implements ApplicationContextAware, BeanFactoryAware,
         BeanNameAware, EnvironmentAware, EmbeddedValueResolverAware {

     @Override
     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
         log.info("applicationContext = {}", applicationContext.getBean("person"));
     }

     @Override
     public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
         log.info("beanFactory = {}", beanFactory.containsBean("person"));
     }

     @Override
     public void setBeanName(String name) {
         log.info("name = {}", name);
     }

     @Override
     public void setEmbeddedValueResolver(StringValueResolver resolver) {
         // 字符解析器
         log.info("val = {}", resolver.resolveStringValue("#{5 * 10}"));
     }

     @Override
     public void setEnvironment(Environment environment) {
         // 这个可以获取环境变量的值
         log.info("app = {}", environment.getProperty("app.secret"));
     }
 }

结果：

 2020-04-04 21:35:39.474 [main] [] INFO  - [com.gdufe.osc.controller.Person java:37] [name = person]
 2020-04-04 21:35:39.475 [main] [] INFO  - [com.gdufe.osc.controller.Person java:32] [beanFactory = true]
 2020-04-04 21:35:39.475 [main] [] INFO  - [com.gdufe.osc.controller.Person java:48] [app = wenbochang888]
 2020-04-04 21:35:39.491 [main] [] INFO  - [com.gdufe.osc.controller.Person java:42] [val = 50]
 2020-04-04 21:35:39.493 [main] [] INFO  - [com.gdufe.osc.controller.Person java:27] [applicationContext = com.gdufe.osc.controller.Person@24386839]

Aware接口底层实现原理

我们看下如下的代码

 class ApplicationContextAwareProcessor implements BeanPostProcessor {

     @Override
     @Nullable
     public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {

         .....
         invokeAwareInterfaces(bean);
         .....

         return bean;
     }

     private void invokeAwareInterfaces(Object bean) {
         if (bean instanceof Aware) {
             if (bean instanceof EnvironmentAware) {
                 ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
             }
             if (bean instanceof EmbeddedValueResolverAware) {
                 ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
             }
             if (bean instanceof ResourceLoaderAware) {
                 ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
             }
             if (bean instanceof ApplicationEventPublisherAware) {
                 ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
             }
             if (bean instanceof MessageSourceAware) {
                 ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
             }
             if (bean instanceof ApplicationContextAware) {
                 ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
             }
         }
     }
 }

这里我稍微解释一下 BeanPostProcessor 方法。在初始化bean之前，以及之后，可以执行相应的方法。类似有点AOP的功能。

那么ApplicationContextAwareProcessor 就很好理解了。

在一个bean实例初始化之前调用postProcessBeforeInitialization方法。然后判断该bean有没有实现相应的aware接口，将对于的aware set进去即可，非常的方便。