Spring的核心Refresh

Posted on | In
Words count in article: 3k | Reading time ≈ 13

在注册配置文件后的刷新（Refresh）

在上一篇文章中，主要理清了Spring是如何（通过 register(Class<?>... componentClasses) ）注册一个或多个要处理的配置类。

但是如果不进行下一步，也就是刷新（refresh）容器，整个类是得不到完全的处理的。下图是对 refresh 方法进行的主要过程总结。会通过对每一条线上的方法进行分析和总结方法的用途。

20191123225557.png

1.prepareRefresh

prepareRefresh 是 refresh 的第一个方法，用来准备上下文环境以用来刷新（refresh）。

  1. 设置startupDate启动时间、设置closed为false，设置active为true.
  2. initPropertySources()方法，留给子类自行实现，用来在上下文环境中初始化任何占位符属性源.
  3. validateRequiredProperties() 用来验证所有的Proprities都是可解析的.
  4. 最后存储预刷新的ApplicationListeners。也就是初始化earlyApplicationEvents；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
protected void prepareRefresh() {
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);
    this.active.set(**true**);
    // ...省略部分代码.
    // 在上下文环境中初始化任何占位符属性源，子类继承实现
    initPropertySources();

    // 验证所有必须的Property都是可解析的
    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);
    }

    this.earlyApplicationEvents = new LinkedHashSet<>();
}

2.obtainFreshBeanFactory

用于获取BeanFactory,在 obtainFreshBeanFactory 方法中有两个子方法。

  • refreshBeanFactory方法为BeanFactory设置SerializationId
1
2
3
4
5
6
7
8
protected final void refreshBeanFactory() throws IllegalStateException {
    // ...省略部分代码
    // 在register的时候，通过registerBeanDefinition时会创建一个beanFactory为DefaultListableBeanFactory
    this.beanFactory.setSerializationId(getId());
}
public final ConfigurableListableBeanFactory getBeanFactory() {
    return this.beanFactory;
}
  • 使用getBeanFactory获取在register过程中已经产生的beanFactory。
1
2
3
4
@Override
public final ConfigurableListableBeanFactory getBeanFactory() {
    return this.beanFactory;
}

在上一篇文章中已经分析得知，在GenericApplicationContext的this.beanFactory 就是创建ApplicationContext时在构造函数中创建的DefaultListableBeanFactory。

3.prepareBeanFactory

在这个方法里面实现类对BeanFactory的内容进行基本的初始化。设置了 classLoador、ExpressionResolver、BeanPostProcessor等等属性。

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
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    beanFactory.setBeanClassLoader(getClassLoader());
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
  beanFactory.addPropertyEditorRegistrar(newResourceEditorRegistrar(this,getEnvironment()));

    // 设置PostProcessor 回调方法
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    // 忽略给定的接口类的自动装配（就是不装配给定的接口类）
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

    // registerResolvableDependency的作用就是将 第一个参数作为依赖注入到第二个参数中
    // 这里的this指的就是AbstractApplicationContext
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    // Register early post-processor for detecting inner beans as ApplicationListeners. 注册一个applicationListeners检测器
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

    // 注册环境相关Bean
    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());
    }
}

4.postProcessBeanFactory

这个方法的含义为对BeanFactory的后置处理，方法的实现是空的，实际含义就是让子类去实现这个方法，然后调用的时候可以对BeanFactory在标准化的初始后，进行自定义的后置处理。

5.invokeBeanFactoryPostProcessors

方法的作用就是实例化并调用所有已注册的BeanFactoryPostProcessor，也就是在这一步完成对configuration配置类中的Bean的注册过程。主要的执行方法是 PostProcessorRegistrationDelegate 中的 invokeBeanFactoryPostProcessors 方法。

在上一篇文章中提到了在 register 方法中，调用了 this.reader = new AnnotatedBeanDefinitionReader(this) 后，使用 registerAnnotationConfigProcessors 注册一些相关配置类bean，如ConfigurationClassPostProcessor等等。

首先、如果有BeanFactoryPostProcessor,则会先执行类中的 postProcessBeanDefinitionRegistry 方法

1
2
3
4
5
6
7
8
9
10
11
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
    if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
        BeanDefinitionRegistryPostProcessor registryProcessor =
                (BeanDefinitionRegistryPostProcessor) postProcessor;
        registryProcessor.postProcessBeanDefinitionRegistry(registry);
        registryProcessors.add(registryProcessor);
    }
    else {
        regularPostProcessors.add(postProcessor);
    }
}

第二步、会处理在beanFactory中存在的继承BeanDefinitionRegistryPostProcessor 并且实现了PriorityOrdered 接口的类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
String[] postProcessorNames =
        beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
    if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
        processedBeans.add(ppName);
    }
}
// 对依赖排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 添加到registryProcessors中
registryProcessors.addAll(currentRegistryProcessors);
// 执行{ConfigurationClassPostProcessor的}后置方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 清空当前注册处理器
currentRegistryProcessors.clear();

通过Type获取BeanNames

其中使用了方法 getBeanNamesForType 用来类型为BeanDefinitionRegistryPostProcessor的Bean的名称。

1
2
3
4
5
@Override
public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
    if (!isConfigurationFrozen() || type == null || !allowEagerInit) {
        return doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit);
    }

在 doGetBeanNamesForType 中，会通过循环 this.beanDefinitionNames 内容，获取所有的 RootBeanDefinition。通过debug可以看到在此处所有的 beanDefinitionNames为

图片1

可以发现是在上一篇文章中提到的 new AnnotatedBeanDefinitionReader 的时候默认register的一些配置类。在通过使用isTypeMatch方法对所有获取到name循环比较。符合则将内容返回（只有ConfigurationAnnotationProcessor满足条件）。

执行ConfigurationAnnotationProcessor的后置方法

通过调用ConfigurationClassPostProcessor中的processConfigBeanDefinitions方法进行【构建和验证配置类】，完成对配置文件中Bean的装配，具体步骤如下：

  1. 获得符合条件的配置类
  2. 使用@Order的顺序进行排序
  3. 获取到处理每一个@Configuration处理类
  4. 处理所有@Configuration的类
  5. 验证所有@Coniguration的类

更具体的内容在后续再详细介绍。

第三步、会处理在beanFactory中存在的 继承 BeanDefinitionRegistryPostProcessor 并且实现了Ordered 接口的类中的

1
2
3
4
5
// 只列出差异点
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    processedBeans.add(ppName);
}

和第二步几乎一样，同样会对依赖排序、添加到registryProcessors中到、处理后置方法等。

最后、处理剩下的BeanDefinitionRegistryPostProcessor类

和前两步相似的重复的操作。就不展示代码了。

激活所有BeanFactoryPostProcessors

处理完所有的BeanDefinitionRegistryPostProcessors后，进行对Bean工厂的后置处理器处理。

1
2
3
4
5
6
7
8
9
10
11
// 在前面处理过的 registryProcessors 处理器
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);

private static void invokeBeanFactoryPostProcessors(
        Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
 // 执行postProcessBeanFactory回调方法
    for (BeanFactoryPostProcessor postProcessor : postProcessors) {
        postProcessor.postProcessBeanFactory(beanFactory);
    }
}

上面是针对 beanFactory instanceof BeanDefinitionRegistry 的情况，如果返回false，具体内容可能稍有不容。但大致上没什么区别.

5.registerBeanPostProcessors

就像名字一样，registerBeanPostProcessors 的作用就是注册 BeanPostProcessors，注册Bean的后置处理器。

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

调用PostProcessorRegistrationDelegate的静态方法 registerBeanPostProcessors

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
public static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    // 获得所有的BeanPostProcessor
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    // 注册一个BeanPostProcessorChecker用来在BeanPostProcessor实例化Bean时打印信息
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    // Separate between BeanPostProcessors that implement PriorityOrdered,
    // Ordered, and the rest.
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // First, register the BeanPostProcessors that implement PriorityOrdered.
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    // Next, register the BeanPostProcessors that implement Ordered.
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    for (String ppName : orderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    // Now, register all regular BeanPostProcessors.
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String ppName : nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

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

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

过程类似 invokeBeanFactoryPostProcessors 的过程，实际过程分步可以整理如下：

  1. 获得所有的BeanPostProcessor，并注册一个BeanPostProcessorChecker，用来在BeanPostProcessor中创建Bean时打印信息。
  2. 首先注册继承了PriorityOrdered接口的BeanPostProcessor;
  3. 然后注册继承了Ordered接口的 BeanPostProcessor;然后注册所有的普通的 BeanPostProcessor；
  4. 最后注册所有的内部的BeanPostProcessor;

不管如何最后的结果都是将实现BeanPostProcessor的类注册到BeanFactory中。注册的过程就是一个CopyOnWriteArrayList添加的过程

6.initMessageSource

处理初始化消息来源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
protected void initMessageSource() {
    // 获得beanFactory
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 如果包含name为 messageSource 的bean
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        // 让当前 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 {
        // 如果不存在MS，则新建一个空的 MessageSource
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        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 + "]");
        }
    }
}

在 initMessageSource 过程中，做的事情很简单，主要分两步：

  1. 如果包含messageSource的Bean，则设置父MessageSource
  2. 如果不包含 messageSource 的 Bean，则创建一个 DelegatingMessageSource 的单例Bean并注册到 beanFactory 中。

7. initApplicationEventMulticaster

初始化应用事件多播器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        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);
        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() + "]");
        }
    }
}

和初始化MessageSource过程相似,如果包含 applicationEventMulticaster，则设置 this.applicationEventMulticaster 为容器中的多播器。如果没有，则创建，并使用beanFactory进行注册为单例的Bean。

8. onRefresh

方法用于在特定上下文子类中初始化其他特殊bean，点进方法后显示是一个空方法，是留给子类自行去实现的，去处理特殊的bean。

9. registerListeners

注册Listeners

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
protected void registerListeners() {
    // 首先注册静态的listener
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }
    // 发布早起的应用事件
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (earlyEventsToProcess != null) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

10.finishBeanFactoryInitialization

用于完成BeanFactory的初始化，在这一步完成了所有的剩余的单实例Bean的初始化过程。

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
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    //初始化 conversionService Bean
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
            beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
                beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }

    // Register a default embedded value resolver if no bean post-processor
    // (such as a PropertyPlaceholderConfigurer bean) registered any before:
    // at this point, primarily for resolution in annotation attribute values.
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }

    // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    // Stop using the temporary ClassLoader for type matching.
    beanFactory.setTempClassLoader(null);

    // Allow for caching all bean definition metadata, not expecting further changes.
    beanFactory.freezeConfiguration();

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

主要过程包括：

  1. 初始化 conversionService ;
  2. 如果没有内置的Value解析器，则设置一个StringValueResolver解析器到beanFactory中。
  3. 初始化LoadTimeWeaverAware；
  4. 停止使用临时的ClassLoader进行类型匹配。
  5. 允许缓存所有bean定义元数据，而不期望进一步的更改。
  6. 实例化所有的剩余的、非懒加载的单实例Bean。

这里只针对第6条的实例化剩余的单实例Bean进行源码分析：

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
beanFactory.preInstantiateSingletons();

@Override
public void preInstantiateSingletons() throws BeansException {
    // 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.
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    // Trigger initialization of all non-lazy singleton beans...
    for (String beanName : beanNames) {
        // 如果对应子Bean的定义，则遍历父Bean定义得到一个合并的RootBeanDefinition
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        //如果这个Bean不是abstract、是单例的、非懒加载的
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // 如果是FactoryBean
            if (isFactoryBean(beanName)) {
            // 想使用getBean时需要添加 & 前缀
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    final 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进行初始化
                        getBean(beanName);
                    }
                }
            }
            else {
                // 调用getBean进行初始化
                getBean(beanName);
            }
        }
    }
    // Trigger post-initialization callback for all applicable beans...
}

经过上面的分析可以看出：在preInstantiateSingletons方法中，真正去实例化的方式是去调用 getBean方法。

接下来分析配置文件中的Bean的注册和使用 getBean 进行真正的实例化过程进行分析。

-------------本文结束感谢您的阅读-------------

本文标题:Spring的核心Refresh

文章作者:NanYin

发布时间:2019年12月15日 - 15:12

最后更新:2023年07月30日 - 17:07

原始链接:https://nanyiniu.github.io/2019/12/15/Spring%E4%BB%8E%E9%9B%B6%E5%BC%80%E5%A7%8B%E4%B9%8B%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%BA%8C%EF%BC%89/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。