Spring - aware注入原理

Spring中Aware接口原理

    在Spring中存在一个Aware接口，实现该接口可以让我们的Bean获取到Spring容器中特定的资源，但该接口只是个标记接口，不存在任何方法，因此我们还需要继承Aware来做特定资源获取的实现。

    换句话说：只要实现了Aware子接口的Bean都能获取到一个Spring底层组件。

    从我们熟悉的 refresh() 方法入手, 接下来调用的 prepareBeanFactory() 方法，会添加一些默认的后置处理器，这里我们关注的是添加ApplicationContextAwareProcessor实例。 

    一、注册时机

    ApplicationContextAwareProcessor的注册时机，即准备BeanFactory的时候，注册的入口在AbstractApplicationContext#prepareBeanFactory方法中。

    1. refresh

    AbstractApplicationContext#refresh

public void refresh() throws BeansException, IllegalStateException {
        synchronized(this.startupShutdownMonitor) {
            StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
            this.prepareRefres);
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            //...

        }
} 

    2. prepareBeanFactory()

    AbstractApplicationContext#prepareBeanFactory

    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        beanFactory.setBeanClassLoader(this.getClassLoader());
        if (!shouldIgnoreSpel) {
            beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
        }

        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment()));
        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
        
        //...

    }

    二、执行逻辑

    1. postProcessBeforeInitialization 

    1）判断是否是xxxAware接口，判断是，则继续往下

    2）通过invokeAwareInterfaces里面进行注入

    ApplicationContextAwareProcessor#postProcessBeforeInitialization 源码如下：

@Nullable
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    // 判断是否是xxxAware接口，判断是，则继续往下
    if (!(bean instanceof EnvironmentAware) && !(bean instanceof EmbeddedValueResolverAware) && !(bean instanceof ResourceLoaderAware) && !(bean instanceof ApplicationEventPublisherAware) && !(bean instanceof MessageSourceAware) && !(bean instanceof ApplicationContextAware) && !(bean instanceof ApplicationStartupAware)) {
        return bean;
    } else {
        AccessControlContext acc = null;
        if (System.getSecurityManager() != null) {
            acc = this.applicationContext.getBeanFactory().getAccessControlContext();
        }

        if (acc != null) {
            AccessController.doPrivileged(() -> {
                this.invokeAwareInterfaces(bean);
                return null;
            }, acc);
        } else {
            // 在这个方法进行相应的注入
            this.invokeAwareInterfaces(bean);
        }

        return bean;
    }
}

    2. invokeAwareInterfaces

    1）判断是否是xxxAware接口

    2) 如果是xxxAware接口，则获取xxx，调用setxxx方法进行注入

    ApplicationContextAwareProcessor#invokeAwareInterfaces 源码如下：

 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);
            }
        }

    }

    三、执行时机

    ApplicationContextAwareProcessor本身并不是扩展点，而是实现了BeanPostProcessor，并实现postProcessBeforeInitialization()，所以并不需要去实现它，但是其内部包含了以下7个接口实现的执行时机，这几个接口的功能作用分别是：

    1. EnvironmentAware

    用于获取Enviroment，Enviroment可以获得系统内的所有参数；另外也可以通过注入的方式来获得Environment，用哪种方式需要以实现场景而决定。

    2. EmbeddedValueResolverAware

    用于获取StringValueResolver，StringValueResolver可以获取基于String类型的properties的变量；另外还可以使用@Value的方式来获取properties的变量，用哪种方式需要以实现场景而决定。 

    3. ResourceLoaderAware

    用于获取ResourceLoader，ResourceLoader可以用于获取classpath内所有的资源对象。

    4. ApplicationEventPublisherAware

    用于获取ApplicationEventPublisher，ApplicationEventPublisher可以用来发布事件，当然这个对象也可以通过spring注入的方式来获得，具体的实现方式可以参考Springboot事件监听机制的实战应用。

    5. MessageSourceAware

    用于获取MessageSource，MessageSource主要用来做国际化。

    6. ApplicationStartupAware

    Spring Boot 应用启动过程中进行额外的配置、监控或自定义操作。

    7. ApplicationContextAware

    用来获取ApplicationContext，ApplicationContext就是Spring上下文管理器。

    四、Aware调用链路

    1. 调用AbstractAutowireCapableBeanFactory的doCreateBean()方法

    2. 调用AbstractAutowireCapableBeanFactory的initializeBean()方法，代码如下： 

    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 {
            invokeAwareMethods(beanName, bean);
        }

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }

        try {
            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;
    }

    3. 调用AbstractAutowireCapableBeanFactory的applyBeanPostProcessorsBeforeInitialization()方法

    4. 调用ApplicationContextAwareProcessor的postProcessBeforeInitialization()方法

    5. 调用ApplicationContextAwareProcessor的invokeAwareInterfaces()方法

    6. 调用Aware接口实现的方法

    五、自定义aware

    自定义组件时，想要使用spring容器底层的一些组件，比如ApplicationContext、Beanfactory，xxx等，只需要让自定义组件实现xxxAware，在对象实例化的时候，会把spring底层的一些组件注入到自定义的bean中。

    举个例子：

import org.springframework.beans.factory.BeanFactoryUtils;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

import java.util.Map;

/**
 * 通过Spring上下文获取bean工具类
 *
 * @author test
 */
public class SpringContextUtils implements ApplicationContextAware {

    /**
     * Spring应用上下文环境
     */
    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        SpringContextUtils.initSpringContext(applicationContext);
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) {
        return (T) applicationContext.getBean(name);
    }

    public static <T> T getBean(Class<T> clazz) {
        return applicationContext.getBean(clazz);
    }

    public static boolean isSingleton(String name) {
        return applicationContext.isSingleton(name);
    }

    /**
     * 根据class对象返回IOC容器中其对象和其子类的对象。
     * 未找到则返回空MAP。
     * KEY为BEAN ID或者NAME，VALUE为BEAN实例
     *
     * @param type 需要找的bean类型的CLASS对象
     * @return bean映射
     */
    public static <T> Map<String, T> getBeansByType(Class<T> type) {
        return BeanFactoryUtils.beansOfTypeIncludingAncestors(SpringContextUtils.getApplicationContext(), type);
    }

    /**
     * 初始化ApplicationContext
     *
     * @param applicationContext 上下文
     */
    public static void initSpringContext(ApplicationContext applicationContext) {
        SpringContextUtils.applicationContext = applicationContext;
    }

    /**
     * 获取业务线（业务线配置在配置文件中）
     *
     * @return 业务线
     */
    public static String getProjectBusinessLine() {
        if (applicationContext == null) {
            throw new RuntimeException("spring初始化失败");
        }
        return applicationContext.getEnvironment().getProperty("***.application.businessLine");
    }

    /**
     * 获取项目名称（项目名称配置在配置文件中）
     *
     * @return 项目名称
     */
    public static String getProjectName() {
        if (applicationContext == null) {
            throw new RuntimeException("spring初始化失败");
        }
        return applicationContext.getEnvironment().getProperty("***.application.name");
    }
}