BeanFactory 初始化方法及其标准顺序

Posted 2023-03-23

参考技术A BeanFactory 初始化方法及其标准顺序为：

BeanNameAware.setBeanName

在创建此bean的 BeanFactory 中设置bean的名称。

在填充常规bean属性之后 但在 InitializingBean.afterPropertiesSet（）类的init回调 或 自定义 init-method之前调用。

BeanClassLoaderAware.setBeanClassLoader

允许bean知道 bean 的回调 ClassLoader class loader ;

也就是说，当前 bean 工厂使用的类加载器来加载bean类。

BeanFactoryAware.setBeanFactory

将拥有的工厂提供给 Bean 实例的回调。

在填充常规 bean 属性之后但在初始化回调之前调用，例如 InitializingBean.afterPropertiesSet() 或 自定义的 init-method。

bean 可以立即在工厂中调用方法。

EnvironmentAware.setEnvironment

设置运行该组件的 环境

EmbeddedValueResolverAware.setEmbeddedValueResolver

通过 ApplicationContextAware / BeanFactoryAware 接口，这可以替代完整的ConfigurableBeanFactory 依赖项。

设置 StringValueResolver 以用于解析嵌入式定义值。

ResourceLoaderAware.setResourceLoader （仅在应用程序上下文中运行时适用）

设置运行该对象的 ResourceLoader。

这可能是 ResourcePatternResolver，可以通过 `instanceof ResourcePatternResolver 进行检查。

另请参见 ResourcePatternUtils.getResourcePatternResolver 方法。

在填充正常的 bean 属性之后但在初始化回调之前调用，例如在 InitializingBean. afterPropertiesSet 或 自定义的init方法 上。

在 ApplicationContextAware.setApplicationContext 之前调用。

ApplicationEventPublisherAware.setApplicationEventPublisher （仅在应用程序上下文中运行时适用）

设置此对象在其中运行的 ApplicationEventPublisher。

在填充正常的 bean 属性之后,但在 InitializingBean.afterPropertiesSet 或 自定义init-method 之类的 init 回调之前调用。

在 ApplicationContextAware.setApplicationContext 之前调用。

MessageSourceAware.setMessageSource （仅适用于在应用程序上下文中运行）

设置此对象在其中运行的MessageSource。

在填充正常的 bean 属性之后,但在InitializingBean.afterPropertiesSet 或 自定义init-method之类的 init 回调 之前调用。

在ApplicationContextAware.setApplicationContext之前调用。

ApplicationContextAware.setApplicationContext（仅适用于在应用程序上下文中运行）

设置该对象在其中运行的ApplicationContext。

通常，此调用将用于初始化该对象。

在填充正常的 bean 属性之后 ,但在org.springframework.beans.factory.InitializingBean.afterPropertiesSet()之类的init回调 或 自定义init-method之前调用。

如果适用，在ResourceLoaderAware.setResourceLoader , ApplicationEventPublisherAware.setApplicationEventPublisher和MessageSourceAware之后调用。

ServletContextAware.setServletContext （仅适用于在以下环境中运行Web应用程序上下文)

设置运行该对象的ServletContext。

在填充正常的bean属性之后,但在nitializingBean. afterPropertiesSet 之类的init 回调 或 自定义init-method之前调用。

在 ApplicationContextAware.setApplicationContext 之后调用。

BeanPostProcessors.postProcessBeforeInitialization方法

12.InitializingBean.afterPropertiesSet

由包含的BeanFactory 设置了所有 bean 属性并满足BeanFactoryAware，ApplicationContextAware等之后调用。

此方法允许 bean 实例对其总体配置进行验证。

设置所有 bean 属性后进行最后的初始化。

自定义 init-method 定义 (a custom init-method definition)

BeanPostProcessors.postProcessAfterInitialization

spring注解开发-扩展原理（源码）

1.BeanFactoryPostProcessor

BeanPostProcessor：bean后置处理器，bean创建对象初始化前后进行拦截工作的;

BeanFactoryPostProcessor：beanFactory的后置处理器；在BeanFactory标准初始化之后调用，来定制和修改BeanFactory的内容；即所有的bean定义已经保存加载到beanFactory，但是bean的实例还未创建；

BeanFactoryPostProcessor原理:

1）IOC容器创建对象

2）调用AbstractApplicationContext的refresh()方法；

3）调用AbstractApplicationContext的invokeBeanFactoryPostProcessors(beanFactory)方法，然后调用PostProcessorRegistrationDelegate的invokeBeanFactoryPostProcessors()方法

如何找到所有的BeanFactoryPostProcessor并执行他们的方法；

1）、直接在BeanFactory中找到所有类型是BeanFactoryPostProcessor的组件，并执行他们的方法

2）、在初始化创建其他组件前面执行

2.BeanDefinitionRegistryPostProcessor

它是BeanFactoryPostProcessor的子接口；在所有bean定义信息将要被加载，bean实例还未创建的时候触发；

所以它优先于BeanFactoryPostProcessor执行；利用BeanDefinitionRegistryPostProcessor可以给容器中再额外添加一些组件；

BeanDefinitionRegistry： Bean定义信息的保存中心，以后BeanFactory就是按照BeanDefinitionRegistry里面保存的每一个bean定义信息创建bean实例；

BeanDefinitionRegistryPostProcessor原理:

1）IOC容器创建对象

2）调用AbstractApplicationContext的refresh()方法中的invokeBeanFactoryPostProcessors(beanFactory)；

3）从容器中获取到所有的BeanDefinitionRegistryPostProcessor组件。

//PostProcessorRegistrationDelegate.class
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

3.1）调用invokeBeanDefinitionRegistryPostProcessors依次触发所有的postProcessBeanDefinitionRegistry()方法

//PostProcessorRegistrationDelegate.class
private static void invokeBeanDefinitionRegistryPostProcessors(Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
        Iterator var2 = postProcessors.iterator();
        while(var2.hasNext()) {
            BeanDefinitionRegistryPostProcessor postProcessor = (BeanDefinitionRegistryPostProcessor)var2.next();
            postProcessor.postProcessBeanDefinitionRegistry(registry);
        }

    }

3.2）再来触发BeanFactoryPostProcessor的postProcessBeanFactory()方法；

//PostProcessorRegistrationDelegate.class
private static void invokeBeanFactoryPostProcessors(Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
        Iterator var2 = postProcessors.iterator();

        while(var2.hasNext()) {
            BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var2.next();
            postProcessor.postProcessBeanFactory(beanFactory);
        }

    }

4）再来从容器中找到BeanFactoryPostProcessor组件；然后依次触发postProcessBeanFactory()方法

//PostProcessorRegistrationDelegate.class
private static void invokeBeanFactoryPostProcessors(
            Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {

        for (BeanFactoryPostProcessor postProcessor : postProcessors) {
            postProcessor.postProcessBeanFactory(beanFactory);
        }
    }

3.ApplicationListener

public interface ApplicationListener<E extends ApplicationEvent>

监听 ApplicationEvent 及其下面的子事件；

实现步骤：

1）写一个监听器（ApplicationListener实现类）来监听某个事件（ApplicationEvent及其子类）

@Component
public class MyApplicationListener implements ApplicationListener<ApplicationEvent> {

2）把监听器加入到容器； @Component

3）只要容器中有相关事件的发布，我们就能监听到这个事件；
ContextRefreshedEvent：容器刷新完成（所有bean都完全创建）会发布这个事件；
ContextClosedEvent：关闭容器会发布这个事件；

4）、发布一个事件：applicationContext.publishEvent()；

applicationContext.publishEvent(new ApplicationEvent(new String("发布事件")) {
        });

事件原理：

1）ContextRefreshedEvent事件：

1.1）容器创建对象：refresh()；

1.2）finishRefresh();容器刷新完成会发布ContextRefreshedEvent事件

//AbstractApplicationContext.class
publishEvent(new ContextRefreshedEvent(this));

2）自己发布事件；

3）容器关闭会发布ContextClosedEvent；

【发布事件】

publishEvent(new ContextRefreshedEvent(this));

1）获取事件的多播器（派发器）：getApplicationEventMulticaster()

2）multicastEvent派发事件(原理见下);

3）获取到所有的ApplicationListener【原理见下】；

for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {

3.1）、如果有Executor，可以支持使用Executor进行异步派发；

Executor executor = getTaskExecutor();

3.2）、否则，同步的方式直接执行listener方法；invokeListener(listener,event);拿到listener回调onApplicationEvent方法；

【事件多播器（派发器）】

1.1）容器创建对象：refresh()；

1.2）在refresh中调用initApplicationEventMulticaster();初始化applicationEventMulticaster

1.2.1）先去容器中找有没有id=“applicationEventMulticaster”的组件；

1.2.2）如果没有this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);并且加入到容器中，我们就可以在其他组件要派发事件时候，自动注入这个applicationEventMulticaster；

【容器中有哪些监听器】

1）容器创建对象：refresh();

2）registerListeners();从容器中拿到所有的监听器，把他们注册到applicationEventMulticaster中；

String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
//将listener注册到ApplicationEventMulticaster中
   getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);

注解实现监听

@EventListener

//可以写多个
@EventListener(classes={ApplicationEvent.class})
public void listen(ApplicationEvent event){
        System.out.println("UserService监听事件:"+event);
    }

@EventListener原理：
使用EventListenerMethodProcessor处理器来解析方法上的@EventListener；

SmartInitializingSingleton 原理：

1）ioc容器创建对象并refresh()；

2）finishBeanFactoryInitialization(beanFactory);调用preInstantiateSingletons，初始化剩下的单实例bean；

2.1）先创建所有的单实例bean；getBean();

//DefaultListableBeanFactory implement ConfigurableListableBeanFactory 
//实现了方法preInstantiateSingletons
for (String beanName : beanNames) {
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) {
                    final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                            @Override
                            public Boolean run() {
                                return ((SmartFactoryBean<?>) factory).isEagerInit();
                            }
                        }, getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
                else {
                    getBean(beanName);
                }
            }
        }

2.2）获取所有创建好的单实例bean，判断是否是SmartInitializingSingleton类型的；如果是就调用afterSingletonsInstantiated();

//DefaultListableBeanFactory implement ConfigurableListableBeanFactory 
//实现了方法preInstantiateSingletons
for (String beanName : beanNames) {
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged(new PrivilegedAction<Object>() {
                        @Override
                        public Object run() {
                            smartSingleton.afterSingletonsInstantiated();
                            return null;
                        }
                    }, getAccessControlContext());
                }
                else {
                    smartSingleton.afterSingletonsInstantiated();
                }
            }
        }

3）调用EventListenerMethodProcessor实现的 SmartInitializingSingleton接口的afterSingletonsInstantiated方法

for (Method method : annotatedMethods.keySet()) {
                    for (EventListenerFactory factory : factories) {
                        if (factory.supportsMethod(method)) {
                            Method methodToUse = AopUtils.selectInvocableMethod(
                                    method, this.applicationContext.getType(beanName));
                            ApplicationListener<?> applicationListener =
                                    factory.createApplicationListener(beanName, targetType, methodToUse);
                            if (applicationListener instanceof ApplicationListenerMethodAdapter) {
                                ((ApplicationListenerMethodAdapter) applicationListener)
                                        .init(this.applicationContext, this.evaluator);
                            }
                            this.applicationContext.addApplicationListener(applicationListener);
                            break;
                        }
                    }