devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Spring08】SpringIOC容器启动的过程及原理_spring ioc容器启动流程

作者：weixin_40725706 | 2024-03-15 14:00:45

赞

踩

spring ioc容器启动流程

SpringIOC容器启动的过程及原理

一、Spring启动概览

Spring的IOC启动的过程重点在于其refresh(); 方法。
在这里插入图片描述

其源码关键节点转化为流程图如下：
在这里插入图片描述

二、Spring启动源码详解

2.1 刷新前的预处理

prepareRefresh(); // Prepare this context for refreshing. 刷新前的预处理；

// Prepare this context for refreshing.
prepareRefresh();

  • 1
  • 2
protected void prepareRefresh() {
    // Switch to active.
    // 初始化值
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);
    this.active.set(true);

    if (logger.isDebugEnabled()) {
        if (logger.isTraceEnabled()) {
            logger.trace("Refreshing " + this);
        }
        else {
            logger.debug("Refreshing " + getDisplayName());
        }
    }

    // Initialize any placeholder property sources in the context environment.
    // 子类自定义个性化属性方法
    initPropertySources();

    // Validate that all properties marked as required are resolvable:
    // see ConfigurablePropertyResolver#setRequiredProperties
    // 校验环境属性合法性
    getEnvironment().validateRequiredProperties();

    // 保存一些早期事件监听器
    // Store pre-refresh ApplicationListeners...
    if (this.earlyApplicationListeners == null) {
        this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
    }
    else {
        // Reset local application listeners to pre-refresh state.
        this.applicationListeners.clear();
        this.applicationListeners.addAll(this.earlyApplicationListeners);
    }

    // Allow for the collection of early ApplicationEvents,
    // to be published once the multicaster is available...
    this.earlyApplicationEvents = new LinkedHashSet<>();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

该步骤较为重点的操作为：

1）initPropertySources(); 初始化一些属性设置；子类自定义个性化的属性设置方法
2）getEnvironment().validateRequiredProperties(); 校验环境属性合法性
3）保存一些早期事件监听器至 this.applicationListeners

2.2 获取初始化BeanFactory

obtainFreshBeanFactory(); 初始化BeanFactory

// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

  • 1
  • 2
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    refreshBeanFactory();
    return getBeanFactory();
}

  • 1
  • 2
  • 3
  • 4

该步骤较为重点的操作为：

1）refreshBeanFactory(); 刷新BeanFactory；

protected final void refreshBeanFactory() throws BeansException {
    // 存在BeanFactory则先销毁关闭
    if (hasBeanFactory()) {
        destroyBeans();
        closeBeanFactory();
    }
    try {
        // 初始化BeanFactory this.beanFactory = new DefaultListableBeanFactory();
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        // 赋值ID
        beanFactory.setSerializationId(getId());
        customizeBeanFactory(beanFactory);
        // beanFactory——加载Bean定义信息
        loadBeanDefinitions(beanFactory);
        this.beanFactory = beanFactory;
    }
    catch (IOException ex) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

2）getBeanFactory(); 返回刚才创建的beanFactory对象

2.3 BeanFactory的预准备工作

prepareBeanFactory(beanFactory); BeanFactory的预准备工作（对初始化的BeanFactory进行一些设置）；

// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);

  • 1
  • 2

在这里插入图片描述

该步骤较为重点的操作为：

1）设置BeanFactory的类加载器、支持表达式解析器…

beanFactory.setBeanClassLoader(getClassLoader());
if (!shouldIgnoreSpel) {
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
}
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

  • 1
  • 2
  • 3
  • 4
  • 5

2）添加部分的后置处理器【ApplicationContextAwareProcessor】

beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

  • 1

3）设置忽略自动装配的接口，对于实现这些接口的类容器不进行自动注入；

beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

4）设置可以解析的自动装配；我们可以直接在任何组件中自动注入（@AutoWire）

BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext

beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);

  • 1
  • 2
  • 3
  • 4

5）添加后置处理器【ApplicationListenerDetector】用于 ApplicationListeners 事件监听器；

beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

  • 1

6）给BeanFactory中注册一些能用的组件；environment【ConfigurableEnvironment】、systemProperties、systemEnvironment、applicationStartup

// Register default environment beans.
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
    beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
    beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
    beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
    beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

2.4 子类对BeanFactory进一步设置

postProcessBeanFactory(beanFactory); BeanFactory准备工作完成后进行的后置处理器工作；

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}

  • 1
  • 2

在这里插入图片描述

子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置。

例如子类：ServletWebServerApplicationContext 的 postProcessBeanFactory()

添加了一个后置处理器、忽略了ServletContextAware、注册了web的作用域信息。

2.5 执行部分类型后置处理器

invokeBeanFactoryPostProcessors(beanFactory); 执行BeanFactoryPostProcessors；

// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);

  • 1
  • 2
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    // 执行部分类型后置处理器
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
	......
}

  • 1
  • 2
  • 3
  • 4
  • 5

在这里插入图片描述

该步骤较为重点的操作为：

执行了两个特殊的后置处理器：BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessors

先执行 BeanDefinitionRegistryPostProcessor
1）获取所有的BeanDefinitionRegistryPostProcessor；
2）先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor、
3）在执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor；
4）最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors；
invokeBeanDefinitionRegistryPostProcessors() -> postProcessBeanDefinitionRegistry()
invokeBeanFactoryPostProcessors() -> postProcessBeanFactory()

再执行BeanFactoryPostProcessor的方法
1）获取所有的BeanFactoryPostProcessor
2）看先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor;
3）在执行实现了Ordered顺序接口的BeanFactoryPostProcessor；
4）最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor；
invokeBeanFactoryPostProcessors() -> postProcessBeanFactory()

2.6 注册bean的后置处理器

registerBeanPostProcessors(beanFactory); 注册bean的后置处理器；

// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);

  • 1
  • 2
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

  • 1
  • 2
  • 3

在这里插入图片描述

不同接口类型的 BeanPostProcessor，在bean创建前后执行的时机是不一样的

BeanPostProcessor 接口还存在多个子接口：
DestructionAwareBeanPostProcessor、
InstantiationAwareBeanPostProcessor、
SmartInstantiationAwareBeanPostProcessor、
MergedBeanDefinitionPostProcessor【internalPostProcessors】…等等

该步骤较为重点的操作为：

1）所有的后置处理器 BeanPostProcessor，都可以默认通过PriorityOrdered、Ordered接口来执行优先级

2）先注册 PriorityOrdered 优先级接口的BeanPostProcessor
把每个BeanPostProcessor添加至 BeanFactory中
registerBeanPostProcessors(beanFactory, orderedPostProcessors); -> beanFactory.addBeanPostProcessor(postProcessor);

private static void registerBeanPostProcessors(
    ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {

    if (beanFactory instanceof AbstractBeanFactory) {
        // Bulk addition is more efficient against our CopyOnWriteArrayList there
        ((AbstractBeanFactory) beanFactory).addBeanPostProcessors(postProcessors);
    }
    else {
        for (BeanPostProcessor postProcessor : postProcessors) {
            beanFactory.addBeanPostProcessor(postProcessor);
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

3）再注册实现Ordered接口的BeanPostProcessor

4）再注册没有实现任何优先级接口的

5）最后注册 MergedBeanDefinitionPostProcessor

if (pp instanceof MergedBeanDefinitionPostProcessor) {
    internalPostProcessors.add(pp);
}

// Finally, re-register all internal BeanPostProcessors.
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

6）添加一个 ApplicationListenerDetector ：在bean创建完成后检查bean是否是 ApplicationListener
如果是则添加至 this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);

// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));

  • 1
  • 2
  • 3

2.7 初始化MessageSource组件

initMessageSource(); 初始化MessageSource组件（做国际化功能、消息绑定、消息解析）；

// Initialize message source for this context.
initMessageSource();

  • 1
  • 2
protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 查看容器中是否存在 id为messageSource的，类型是MessageSource的组件
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        // 有则赋值给 messageSource
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        // Make MessageSource aware of parent MessageSource.
        // 设置 messageSource的父级
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
            if (hms.getParentMessageSource() == null) {
                // Only set parent context as parent MessageSource if no parent MessageSource
                // registered already.
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
        if (logger.isTraceEnabled()) {
            logger.trace("Using MessageSource [" + this.messageSource + "]");
        }
    }
    else {
        // 没有自己创建一个DelegatingMessageSource；
        // Use empty MessageSource to be able to accept getMessage calls.
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        // 把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；
        this.messageSource = dms;
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
        if (logger.isTraceEnabled()) {
            logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取；

该步骤较为重点的操作为：

1）看容器中是否有id为messageSource的，类型是MessageSource的组件.
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) ?

2）容器中存在，取到bean赋值给messageSource

3）容器中不存在，自己创建一个DelegatingMessageSource；
把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);

2.8 初始化事件派发器

initApplicationEventMulticaster(); 初始化事件派发器；事件派发器用于事件监听和派发。

// Initialize event multicaster for this context.
initApplicationEventMulticaster();

  • 1
  • 2
protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 查询是否存在ID为：applicationEventMulticaster 的bean
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        // 存在给 this.applicationEventMulticaster 赋值
        this.applicationEventMulticaster =
            beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        if (logger.isTraceEnabled()) {
            logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    }
    else {
        // 没有这初始化创建多播器
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        // 并加到容器中,自动注入这个 applicationEventMulticaster
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
        if (logger.isTraceEnabled()) {
            logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
                         "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

2.9 子类重写容器刷新方法

onRefresh(); 子类重写这个方法，在容器刷新的时候可以自定义逻辑；

// Initialize other special beans in specific context subclasses.
onRefresh();

  • 1
  • 2
protected void onRefresh() throws BeansException {
    // For subclasses: do nothing by default.
}

  • 1
  • 2
  • 3

2.10 注册事件监听器

registerListeners(); 注册事件监听器；

// Check for listener beans and register them.
registerListeners();

  • 1
  • 2
protected void registerListeners() {
    // Register statically specified listeners first.
    // 获取已有的 this.applicationListeners 所有监听器 ApplicationListener
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        // 监听器加入到事件派发器中
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // uninitialized to let post-processors apply to them!
    // 获取ApplicationListener类的监听器
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    // 监听器加入到事件派发器中
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    // Publish early application events now that we finally have a multicaster...
    // 派发之前步骤产生的提前事件； this.earlyApplicationEvents
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

该步骤较为重点的操作为：

1）从容器中拿到所有的监听器 ApplicationListener.class
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);

2）把他们注册到 applicationEventMulticaster （事件多播器）中
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);

3）派发之前步骤产生的事件； this.earlyApplicationEvents
getApplicationEventMulticaster().multicastEvent(earlyEvent);

2.11 【重点】初始化余下单实例bean

finishBeanFactoryInitialization(beanFactory); 初始化剩下的单实例bean；

// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);

finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // ......
    
    // Instantiate all remaining (non-lazy-init) singletons.
    // 初始化后剩下的单实例bean
    beanFactory.preInstantiateSingletons();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
public void preInstantiateSingletons() throws BeansException {
    if (logger.isTraceEnabled()) {
        logger.trace("Pre-instantiating singletons in " + this);
    }

    // Iterate over a copy to allow for init methods which in turn register new bean definitions.
    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    // 1）获取容器中所有的bean
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    // Trigger initialization of all non-lazy singleton beans...
    for (String beanName : beanNames) {
        // 2）获取bean的定义信息
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        // 3）bean不是抽象的，是单实例，不是懒加载的
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // 判断是否是FactoryBean；是否是实现FactoryBean接口的Bean；是则为FactoryBean创建bean，使用其getObject()返回的bean
            if (isFactoryBean(beanName)) {
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    FactoryBean<?> factory = (FactoryBean<?>) bean;
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged(
                            (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
                            getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                       ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
            }
            else {
                // 4）利用getBean(beanName) -> doGetBean() ;创建对象
                getBean(beanName);
            }
        }
    }

    // Trigger post-initialization callback for all applicable beans...
    // 5）所有的bean都利用getBean()创建完成后
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        // bean 是否为 SmartInitializingSingleton，为则执行其 afterSingletonsInstantiated()方法
        if (singletonInstance instanceof SmartInitializingSingleton) {
            StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
                .tag("beanName", beanName);
            SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    smartSingleton.afterSingletonsInstantiated();
                    return null;
                }, getAccessControlContext());
            }
            else {
                // SmartInitializingSingleton -> afterSingletonsInstantiated()
                smartSingleton.afterSingletonsInstantiated();
            }
            smartInitialize.end();
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66

重点解析一下第四点 —— 创建对象

利用getBean(beanName) -> doGetBean() ;创建对象
protected <T> T doGetBean(
    String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    throws BeansException {

    String beanName = transformedBeanName(name);
    Object beanInstance;

    // Eagerly check singleton cache for manually registered singletons.
    // 1）getSingleton(beanName); 先获取缓存中保存的单实例bean
    Object sharedInstance = getSingleton(beanName);
    // 获取的bean不为空，则获取bean实例返回
    if (sharedInstance != null && args == null) {
        if (logger.isTraceEnabled()) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                             "' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
                logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    // 2）缓存中获取不到，开始bean的创建过程
    else {
        // ......

        if (!typeCheckOnly) {
            // 3）首先标记当前bean已经被创建，保证bean的单例；
            markBeanAsCreated(beanName);
        }

        StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
            .tag("beanName", name);
        try {
            if (requiredType != null) {
                beanCreation.tag("beanType", requiredType::toString);
            }
            // 4）获取bean的定义信息；RootBeanDefinition
            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // Guarantee initialization of beans that the current bean depends on.
            // 5）获取当前bean依赖的其他bean；如果有按照getBean()把依赖的bean先创建出来；
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                        "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    registerDependentBean(dep, beanName);
                    try {
                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                        "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }

            // Create bean instance.
            if (mbd.isSingleton()) {
                // 7）将创建的bean添加到缓存中 singletonObjects，ioc容器就是这些map；很多的map里面保存了单实例beans，环境信息....
                // getSingleton() -> addSingleton(beanName, singletonObject);
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        // 6）启动单实例bean的创建流程
                        return createBean(beanName, mbd, args);
                    }
                });
                beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }

            else if (mbd.isPrototype()) {
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }

            else {
                String scopeName = mbd.getScope();
                if (!StringUtils.hasLength(scopeName)) {
                    throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
                }
                Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                }
                try {
                    Object scopedInstance = scope.get(beanName, () -> {
                        beforePrototypeCreation(beanName);
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        finally {
                            afterPrototypeCreation(beanName);
                        }
                    });
                    beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                }
                catch (IllegalStateException ex) {
                    throw new ScopeNotActiveException(beanName, scopeName, ex);
                }
            }
        }
        finally {
            beanCreation.end();
        }
    }

    return adaptBeanInstance(name, beanInstance, requiredType);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121

重点解析 第 6）启动单实例bean的创建流程

createBean(beanName, mbd, args); 创建bean

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    throws BeanCreationException {

   // ......
    
    try {
        // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
        // 1）给BeanPostProcessors一个返回代理而不是目标bean实例的机会。
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        // 2）如果步骤1，有代理对象，则直接返回
        if (bean != null) {
            return bean;
        }
    }

    try {
        // 3）创建对象
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isTraceEnabled()) {
            logger.trace("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    } // ......
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

1）Object bean = resolveBeforeInstantiation(beanName, mbdToUse); BeanPostProcessors返回代理对象

让BeanPostProcessor先拦截【InstantiationAwareBeanPostProcessor】，返回代理对象【AOP自动配置开启原理】

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        // Make sure bean class is actually resolved at this point.
        // 判断 BeanPostProcessor 是否存在 InstantiationAwareBeanPostProcessor
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            Class<?> targetType = determineTargetType(beanName, mbd);
            if (targetType != null) {
                // 先触发：postProcessBeforeInstantiation()；
                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                // 如果有返回值：触发postProcessAfterInitialization()；
                if (bean != null) {
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }
        mbd.beforeInstantiationResolved = (bean != null);
    }
    return bean;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

2）如果步骤1，有代理对象，则直接返回
3）如果步骤1没值，这进行bean的创建

Object beanInstance = doCreateBean(beanName, mbdToUse, args);

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    throws BeanCreationException {

    // Instantiate the bean.
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        // 1）【创建bean实例】利用工厂方法或者对象的构造器
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }

    // Allow post-processors to modify the merged bean definition.
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                // 2）调用 MergedBeanDefinitionPostProcessor -> postProcessMergedBeanDefinition()
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            mbd.postProcessed = true;
        }
    }
    // ......

    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        // 3）【bean属性赋值】上述对bean进行实例化了，但是bean并没有具体的属性值
        populateBean(beanName, mbd, instanceWrapper);
        // 4）【bean初始化】
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    // ......

    // Register bean as disposable.
    // 5）注册bean的销毁方法 DisposableBeanAdapter -> DisposableBean
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }

    return exposedObject;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52

3）【bean属性赋值】上述对bean进行实例化了，但是bean并没有具体的属性值

populateBean(beanName, mbd, instanceWrapper);

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
   	// ......

    // 1）赋值之前 hasInstantiationAwareBeanPostProcessors() 判断是否为 InstantiationAwareBeanPostProcessor
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
            // 执行 InstantiationAwareBeanPostProcessor -> postProcessAfterInstantiation()
            if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                return;
            }
        }
    }

    PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

	// ......

    // 2）再次拿到 InstantiationAwareBeanPostProcessor 后置处理器
    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

    PropertyDescriptor[] filteredPds = null;
    if (hasInstAwareBpps) {
        if (pvs == null) {
            pvs = mbd.getPropertyValues();
        }
        // 调用 postProcessProperties() 、 postProcessPropertyValues() 方法 获取bean属性的值
        for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
            PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
            if (pvsToUse == null) {
                if (filteredPds == null) {
                    filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                }
                pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                if (pvsToUse == null) {
                    return;
                }
            }
            pvs = pvsToUse;
        }
    }
	// ......

    // 3）应用bean属性的值：为属性利用setter方法进行赋值
    if (pvs != null) {
        applyPropertyValues(beanName, mbd, bw, pvs);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

4）【bean初始化】

exposedObject = initializeBean(beanName, exposedObject, mbd);

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    // 1）【执行Aware接口方法】执行部分xxxAware接口的方法； invokeAwareMethods(beanName, bean);
    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()) {
        // 2）【执行后置处理器之前方法】 BeanPostProcessor -> postProcessBeforeInitialization(result, beanName);
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        // 3) 【执行初始化方法】
        invokeInitMethods(beanName, wrappedBean, mbd);
    }

    
    if (mbd == null || !mbd.isSynthetic()) {
        // 4）【执行后置处理器之后方法】 BeanPostProcessor -> postProcessAfterInitialization(result, beanName);
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

3）【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);

​ 1）bean是否是 InitializingBean 接口的实现；是执行接口规定的初始化方法

​ ((InitializingBean) bean).afterPropertiesSet();

​ 2）是否自定义初始化方法； getInitMethodName();

​ mbd.getInitMethodName(); ——》invokeCustomInitMethod(beanName, bean, mbd);

2.12 完成IOC容器创建

finishRefresh(); 完成BeanFactory的初始化创建工作；IOC容器创建完成；

// Last step: publish corresponding event.
finishRefresh();

  • 1
  • 2
protected void finishRefresh() {
    // Clear context-level resource caches (such as ASM metadata from scanning).
    // 清除上下文级别的资源缓存（如扫描中的ASM元数据）
    clearResourceCaches();

    // Initialize lifecycle processor for this context.
    // 初始化和生命周期有关的后置处理器； LifecycleProcessor
    initLifecycleProcessor();

    // Propagate refresh to lifecycle processor first.
    // 获取前面的生命周期处理器，回调其onRefresh()方法
    getLifecycleProcessor().onRefresh();

    // Publish the final event.
    // 发布容器刷新完成事件；
    publishEvent(new ContextRefreshedEvent(this));

    // Participate in LiveBeansView MBean, if active.
    // 注册MBean
    if (!NativeDetector.inNativeImage()) {
        LiveBeansView.registerApplicationContext(this);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

该步骤较为重点的操作为：

1）clearResourceCaches(); 清除上下文级别的资源缓存（如扫描中的ASM元数据）

2）initLifecycleProcessor(); 初始化和生命周期有关的后置处理器； LifecycleProcessor

​ 默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】；如果没有new DefaultLifecycleProcessor()，加入到容器；

​ LifecycleProcessor -> void onRefresh(); / void onClose();

3）getLifecycleProcessor().onRefresh(); 获取前面的生命周期处理器，回调其onRefresh()方法

4）publishEvent(new ContextRefreshedEvent(this)); 发布容器刷新完成事件；

5）LiveBeansView.registerApplicationContext(this); 注册MBean

三、Spring启动源码全过程

Spring容器的 refresh(); 【创建和刷新】：
1）prepareRefresh(); // Prepare this context for refreshing. 刷新前的预处理；
	1）initPropertySources(); 初始化一些属性设置；子类自定义个性化的属性设置方法
	2）getEnvironment().validateRequiredProperties(); 校验环境属性合法性
	3）保存一些早期事件监听器至 this.applicationListeners

2）beanFactory = obtainFreshBeanFactory(); 获取BeanFactory；
	1）refreshBeanFactory(); 刷新BeanFactory；
		在 GenericApplicationContext 创建了 this.beanFactory = new DefaultListableBeanFactory();
		赋值了ID this.beanFactory.setSerializationId(getId());
	2）getBeanFactory(); 返回刚才创建的beanFactory对象

3）prepareBeanFactory(beanFactory); BeanFactory的预准备工作（对初始化的BeanFactory进行一些设置）；
	1）设置BeanFactory的类加载器、支持表达式解析器...
	2）添加部分的后置处理器【ApplicationContextAwareProcessor】
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
	3）设置忽略自动装配的接口，对于实现这些接口的类容器不进行自动注入；
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);...
	4）设置可以解析的自动装配；我们可以直接在任何组件中自动注入（@AutoWire）
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);...ResourceLoader、ApplicationEventPublisher
	5）添加后置处理器【ApplicationListenerDetector】用于 ApplicationListeners 事件监听器；
	6）给BeanFactory中注册一些能用的组件；environment【ConfigurableEnvironment】、systemProperties、systemEnvironment、applicationStartup

4）postProcessBeanFactory(beanFactory); BeanFactory准备工作完成后进行的后置处理器工作；
子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置

===================================== 以上为BeanFactory的预创建和准备工作 ==============================================================
5）invokeBeanFactoryPostProcessors(beanFactory); 执行BeanFactoryPostProcessors；
	BeanFactoryPostProcessors 和 BeanDefinitionRegistryPostProcessor

	先执行 BeanDefinitionRegistryPostProcessor
	1）、获取所有的BeanDefinitionRegistryPostProcessor；
	2）、先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor、
	3）、在执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor；
	4）、最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors；
	invokeBeanDefinitionRegistryPostProcessors() -> postProcessBeanDefinitionRegistry()
	invokeBeanFactoryPostProcessors() -> postProcessBeanFactory()

    再执行BeanFactoryPostProcessor的方法
	BeanFactoryPostProcessors：BeanFactory的后置处理器，在BeanFactory标准初始化之后执行的；
	执行 invokeBeanFactoryPostProcessors() 方法
    1）、获取所有的BeanFactoryPostProcessor
    2）、看先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor、
    3）、在执行实现了Ordered顺序接口的BeanFactoryPostProcessor；
    4）、最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor；
    invokeBeanFactoryPostProcessors() -> postProcessBeanFactory()

6）registerBeanPostProcessors(beanFactory); 注册bean的后置处理器；
    不同接口类型的 BeanPostProcessor，在bean创建前后执行的时机是不一样的
    BeanPostProcessor 接口还存在多个子接口：
    DestructionAwareBeanPostProcessor、
    InstantiationAwareBeanPostProcessor、
    SmartInstantiationAwareBeanPostProcessor、
    MergedBeanDefinitionPostProcessor【internalPostProcessors】...等等

	1）所有的后置处理器 BeanPostProcessor，都可以默认通过PriorityOrdered、Ordered接口来执行优先级
	2）先注册 PriorityOrdered 优先级接口的BeanPostProcessor
		把每个BeanPostProcessor添加至 BeanFactory中
		registerBeanPostProcessors(beanFactory, orderedPostProcessors); -> beanFactory.addBeanPostProcessor(postProcessor);
    3）再注册实现Ordered接口的BeanPostProcessor
    4）再注册没有实现任何优先级接口的
    5）最后注册 MergedBeanDefinitionPostProcessor
    6）添加一个 ApplicationListenerDetector ：在bean创建完成后检查bean是否是 ApplicationListener
		如果是则添加至 this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);

7）initMessageSource(); 初始化MessageSource组件（做国际化功能、消息绑定、消息解析） ；
	1）、看容器中是否有id为messageSource的，类型是MessageSource的组件
    	如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource；
		MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取；
	2）、把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
        MessageSource.getMessage(String code, Object[] args, String defaultMessage, Locale locale);

8）initApplicationEventMulticaster(); 初始化事件派发器；
	1）先去容器中查找ID为 "applicationEventMulticaster" 的组件
	2）如果没有这初始化创建多播器 ，并加到容器中，就可以在其他组件需要派发事件时，自动注入这个 applicationEventMulticaster
		this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);

9）onRefresh(); 子类重写这个方法，在容器刷新的时候可以自定义逻辑；

10）registerListeners(); 注册事件监听器；
	1）从容器中拿到所有的监听器 ApplicationListener.class
		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
	2）把他们注册到 applicationEventMulticaster （事件多播器）中
		getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
	3）派发之前步骤产生的事件； this.earlyApplicationEvents
		getApplicationEventMulticaster().multicastEvent(earlyEvent);

11）finishBeanFactoryInitialization(beanFactory); 初始化剩下的单实例bean
	beanFactory.preInstantiateSingletons(); 初始化后剩下的单实例bean
	1）获取容器中所有的bean，依次进行初始化和创建对象
	2）获取bean的定义信息
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
	3）bean不是抽象的，是单实例，不是懒加载的
		if(!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit())
		1）判断是否是FactoryBean；是否是实现FactoryBean接口的Bean；是则为FactoryBean创建bean，使用其getObject()返回的bean
         	if (isFactoryBean(beanName))
		2）不是FactoryBean，利用getBean(beanName);创建对象
	4）利用getBean(beanName) -> doGetBean() ;创建对象
		1）getSingleton(beanName); 先获取缓存中保存的单实例bean，如果能获取到说明这个bean之前被创建过（所有创建过的单实例Bean都会被缓存起来） 【三级缓存】
			this.singletonObjects.get(beanName); ->  Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); —> 单例对象的缓存：Cache of singleton objects
		2）缓存中获取不到，开始bean的创建过程
		3）markBeanAsCreated(beanName); 首先标记当前bean已经被创建，保证bean的单例；
		4）获取bean的定义信息；RootBeanDefinition
		5）获取当前bean依赖的其他bean；如果有按照getBean()把依赖的bean先创建出来；
		6）启动单实例bean的创建流程 createBean(beanName, mbd, args);
			1）Object bean = resolveBeforeInstantiation(beanName, mbdToUse); 
				让BeanPostProcessor先拦截【InstantiationAwareBeanPostProcessor】，返回代理对象【AOP自动配置开启原理】
				先触发：postProcessBeforeInstantiation()；
                如果有返回值：触发postProcessAfterInitialization()；
            2）如果步骤1，有代理返回值，则直接返回；否则调用步骤3
            3）	Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            	1）【创建bean实例】；createBeanInstance(beanName, mbd, args);
                	利用工厂方法或者对象的构造器
                2）applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                    调用  MergedBeanDefinitionPostProcessor -> postProcessMergedBeanDefinition()
                3）【bean属性赋值】上述对bean进行实例化了，但是bean并没有具体的属性值
                    populateBean(beanName, mbd, instanceWrapper);
                    1）赋值之前 hasInstantiationAwareBeanPostProcessors() 判断是否为 InstantiationAwareBeanPostProcessor
                    	InstantiationAwareBeanPostProcessor -> postProcessAfterInstantiation()
                    2）再次拿到 InstantiationAwareBeanPostProcessor 后置处理器
                        调用 postProcessProperties() 、 postProcessPropertyValues() 方法 获取bean属性的值
                   =====赋值之前：===
                   3）应用bean属性的值：为属性利用setter方法进行赋值
                        applyPropertyValues(beanName, mbd, bw, pvs);
                4）【bean初始化】 initializeBean(beanName, exposedObject, mbd);
                    1）【执行Aware接口方法】执行部分xxxAware接口的方法； invokeAwareMethods(beanName, bean);
                        BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
                    2）【执行后置处理器之前方法】 applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
                         BeanPostProcessor -> postProcessBeforeInitialization(result, beanName);
                    3) 【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);
                         1）bean是否是 InitializingBean 接口的实现；是执行接口规定的初始化方法
                             ((InitializingBean) bean).afterPropertiesSet();
                         2）是否自定义初始化方法； getInitMethodName();
                    4）【执行后置处理器之后方法】applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
                         BeanPostProcessor -> postProcessAfterInitialization(result, beanName);
                    5）注册bean的销毁方法；registerDisposableBeanIfNecessary(beanName, bean, mbd);
                         DisposableBeanAdapter -> DisposableBean
		7）将创建的bean添加到缓存中 singletonObjects
			getSingleton() -> addSingleton(beanName, singletonObject);
			ioc容器就是这些map；很多的map里面保存了单实例beans，环境信息....
	5）所有的bean都利用getBean()创建完成后，检查所有bean是否是 SmartInitializingSingleton 接口的bean
		是的话执行： org.springframework.beans.factory.SmartInitializingSingleton -> afterSingletonsInstantiated()

12）finishRefresh(); 完成BeanFactory的初始化创建工作；IOC容器创建完成；
	1）clearResourceCaches(); 清除上下文级别的资源缓存（如扫描中的ASM元数据）
	2）initLifecycleProcessor(); 初始化和生命周期有关的后置处理器； LifecycleProcessor
		默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】；如果没有new DefaultLifecycleProcessor()，加入到容器；
		LifecycleProcessor -> void onRefresh(); / void onClose();
	3) getLifecycleProcessor().onRefresh(); 获取前面的生命周期处理器，回调其onRefresh()方法
	4）publishEvent(new ContextRefreshedEvent(this)); 发布容器刷新完成事件；
	5）LiveBeansView.registerApplicationContext(this); 注册MBean

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154

四、总结

1）Spring容器在启动的时候，会先保存所有注册进来的bean的定义信息

  • xml注册bean；
  • 注解注册bean；@Service，@Component，@Bean

2）Spring容器会在合适的时机创建这些Bean

  • 用到这个bean的时候；利用getBean创建bean；创建好以后保存在容器中；
  • 统一创建剩下所有的bean的时候；finishBeanFactoryInitialization()；

3）后置处理器：

  • 每一个bean创建完成，都会使用各种后置处理器进行处理；来增强bean的功能；
  • AutowiredAnnotationBeanPostProcessor:处理自动注入
  • AnnotationAwareAspectJAutoProxyCreator:来做AOP功能

4）事件驱动模型；

  • ApplicationListener；事件监听；
  • ApplicationEventMulticaster；事件派发；

InitializingSingleton 接口的bean
是的话执行： org.springframework.beans.factory.SmartInitializingSingleton -> afterSingletonsInstantiated()

12）finishRefresh(); 完成BeanFactory的初始化创建工作；IOC容器创建完成；
1）clearResourceCaches(); 清除上下文级别的资源缓存（如扫描中的ASM元数据）
2）initLifecycleProcessor(); 初始化和生命周期有关的后置处理器； LifecycleProcessor
默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】；如果没有new DefaultLifecycleProcessor()，加入到容器；
LifecycleProcessor -> void onRefresh(); / void onClose();
3) getLifecycleProcessor().onRefresh(); 获取前面的生命周期处理器，回调其onRefresh()方法
4）publishEvent(new ContextRefreshedEvent(this)); 发布容器刷新完成事件；
5）LiveBeansView.registerApplicationContext(this); 注册MBean

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/241476
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号