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进去即可，非常的方便。