一、配置
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>
二、启动流程
主要启动流程在 AbstractApplicationContext
的 refresh()
方法
- prepareRefresh();
- ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
- prepareBeanFactory(beanFactory);
- postProcessBeanFactory(beanFactory);
- invokeBeanFactoryPostProcessors(beanFactory);
- registerBeanPostProcessors(beanFactory);
- initMessageSource();
- initApplicationEventMulticaster();
- onRefresh();
- registerListeners();
- finishBeanFactoryInitialization(beanFactory);
- 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:environment
、systemProperties
、systemEnvironment
BeanPostProcessor
:ApplicationContextAwareProcessor
(处理实现 EnvironmentAware
、EmbeddedValueResolverAware
、ResourceLoaderAware
、ApplicationEventPublisherAware
、MessageSourceAware
、ApplicationContextAware
的 bean)
BeanPostProcessor
:ApplicationListenerDetector
(处理 实现 ApplicationListener
的 bean,在 bean 实例化时,把 bean 加入 applicationEventMulticaster
中)
4. postProcessBeanFactory(beanFactory)
5. invokeBeanFactoryPostProcessors(beanFactory)
从 beanDefinitionNames
中获得 BeanDefinitionRegistryPostProcessor
和 BeanFactoryPostProcessor
类型的,并实例化
调用 BeanDefinitionRegistryPostProcessor
的 postProcessBeanDefinitionRegistry()
方法 和 postProcessBeanFactory()
方法,
BeanFactoryPostProcessor
的 postProcessBeanFactory()
方法
6. registerBeanPostProcessors(beanFactory)
实例化 BeanPostProcessor
,并把 BeanPostProcessor
加入 DefaultListableBeanFactory
的List<BeanPostProcessor> beanPostProcessors
中
7. initMessageSource()
8. initApplicationEventMulticaster()
创建 SimpleApplicationEventMulticaster
对象,放到 beanFactory
的 singletonObjects
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()
执行 SimpleApplicationEventMulticaster
的 multicastEvent(applicationEvent, eventType)
,调用每个 listener
的 onApplicationEvent(event)
方法
总结:
-
获得 beanFactory, 把xml定义的 bean,转化成 BeanDefinition,放入 beanDefinitionMap 中
-
执行 invokeBeanFactoryPostProcessors(), 实例化并调用 BeanFactoryPostProcessors 的 postProcessBeanFactory() 方法
-
执行 registerBeanPostProcessors(),注册 BeanPostProcessors,实例化 BeanPostProcessors
-
执行 finishBeanFactoryInitialization(),实例化还没实例化的 bean,
三、Bean 的生命周期
Bean 的生命周期4个阶段:
- 实例化
- 属性赋值
- 初始化
- 销毁
1. 实例化 (createBeanInstance方法)
在实例化和注入属性之间,把 beanName 放入 三级缓存 Map<String, ObjectFactory<?>> singletonFactories
2. 注入属性 (populateBean方法)
对于 ref,注入 bean,尝试获得 ref 指定的 bean,先从 一二三级缓存 中取的,没有的话进行创建,如果在三级缓存,放到二级缓存
3.初始化 (initializeBean方法)
BeanPostProcessor
不处理 synthetic = true
(合成的)对象
1.aware
方法 (invokeAwareMethods方法)
BeanNameAware
的 setBeanName()
方法
BeanClassLoaderAware
的
BeanFactoryAware
的
2.所有BeanPostProcessors
的 postProcessBeforeInitialization()
方法
3.初始化方法 (invokeInitMethods方法)
InitializingBean
的 afterPropertiesSet()
自定义的 init()
4.所有 BeanPostProcessor
的 postProcessAfterInitialization()
对于 aop,会执行 AbstractAutoProxyCreator
的 postProcessAfterInitialization()
,返回代理对象
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)的场景是不支持循环依赖的,会抛出异常