虽然是研究Spring的生命周期,我们仍然可以使用springboot项目来研究
POM依赖
4.0.0 org.springframework.boot spring-boot-starter-parent 2.1.6.RELEASE com.itmark mongoDemo 1.0-SNAPSHOT 11 11 org.springframework.boot spring-boot-starter-test test org.projectlombok lombok true
一个实体类
package com.itmark.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;
import java.io.Serializable;
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class SGRole implements Serializable {
String id;
String name;
Integer age;
}
一个bean的配置文件,需要放在resources目录下
引入这个配置
@Configuration
@ImportResource(locations = "classpath:beans.xml")
public class RoleConfiguration {
}
}
在IOC容器中获取这个对象
@Slf4j
@SpringBootTest(classes = AppMongo.class)
@RunWith(SpringRunner.class)
public class SpringBeanTest {
@Test
public void getMongoData() {
// 1.当作是一个IOC容器即可
AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(RoleConfiguration.class);
// 2.getBean
SGRole sgRole2 = (SGRole) annotationConfigApplicationContext.getBean("sgRole2");
System.out.println(sgRole2);
}
}
2 DEBUG
目标是找到哪一个代码可以找到我们想要的对象实例。
发现debug到这行代码时候返回了对象
此时找到了容器IOC
下图分别为一级缓存三级缓存和二级缓存
既然可以从缓存中拿到对象,而且缓存就是Map集合所以如果能取到,那么spring一定在某个时刻put进去了我们的实例对象。如下。
通过断点表达式找到了什么时候put进去了。
但是是谁调用了put方法所在的方法呢?发现是IOC容器启动的过程中将所有的对象初始化好放到单例缓存池中。
注意:如果使用的是springboot的单元测试,你很难找到到底是谁最终调用了put方法,但是当你把代码放到一个main方法的时候,你很容易可以看到是IOC容器调用了PUT。
public Object getSingleton(String beanName, ObjectFactory> singletonFactory) {
synchronized (this.singletonObjects) {
// 1 尝试从IOC一级缓存中拿对象
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
// 1.1 用于标记一个bean将要被创建防止其他线程重复创建
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
// 2 初始化一个bean,而这个方法的调用者是一个lambda表达式
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
return singletonObject;
}
}
当方法调用singletonObject = singletonFactory.getObject();时候lambda表达式会被调用。
现在研究一下 createBean 这个方法,最终调用了doCreateBean
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (instanceWrapper == null) {
// 0 创建这个bean的空对象
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
// 1 spring是如何解决循环依赖的
// 1.2 mbd.isSingleton()判断是否单例
// 1.3 this.allowCircularReferences是否允许循环依赖
// 1.4 isSingletonCurrentlyInCreation(beanName) 判断正在创建集合中是否包含现在的名称
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
// 2 包早起对象放到三级缓存中
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper);
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
3 核心调用堆栈总结
-
重点方法一:org.springframework.beans.factory.support.AbstractBeanFactory#getBean
-
重点方法二: org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
- 别名解析org.springframework.beans.factory.support.AbstractBeanFactory#transformedBeanName
- 获取当前bean定义org.springframework.beans.factory.support.AbstractBeanFactory#getMergedLocalBeanDefinition
- 判断是否为抽象类org.springframework.beans.factory.support.AbstractBeanFactory#checkMergedBeanDefinition
- 检测dependsOn属性org.springframework.beans.factory.support.AbstractBeanDefinition#getDependsOn
-
重点方法三:返回对象org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton
- org.springframework.beans.factory.support.AbstractBeanFactory#createBean
- org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
- org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance 通过反射创建空壳对象
- org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingletonFactory 暴露早起对象(上一步创建的空壳对象,还没有进行属性赋值)暴露就是加入到三级缓存中(this.singletonFactories.put(beanName, singletonFactory);)
- org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean给当前创建的空壳对象A注入属性B(通过注入早期对象来解决循环依赖的问题)(底层调用了getBean的方法来再次走一遍上面的流程把B的实例创建出来,那么三级缓存中也有B了,再给B的循环依赖属性进行赋值的时候,此时三级缓存中已经有A的早期对象实例了)处理完毕B的循环依赖A后,进行B的实例后续处理,把完整的实例返回给当前方法处理A的循环依赖B的问题
- org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#getEarlyBeanReference三级缓存用于保证实例获取的是代理对象,可以进行一些增强,三级缓存在getBean的时候会触发当前方法
-
所有对象在创建的过程中都会把自己的对象暴露到三级缓存中,从三级缓存到二级缓存中会记过一次代理,创建完毕后就会删除二级缓存放到一级缓存中。所已使用构造函数方法来注入循环依赖无法实现,因为空壳对象三级缓存中没有。



