spring · 2022-02-15 0

spring的启动流程与三级缓存

一、配置

1.pom

<properties>
    <spring.version>5.1.9.RELEASE</spring.version>
</properties>

<dependencies>

    <!-- spring core -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>${spring.version}</version>
    </dependency>

</dependencies>

2.配置文件

<?xml version="1.0" encoding="utf-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="studentService" class="com.example.service.StudentServiceImpl"/>

    <bean id="myBeanDefinitionRegistryPostProcessor" class="com.example.bean.MyBeanDefinitionRegistryPostProcessor"/>

    <bean id="myBeanFactoryPostProcessor" class="com.example.bean.MyBeanFactoryPostProcessor"/>

    <bean id="myBeanPostProcessor" class="com.example.bean.MyBeanPostProcessor"/>

</beans>

二、启动流程

主要启动流程在 AbstractApplicationContextrefresh() 方法

  1. prepareRefresh();
  2. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  3. prepareBeanFactory(beanFactory);
  4. postProcessBeanFactory(beanFactory);
  5. invokeBeanFactoryPostProcessors(beanFactory);
  6. registerBeanPostProcessors(beanFactory);
  7. initMessageSource();
  8. initApplicationEventMulticaster();
  9. onRefresh();
  10. registerListeners();
  11. finishBeanFactoryInitialization(beanFactory);
  12. finishRefresh();

1. prepareRefresh()

2. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()

构造 BeanFactory 对象

读取xml,把 bean 放到 Map<String, BeanDefinition> beanDefinitionMap

BeanDefinition 对象存放的有 <bean>标签定义的 id、class的值

1) 根据 beanName,从 this.beanDefinitionMap 查询 BeanDefinition
2) 若 this.beanDefinitionMap 不存在此 beanName,执行 this.beanDefinitionMap.put(beanName, beanDefinition),this.beanDefinitionNames.add(beanName)

// BeanDefinitionReaderUtils.java
public static void registerBeanDefinition(
        BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
        throws BeanDefinitionStoreException {

    // Register bean definition under primary name.
    String beanName = definitionHolder.getBeanName();
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

    // Register aliases for bean name, if any.
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        for (String alias : aliases) {
            registry.registerAlias(beanName, alias);
        }
    }
}
// DefaultListableBeanFactory.java
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException {
    ...

    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    if (existingDefinition != null) {
        ...
        this.beanDefinitionMap.put(beanName, beanDefinition);
    }
    else {
        if (hasBeanCreationStarted()) {
            // Cannot modify startup-time collection elements anymore (for stable iteration)
            synchronized (this.beanDefinitionMap) {
                this.beanDefinitionMap.put(beanName, beanDefinition);
                List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                updatedDefinitions.addAll(this.beanDefinitionNames);
                updatedDefinitions.add(beanName);
                this.beanDefinitionNames = updatedDefinitions;
                removeManualSingletonName(beanName);
            }
        }
        else {
            // Still in startup registration phase
            this.beanDefinitionMap.put(beanName, beanDefinition);
            this.beanDefinitionNames.add(beanName);
            removeManualSingletonName(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }

    if (existingDefinition != null || containsSingleton(beanName)) {
        resetBeanDefinition(beanName);
    }
}

3. prepareBeanFactory(beanFactory)

beanFactory 加入固定的 bean

普通 bean:environmentsystemPropertiessystemEnvironment

BeanPostProcessorApplicationContextAwareProcessor(处理实现 EnvironmentAwareEmbeddedValueResolverAwareResourceLoaderAwareApplicationEventPublisherAwareMessageSourceAwareApplicationContextAware 的 bean)

BeanPostProcessorApplicationListenerDetector (处理 实现 ApplicationListener 的 bean,在 bean 实例化时,把 bean 加入 applicationEventMulticaster 中)

4. postProcessBeanFactory(beanFactory)

5. invokeBeanFactoryPostProcessors(beanFactory)

beanDefinitionNames 中获得 BeanDefinitionRegistryPostProcessorBeanFactoryPostProcessor 类型的,并实例化

调用 BeanDefinitionRegistryPostProcessorpostProcessBeanDefinitionRegistry() 方法 和 postProcessBeanFactory() 方法,
BeanFactoryPostProcessorpostProcessBeanFactory() 方法

6. registerBeanPostProcessors(beanFactory)

实例化 BeanPostProcessor,并把 BeanPostProcessor 加入 DefaultListableBeanFactoryList<BeanPostProcessor> beanPostProcessors

7. initMessageSource()

8. initApplicationEventMulticaster()

创建 SimpleApplicationEventMulticaster 对象,放到 beanFactorysingletonObjects

9. onRefresh()

10. registerListeners()

beanDefinitionMap 得到 ApplicationListener,加到 SimpleApplicationEventMulticaster

此时 ApplicationListener 可能没有实例化,只是把名称加入SimpleApplicationEventMulticaster,在步骤11实例化时,ApplicationListenerDetector,才真正把实例加入SimpleApplicationEventMulticaster

11. finishBeanFactoryInitialization(beanFactory)

实例化还没实例化的 bean,循环 beanDefinitionNames, 实例化

1) 遍历 this.beanDefinitionNames, 调用 getBean(name) 方法
3) 调用 getSingleton(beanName, allowEarlyReference) 方法,从 this.singletonObjects 获得 bean,如果没有,则返回 null
4) markBeanAsCreated(beanName) 方法,执行 this.mergedBeanDefinitions.remove(beanName),this.alreadyCreated.add(beanName)
5) getMergedLocalBeanDefinition(beanName) 方法,执行 this.mergedBeanDefinitions.put(beanName, mbd)
6) getSingleton(beanName, singletonFactory) 方法,从 this.singletonObjects 获得 bean,如果没有,则执行 createBean(beanName, mbd, args)
7) createBeanInstance(beanName, mbd, args),实例化 bean
8) addSingletonFactory(beanName, singletonFactory) 方法,this.singletonFactories.put(beanName, singletonFactory),this.registeredSingletons.add(beanName),this.earlySingletonObjects.remove(beanName)
9) addSingleton(beanName, singletonObject) 方法,执行 this.singletonObjects.put(beanName, singletonObject), this.registeredSingletons.add(beanName), this.singletonFactories.remove(beanName),

// AbstractApplicationContext.java
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    ...
    beanFactory.setTempClassLoader(null);
    beanFactory.freezeConfiguration();
    beanFactory.preInstantiateSingletons();
}
// DefaultListableBeanFactory.java
@Override
public void preInstantiateSingletons() throws BeansException {
    ...
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            if (isFactoryBean(beanName)) {
                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(beanName);
                    }
                }
            }
            else {
                getBean(beanName);
            }
        }
    }

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

@Override
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
        @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

    final String beanName = transformedBeanName(name);
    Object bean;

    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        ...
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    } else {
        ...
        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        try {
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            ...
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        return createBean(beanName, mbd, args);
                    }
                    ...
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            } else if (mbd.isPrototype()) {
                ...
            } else {
                ...
            }
        }
        ...
    }
    ...
    return (T) bean;
}

@Override
@Nullable
public Object getSingleton(String beanName) {
    return getSingleton(beanName, true);
}

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        ...
    }
    return singletonObject;
}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    ...
    synchronized (this.singletonObjects) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            ...
            try {
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            ...
            finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException {
    ...
    try {
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        ...
        return beanInstance;
    }
}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
        throws BeanCreationException {
    BeanWrapper instanceWrapper = null;
    ...
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    ...
    if (earlySingletonExposure) {
        ...
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
    Object exposedObject = bean;
    try {
        populateBean(beanName, mbd, instanceWrapper);
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    ...
}

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        this.singletonObjects.put(beanName, singletonObject);
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}

12. finishRefresh()

执行 SimpleApplicationEventMulticastermulticastEvent(applicationEvent, eventType),调用每个 listeneronApplicationEvent(event) 方法

总结:

  1. 获得 beanFactory, 把xml定义的 bean,转化成 BeanDefinition,放入 beanDefinitionMap 中

  2. 执行 invokeBeanFactoryPostProcessors(), 实例化并调用 BeanFactoryPostProcessors 的 postProcessBeanFactory() 方法

  3. 执行 registerBeanPostProcessors(),注册 BeanPostProcessors,实例化 BeanPostProcessors

  4. 执行 finishBeanFactoryInitialization(),实例化还没实例化的 bean,

三、Bean 的生命周期

Bean 的生命周期4个阶段:

  1. 实例化
  2. 属性赋值
  3. 初始化
  4. 销毁

1. 实例化 (createBeanInstance方法)

在实例化和注入属性之间,把 beanName 放入 三级缓存 Map<String, ObjectFactory<?>> singletonFactories

2. 注入属性 (populateBean方法)

对于 ref,注入 bean,尝试获得 ref 指定的 bean,先从 一二三级缓存 中取的,没有的话进行创建,如果在三级缓存,放到二级缓存

3.初始化 (initializeBean方法)

BeanPostProcessor 不处理 synthetic = true(合成的)对象

1.aware 方法 (invokeAwareMethods方法)
BeanNameAwaresetBeanName() 方法
BeanClassLoaderAware
BeanFactoryAware

2.所有BeanPostProcessorspostProcessBeforeInitialization() 方法

3.初始化方法 (invokeInitMethods方法)
InitializingBeanafterPropertiesSet()
自定义的 init()

4.所有 BeanPostProcessorpostProcessAfterInitialization()
对于 aop,会执行 AbstractAutoProxyCreatorpostProcessAfterInitialization(),返回代理对象

4,放入一级缓存

把 bean 放入一级缓存 Map<String, Object> singletonObjects

从三级缓存 Map<String, Object> singletonObjects 移除

从二级缓存 Map<String, Object> earlySingletonObjects 移除

如果定义的 bean 是个接口,实例化的时候会判断是否是接口,如果是,则抛出异常

四、spring 三级缓存

三级缓存(三个Map)

从 beanFactory 中取 bean,是三级缓存,依次尝试从 singletonObjects, earlySingletonObjects, singletonFactories 取值

如果 bean 在 singletonFactories,则把 bean 放到 earlySingletonObjects, 从 singletonFactories 移除

1.singletonObjects(一级,日常实际获取 Bean 的地方)
Map<String, Object> singletonObjects
2.earlySingletonObjects(二级,已实例化,但还没进行属性注入,由三级缓存放进来)
Map<String, Object> earlySingletonObjects
3.singletonFactories(三级,Value是一个对象工厂)
Map<String, ObjectFactory<?>> singletonFactories,ObjectFactory 包含着 Bean 对象

如果没有循环引用关系,也不会被保存到二级缓存中的。

五、循环依赖

循环依赖问题,如果有 A 依赖 B,B 依赖 A。

假如先创建 A,并 A 放在第三级缓存,在 A 属性注入的时候需要 B;这时会去创建 B,并 B 放在第三级缓存,在 B 属性注入的时候需要 A;则从一二三级缓存中取,发现 A 在 第三级缓存,则把 A 放在第二级缓存。完成 B 的创建,再完成 A 的创建

原型(Prototype)的场景是不支持循环依赖的,会抛出异常