[spring] 源码简析容器启动和创建实例

布满荆棘的人生 2022-01-10 11:37 272阅读 0赞

Spring的IOC容器在实现控制反转和依赖注入的过程，可以划分为两个阶段

*  容器启动阶段
 *  Bean实例化阶段

本文主要从这两个角度来解析源码的执行流程。

我们知道启动容器阶段会创建beanFactory，同时会将spring.xml中定义的beanDefinition注册到beanFactory中,or 在解析xml的过程中会找到对应标签的解析器(比如component-scan会触发Component扫描解析器)，将扫描到的beanDefinition注册到beanFactory中，同时实例化钩子函数

(主要分为两块BeanFactoryPostProcessor 和BeanPostProcessor ),其中BeanFactoryPostProcessor在启动阶段会被触发，BeanPostProcessor 是在实例化Bean的阶段会被触发。

在Bean的实例化阶段，主要是根据beanDefinition来实例化，首先是构造函数，是否通过constructor-arg指定了有参构造函数，如果没有指定的话，则使用无参构造函数，其次给属性设置，对于通过注解注入的属性通过BeanPostProcessor钩子函数的方式来注入。

下面以这段代码为例，来解析源码的启动and实例化流程:

1public class TestMain {
    2    public static void main(String[] args){
    3        ClassPathXmlApplicationContext applicationContext = 
    4                    new ClassPathXmlApplicationContext("spring.xml");
    5        User user = (User) applicationContext.getBean("user");
    6        System.out.println(user);
    7    }
    8}

spring.xml如下：

1    
     2        
     3        
     4            
     5                
     6            
     7        
     8    
     9
    10    <bean id="user" class="com.mian.User">
    11        <constructor-arg name="name" value="${mian.name}"></constructor-arg>
    12        <constructor-arg name="age" value="18"></constructor-arg>
    13        <property name="hobby" ref="hobby"/>
    14    </bean>
    15
    16    <context:property-placeholder location="classpath:config.properties"/>
    17
    18    <context:component-scan base-package="com.mian" />

先来看一下整体的结构图(注意实际的情况比这个复杂很多)，只列出了需要说明的类。  
图如下：

![884202-20190412094815178-1511377007.jpg][]

图中分为两块:

*  左边是beanFactory相关，主要是将beanDefinition注册到beanFactory中以及根据beanName来创建/获取Bean实例。基于安全的角度，获取beanDefinition相关的方法，不希望暴露给用户，所以增加了ApplicationContext,通过组合的方式只暴露了getBean方法。
 *  右边一块ApplicationContext
    
    ApplicationContext这里有两种方式FileSystem和ClassPath
    
    将共通的代码抽出成
    
    AbstractXmlApplicationContext
    
    (通过XmlBeanDefinitionReader组件将配置文件构建成BeanDefinition)，其中启动容器和创建实例的代码在AbsractApplicationContext中。

### 容器启动 ###

AbstractApplicationContext中的refresh方法(ClassPathXmlApplicationContext构造函数中调用)：

1    @Override
     2    public void refresh() throws BeansException, IllegalStateException {
     3        synchronized (this.startupShutdownMonitor) {
     4            // Prepare this context for refreshing.
     5            // ① 记录启动时间，给子类留了initPropertySources的可覆盖方法，
     6            // 同时检查标记为必须的properties
     7            prepareRefresh();
     8
     9            // Tell the subclass to refresh the internal bean factory.
    10            // ② 创建beanFactory,
    11            // 重点是通过XmlBeanDefinitionReader将配置文件解析成BeanDefinition
    12            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    13
    14            // Prepare the bean factory for use in this context.
    15            // ③ 给beanFactory设置一些属性比如classLoader,增加一些默认的钩子函数等
    16            prepareBeanFactory(beanFactory);
    17
    18            try {
    19                // Allows post-processing of the bean factory in context subclasses.
    20                // ④ 给子类留下一个可覆盖的方法，默认是什么都不做
    21                postProcessBeanFactory(beanFactory);
    22
    23                // Invoke factory processors registered as beans in the context.
    24                // ⑤ 注册BeanFactoryPostProcessor到beanFactory中，并触发方法
    25                invokeBeanFactoryPostProcessors(beanFactory);
    26
    27                // Register bean processors that intercept bean creation.
    28                // ⑥ 注册BeanPostProcessor到beanFactory中，注意在创建实例的时候触发
    29                registerBeanPostProcessors(beanFactory);
    30
    31                // Initialize message source for this context.
    32                // ⑦ 注册messageSource
    33                initMessageSource();
    34
    35                // Initialize event multicaster for this context.
    36                // ⑧ 注册广播器
    37                initApplicationEventMulticaster();
    38
    39                // Initialize other special beans in specific context subclasses.
    40                // ⑨ 留给子类可覆盖的方法，默认是什么都不做
    41                onRefresh();
    42
    43                // Check for listener beans and register them.
    44                // ⑩ 给广播类添加listeners
    45                registerListeners();
    46
    47                // Instantiate all remaining (non-lazy-init) singletons.
    48                // 11. 添加字符串的解析器的${key:value}，
    49                // 将beanDefinitions中但单例的不是懒加载的实例实例化
    50                finishBeanFactoryInitialization(beanFactory);
    51
    52                // Last step: publish corresponding event.
    53                // 12. 启动所有实现了Lifecycle接口的类，同时发布事件
    54                finishRefresh();
    55            }
    56
    57            catch (BeansException ex) {
    58            // 代码略
    59            }
    60
    61            finally {
    62            // 代码略  
    63            }
    64        }
    65    }

代码解析：  
注意上面容器启动的步骤，其中我们重点看以下几个动作：

② 通过XmlBeanDefinitionReader组件读spring.xml来创建BeanDefinition注册到beanFactory中

⑤ 注册BeanFactoryPostProcessor到beanFactory中，主要介绍PropertyPlaceholderConfigurer(将配置文件value中的$\{key:defalut\}用配置的value来代替)

⑥ 注册BeanPostPostProessor到beanFactory中，在实例化的时候才会被触发，主要介绍AutowiredAnnotationBeanPostProcessor(被@Autowired @Value注解的属性用真正的实例or值注入)

⑪ 这里注意下在容器启动阶段，会将BeanDefinition中不是abstract是单例的不是懒加载的，实例化注册到beanFactory，之后直接可以从单例容器中获取。

加载bean定义-loadBeanDefinitions

1    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
     2        // Create a new XmlBeanDefinitionReader for the given BeanFactory.
     3        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
     4        // Configure the bean definition reader with this context's
     5        // resource loading environment.
     6        beanDefinitionReader.setEnvironment(this.getEnvironment());
     7        beanDefinitionReader.setResourceLoader(this);
     8        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
     9
    10        // Allow a subclass to provide custom initialization of the reader,
    11        // then proceed with actually loading the bean definitions.
    12        initBeanDefinitionReader(beanDefinitionReader);
    13        loadBeanDefinitions(beanDefinitionReader);
    14    }

代码解析：

通过组件XmlBeanDefinitionReader将解读spring.xml配置文件，将beanDefinitions添加到beanFactory中的beanDefinitionMap中。

配置文件是在ClassPathXmlApplicationContext创建的时候已经指定了。

1// DefaultBeanDefinitionDocumentReader
     2protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
     3        if (delegate.isDefaultNamespace(root)) {
     4            NodeList nl = root.getChildNodes();
     5            for (int i = 0; i < nl.getLength(); i++) {
     6                Node node = nl.item(i);
     7                if (node instanceof Element) {
     8                    Element ele = (Element) node;
     9                    // 标签bean beans alias import走这条分支
    10                    if (delegate.isDefaultNamespace(ele)) {
    11                        parseDefaultElement(ele, delegate);
    12                    }
    13                    // component-scan annotation-config property-placeholder标签走这条分支
    14                    else {
    15                        delegate.parseCustomElement(ele);
    16                    }
    17                }
    18            }
    19        }
    20        else {
    21            delegate.parseCustomElement(root);
    22        }
    23    }

代码解析:

分为两条解析路径:

*  bean标签的如何解析成BeanDefinition，构建的BeanDefintion是怎样的?
 *  component-scan|annotation-config|property-placeholder 这种标签是如何解析成BeanDefinition的。

##### 直接在xml中定义的bean构建BeanDefintion #####

1    <bean id="user" class="com.mian.User">
    2        <constructor-arg name="name" value="${mian.name}"></constructor-arg>
    3        <constructor-arg name="age" value="18"></constructor-arg>
    4        <property name="hobby" ref="hobby"/>
    5    </bean>

构建的BeanDefinition如下:

![884202-20190412094831837-1272295490.jpg][]

*  bean的id对应于beanFactory的beanDefinitionMap中
    
    存放BeanDefinition的Map容器的key
 *  xml中的class对应了BeanDefinition中的beanClassName
 *  constructor-arg对应BeanDefintion中的ConstructorArgumentValues，这个里面存放构造器的多个参数List。
 *  property对应的是MutablePropertyValues(多个参数PropertyValue)
 *  ValueHolder/PrpertyValue中的value存放的是RuntimeBeanReference
    
    还是TypedStringValue,取决于ref/value。前者说明是一个对象，注入的时候根据ref=beanName从beanFactory中获取即可，后者说明直接是值，依赖注入时转换成正确的类型即可。

##### component-scan这类标签构建的BeanDefinition #####

1\\ BeanDefinitionParserDelegate
    2    public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
    3        String namespaceUri = getNamespaceURI(ele);
    4        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    5
    6        return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
    7    }

代码解析：  
spring的包META-INF/spring.handlers中定义了很多命名空间处理器。  
根据命名空间找到对应的处理器，处理其中定义了各个标签对应的解析器。

比如ContextNamespaceHandler中的代码如下:

1public class ContextNamespaceHandler extends NamespaceHandlerSupport {
     2
     3    @Override
     4    public void init() {
     5        registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
     6        registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
     7        registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
     8        registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
     9        registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
    10        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    11        registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
    12        registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
    13    }
    14}

ComponentScanBeanDefinitionParser解析器中，

*  负责扫描指定的报名
    
    将target中的类信息解析ScannedGenericBeanDefinition。
 *  默认注册一些BeanPostProcessor到beanFactory中 (annotation-config的标签默认也是会注册这些钩子post-processors)。

> ConfigurationClassPostProcessor  
> AutowiredAnnotationBeanPostProcessor  
> RequiredAnnotationBeanPostProcessor  
> CommonAnnotationBeanPostProcessor

ScannedGenericBeanDefinition的结构下:

![884202-20190412094842082-758458904.jpg][]

#### 注册触发钩子invokeBeanFactoryPostProcessors ####

这里将钩子BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor的实例注册到beanFactory中。  
来源主要是两方面：  
一、开发者自定义通过addBeanFactoryPostProcessor加入到beanFactory中的beanFactoryPostProcessor钩子；  
二、前面已经根据定义加载完毕beanDefintion，beanDefinition中的类型是beanFactoryPostProcessor的钩子  
根据PriorityOrdered,Ordered,nonOrder顺序来加载并且触发以下两个方法：

1public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
    2    void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
    3}
    4
    5public interface BeanFactoryPostProcessor {
    6    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
    7}

##### 介绍一种具体的钩子PropertyPlaceholderConfigurer #####

这个钩子的作用是:  
1.读取指定的配置文件，解析成key-value对  
2.遍历beanFactory中的所有beanDefinitions，检查以下各项，如果出现$\{key:default\}，则用配置文件中的value来代替。（注意-这里仅仅是更新的beanDefinition中value，而非实例化对象中的value）

1// 检查的各项 BeanDefinitionVisitor
     2    public void visitBeanDefinition(BeanDefinition beanDefinition) {
     3        visitParentName(beanDefinition);
     4        visitBeanClassName(beanDefinition);
     5        visitFactoryBeanName(beanDefinition);
     6        visitFactoryMethodName(beanDefinition);
     7        visitScope(beanDefinition);
     8        visitPropertyValues(beanDefinition.getPropertyValues());
     9        ConstructorArgumentValues cas = beanDefinition.getConstructorArgumentValues();
    10        visitIndexedArgumentValues(cas.getIndexedArgumentValues());
    11        visitGenericArgumentValues(cas.getGenericArgumentValues());
    12    }

加载此钩子的方式有两种：  
一、在spring.xml的配置文件中定义如下，解析bean标签的时候此beanDefinition自然会被加入到beanFactory中

1<bean id="propertyPlaceholderConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    2        <property name="ignoreUnresolvablePlaceholders" value="true" />
    3        <property name="locations">
    4            <list>
    5                <value>classpath:config.properties</value>
    6            </list>
    7        </property>
    8    </bean>

二、在spring.xml的配置文件中定义如下，由前面的内容可知最终会

通过PropertyPlaceholderBeanDefinitionParser将PropertySourcesPlaceholderConfigurer的beanDefinition加载进beanFactory中

1<context:property-placeholder location="classpath:config.properties"/>

#### 注册钩子registerBeanPostProcessors ####

将钩子的实例BeanPostProcessor注册到beanFactory中。  
根据PriorityOrdered,Ordered,nonOrder顺序来加载(仅加载不触发)。

##### 介绍一种具体的钩子AutowiredAnnotationBeanPostProcessor #####

1// AutowiredAnnotationBeanPostProcessor
     2    @Override
     3    public PropertyValues postProcessPropertyValues(
     4            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {
     5
     6        InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
     7        try {
     8            metadata.inject(bean, beanName, pvs);
     9        }
    10        catch (BeanCreationException ex) {
    11            throw ex;
    12        }
    13        catch (Throwable ex) {
    14            throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
    15        }
    16        return pvs;
    17    }

代码解析:

扫描正在创建的bean的beanDefinition，将其中被@Value和@Autowired注解的Field和Method过滤出来，对通过反射来实行注入。  
比如被@Autowird注解的field，通过从beanFactory中根据类型拿到对象实例，然后反射注入到field中。  
被@Value注解的field，会使用字符串分解器用真正的值来注入。(容器启动会加载放置StrigValueResolver，PropertyPlaceholderConfigurer如果被加载会将过程中生成的字符串分解器存储起来)。

加载此钩子的方式：  
在spring.xml的配置文件中定义如下，由前面的内容可知最终会通过AnnotationConfigBeanDefinitionParser或者ComponentScanBeanDefinitionParser解析器来加载这些钩子。

1<context:component-scan base-package="com.mian"  />

或者

1<context:annotation-config/>

### Bean实例化 ###

代码详见AbstractBeanFactory中的`doGetBean`  
以及AbstractAutowireCapableBeanFactory中的`createBean`

先来看doGetBean的大致的逻辑，如下:

![884202-20190412094853799-50920697.png][]

再来看createBean中的逻辑，如下:  
一、执行钩子InstantiationAwareBeanPostProcessor中的postProcessBeforeInstantiation；  
如果不为空的话，则执行钩子BeanPostProcessor中的postProcessAfterInitialization。  
（官方给的完美的解释：Give BeanPostProcessors a chance to return a proxy instead of the target bean instance）  
二、createBeanInstance根据构造函数创建实例  
beanDefintion中有constructorArgumentValues的场合，则选择合适(参数个数相同+参数类型匹配)的构造函数来创建一个实例。  
无constructorArgumentValues，则通过无参构造函数创建一个实例。(比如扫描类得到的beanDefintion)  
三、执行钩子函数MergedBeanDefinitionPostProcessor中的postProcessMergedBeanDefinition。  
四、执行钩子函数InstantiationAwareBeanPostProcessor中的postProcessAfterInstantiation。  
五、自动装配（bean的定义中定义了autowire="byName or byType or constructor"）则执行自动装配。(默认情况下 default-autowire属性被设置为none, 标记所有bean都不适用自动装配，除非bean上配置了autowire属性。事实上，spring是不推荐自动装配的，最大的缺点在于不确定性，除非你对整个spring应用中的所有bean的情况都了如指掌，不然随着bean的增多和关系复杂度的上升，情况会变得很糟糕。)  
六、执行钩子函数InstantiationAwareBeanPostProcessor中的postProcessPropertyValues。  
比如我们上面介绍到的AutowiredAnnotationBeanPostProcessor(来注入@Value和@Autowired注解的field和method)  
七、解析其中的BeanDefinition中的PropertyValue，注入创建的实例中。  
比如spring.xml定义bean时用到的property。  
八、给实现了Aware接口一些对象设置beanName类似这种操作  
九、执行钩子函数BeanPostProcessor的postProcessBeforeInitialization  
执行开发者自定义的init方法，之后执行钩子函数BeanPostProcessor的postProcessAfterInitialization。  
十、registerDisposableBeanIfNecessary

以上。

更多源码分析，关注公众号???

![884202-20190411211547755-808016036.jpg][]

转载于:https://www.cnblogs.com/mianteno/p/10692650.html

[884202-20190412094815178-1511377007.jpg]: /images/20220110/c86f884dde2543bca163e9563fa55a6f.png
[884202-20190412094831837-1272295490.jpg]: /images/20220110/ede63e588a894130bef7a5c8430a122c.png
[884202-20190412094842082-758458904.jpg]: /images/20220110/0523c78cfeae441c867a477424696874.png
[884202-20190412094853799-50920697.png]: /images/20220110/123218d0764943d28a725eb585b575a7.png
[884202-20190411211547755-808016036.jpg]: /images/20220110/e6d37acf215e4247969408257a44c8c5.png