Spring启动流程二

registerBeanPostProcessors：

注册bean处理器，这里只是注册功能，真正调用的是getBean

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

PostProcessorRegistrationDelegate.registerBeanPostProcessors(xxx, this)：

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
public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

    //从beanDefinitionMap中得到所有的BeanPostProcessor
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

    // 记录BeanPostProcessor 的目标计数
    // 为什么要 +1 呢？，原因很简单，此方法在后面添加了一个 BeanPostProcessorChecker 的类
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    // 添加BeanPostProcessorChecker （主要用于记录信息、没有实际意义，只记了一下log记录）到 beanFactory
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    // 定义存放 PriorityOrdered 接口的 BeanPostProcessor 集合
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    // 定义存放 spring 内部的BeanPostProcessor
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    // 定义存放实现了 Ordered接口的 BeanPostProcessor 的name 集合
    List<String> orderedPostProcessorNames = new ArrayList<>();
    // 定义存放普通的BeanPostProcessor 的name 集合   
    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);
        }
    }
    
    // 对实现了 PriorityOrdered 接口的BeanPostProcessor 实例进行排序
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    // 注册实现了PriorityOrdered 接口 的BeanPostProcessor 实例到 BeanFactory 中
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    // 注册所有实现Ordered的beanPostProcessor
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
    for (String ppName : orderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    // 排序  
    sortPostProcessors(orderedPostProcessors, beanFactory);
    // 注册到 beanFactory
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);  // 后面有介绍

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

    // 排序
    internalPostProcessors.remove(1);
    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));
}

registerBeanPostProcessors

1
2
3
4
5
6
7
private static void registerBeanPostProcessors(
								ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor>postProcessors) {
	for(BeanPostProcessor postProcessor : postProcessors) {
        // 添加到BeanFactory中
		beanFactory.addBeanPostProcessor(postProcessor); 
	}
}

initMessageSource：国际化处理

为上下文初始化message源头，即不同语言的消息体，国际化处理

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
protected void initMessageSource() {
    // 获取bean工厂
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //查找是否包含了名为messageSource的bean，如果没有，创建一个默认的
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        // 如果有，获取这个bean
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        // Make MessageSource aware of parent MessageSource.
        //判断是否有父类且是一个分层级的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.isDebugEnabled()) {
                logger.debug("Using MessageSource [" + this.messageSource + "]");
        }
    } else {
        // 如果没有xml文件定义信息源对象，新建 DelegatingMessageSource 类作为messageSource 的bean
        DelegatingMessageSource dms = new DelegatingMessageSource();
        // 给这个 DelegatingMessageSource 添加父类消息源
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        // 将这个 messageSource 实例注册到 bean工厂中
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
        if (logger.isDebugEnabled()) {
                logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
                    "': using default [" + this.messageSource + "]");
        }
    }
}

initApplicationEventMulticaster()：

初始化事件监听多路广播器

执行过程：

  1. 事件源发布不同的事件
  2. 当发布事件之后会调用多播器的方法来进行事件广播操作，由多播器去出发具体的监听器去执行操作
  3. 监听器接收到具体的事件之后，可以验证匹配是否能处理当前事件，如果可以，直接处理，如果不行，不做任何操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
protected void initApplicationEventMulticaster() {
    // 获取Bean工厂，一般是DefaultListableBeanFactory
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 判断是否存在 ApplicationEventMulticaster 的 beanDefinition,
    // 也就是说 自定义的事件监听多路广播器，必须实现 ApplicationListener
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
            // 如果存在，就用
            this.applicationEventMulticaster =
                        beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
            if (logger.isDebugEnabled()) {
                    logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
            }
    }
    else {
            // 如果不存在就创建一个
            this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
            beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
            if (logger.isDebugEnabled()) {
                    logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
                            APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
                            "': using default [" + this.applicationEventMulticaster + "]");
            }
    }
}

registerListeners ： 注册监听器

作用：在所有注册的bean中查找 listener 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
protected void registerListeners() {
    // 遍历应用程序中存在的监听器集合，并将对应的监听器添加到监听器的多路广播器中
    for(ApplicationListener<?>listener : getApplicationListeners()) {
            // getApplicationEventMulticaster 上面initApplicationEventMulticaster 获取/创建的
            // addApplicationListener   后面有源码
            getApplicationEventMulticaster().addApplicationListener(listener);  // 后面有源码
    }
    
    //  从容器中获取所有实现了ApplicationListener接口的bd的bdName
    // 放入 AddApplicationListenerBeans  集合中
    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);
      }
   }
}

addApplicationListener 添加应用程序监听器

getApplicationEventMulticaster().addApplicationListener(listener);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Override
public void addApplicationListener(ApplicationListener<?> listener) {
	// 锁定监听器助手对象
	synchronized (this.retrievalMutex) {
		// 如果已经注册，则显示删除已经注册的监听器对象，为了避免调用重复的监听器
		Object singletonTarget = AopProxyUtils.getSingletonTarget(listener);
		if (singletonTarget instanceof ApplicationListener) {
			// 删除监听器
			this.defaultRetriever.applicationListeners.remove(singletonTarget);
		}
		新增监听器对象 
		this.defaultRetriever.applicationListeners.add(listener);
		// 清空监听器助手缓存map
		this.retrieverCache.clear();
	}
}

finishBeanFactoryInitialization:

初始化剩下的单实例

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
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 为上下文初始化类型转换器 //后面有个自定义转化器
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
            // ConversionService  转换服务，比如 文本框输入一个 数字，后台就可以自动转换成 Integer 等
            beanFactory.setConversionService(beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }

    // 如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器，主要用于注解属性值的解析
    if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }

    // 今早初始化loadTimeWeaverAware bean，以便尽早注册他们的转换器
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
            getBean(weaverAwareName);
    }

    // 禁止使用临时类加载器进行类型匹配.
    beanFactory.setTempClassLoader(null);

    // 冻结所有的bean定义，说明注册的bean定义将不被修改或者任何进一步的处理
    beanFactory.freezeConfiguration();

    //实例化所有的单例对象
    beanFactory.preInstantiateSingletons();  // 后面有介绍
}

preInstantiateSingletons

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
public void preInstantiateSingletons() throws BeansException {
    if (logger.isDebugEnabled()) {
        logger.debug("Pre-instantiating singletons in " + this);
    }
    //所有bean的名字
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    // 触发所有非延迟加载单例beans的初始化，主要步骤为调用getBean
    for (String beanName : beanNames) {
        //合并父BeanDefinition
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);   // 后面有介绍
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            if (isFactoryBean(beanName)) {
                //如果是FactoryBean则加上& 进行获取
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    final FactoryBean<?> factory = (FactoryBean<?>) bean;
                    // 判断这个FactoryBean是否希望急切的初始化
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                                        ((SmartFactoryBean<?>) factory)::isEagerInit,
                                getAccessControlContext());
                    }
                    else {
                        // 如果希望急切的初始化，则通过beanName获取Bean
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
        }
        else {
            // 如果beanName 对应的bean不是FactoryBean，只是普通的bean，通过beanName获取Bean实例
            getBean(beanName);
        }
        }
    }

    // Trigger post-initialization callback for all applicable beans...
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    smartSingleton.afterSingletonsInstantiated();
                    return null;
                }, getAccessControlContext());
            }
            else {
                smartSingleton.afterSingletonsInstantiated();
            }
        }
    }
}

getMergedLocalBeanDefinition 先从缓冲中获取，如果没有找到在去put

底层调用了 getMergedBeanDefinition

1
2
3
4
5
6
7
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
    RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
    if (mbd != null) {
        return mbd;
    }
    return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}

mergedBeanDefinitions 中的数据 在 前面getBeanNameByType中就已经进行了put的操作

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
protected RootBeanDefinition getMergedBeanDefinition(
			String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
			throws BeanDefinitionStoreException {

    synchronized (this.mergedBeanDefinitions) {
        RootBeanDefinition mbd = null;

        // Check with full lock now in order to enforce the same merged instance.
        if (containingBd == null) {
            mbd = this.mergedBeanDefinitions.get(beanName);
        }

        if (mbd == null) {
            if (bd.getParentName() == null) {
                // Use copy of given root bean definition.
                if (bd instanceof RootBeanDefinition) {
                    mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
                }
                else {
                    mbd = new RootBeanDefinition(bd);
                }
            }
            else {
                // Child bean definition: needs to be merged with parent.
                BeanDefinition pbd;
                try {
                    String parentBeanName = transformedBeanName(bd.getParentName());
                    if (!beanName.equals(parentBeanName)) {
                        pbd = getMergedBeanDefinition(parentBeanName);
                    }
                    else {
                        BeanFactory parent = getParentBeanFactory();
                        if (parent instanceof ConfigurableBeanFactory) {
                            pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
                        }
                        else {
                            throw new NoSuchBeanDefinitionException(parentBeanName,
                                    "Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
                                    "': cannot be resolved without an AbstractBeanFactory parent");
                        }
                    }
                }
                catch (NoSuchBeanDefinitionException ex) {
                    throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
                            "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
                }
                // Deep copy with overridden values.
                mbd = new RootBeanDefinition(pbd);
                mbd.overrideFrom(bd);
            }

            // Set default singleton scope, if not configured before.
            if (!StringUtils.hasLength(mbd.getScope())) {
                mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
            }

            // A bean contained in a non-singleton bean cannot be a singleton itself.
            // Let's correct this on the fly here, since this might be the result of
            // parent-child merging for the outer bean, in which case the original inner bean
            // definition will not have inherited the merged outer bean's singleton status.
            if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
                mbd.setScope(containingBd.getScope());
            }

            // Cache the merged bean definition for the time being
            // (it might still get re-merged later on in order to pick up metadata changes)
            if (containingBd == null && isCacheBeanMetadata()) {
                this.mergedBeanDefinitions.put(beanName, mbd);
            }
        }

        return mbd;
    }
}
Spring
#Spring
Spring启动流程二
http://yoursite.com/post/62a020e7.html/
Author
Chase Wang
Posted on
October 14, 2021
Licensed under