spring的循环依赖详解
spring实例化入口
在启动程序的时候，启动代码如下：
public class SpringMain {
public static void main(String[] args) {
//初始化spring容器 在初始化的时候完成了依赖注入
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringTest.class);
}
}
在执行该代码的时候便完成了spring容器的初始化的过程。
而依赖注入的功能便是在spring容器初始化（即初始化bean–该过程是bean的生命周期）的时候完成。
bean和对象的区别
springBean有完整的生命周期。
java对象只是我们new出来的。
springBean可以是java对象，java对象不可以是bean。
普通类 vs bean 的实例化过程
普通类
User.java通过javac编译为了class文件
程序执行启动类的时候，会调用c++代码启动jvm虚拟机
jvm虚拟机会将编译好的class文件加载到jvm的内存当中，比如说方法区。
当遇到new关键字的时候，会根据方法区的java模版，去堆上分配一块内存用来存储该new的对象
bean
首先X Y等是添加了Component注解的类
这些类会被编译为class文件
当程序启动的时候，会调用c++启动jvm虚拟机
jvm虚拟机会将class文件加载到虚拟机当中
当虚拟机执行到启动类的部分的时候，即如下部分
spring会先去解析SpringTest.class类中的@ComponentScan注解中包中的所有的bean
获取到所有的bean之后，要分别获取各自bean的类上的各种注解
如@Lazy @DependOn等等，然后spring会new一个对象（BeanDefinition的子类）来存储这些信息
随后，该对象会被放在一个map中
然后调用preinstantiateSingleton方法遍历该map，获取到beanDefinition的对象，通过该对象判断该bean是否是单例，是否有懒加载等等等等，遍历验证完该对象之后，会将该对象放在单例池当中。
小结
单例对象生成过程：
通过javac编译为class文件
spring对class文件进行解析（读取注解）并生成beanDefinition对象存储bean的基本信息
将该beanDefinition存储在map中
调用preinstantiateSingleton获取map，遍历map，对map中的该beanDefinition内存储的信息进行验证，验证是否是单例，是否有懒加载等等注解
将验证后没问题的bean存储到spring的单例池中
spring对外扩展
spring提供了程序员扩展的空间
在对象存到map中后，调用preinstantiateSingleton方法之前，程序员可以进行一定的扩展。
spring在将数据存放到map中之后，调用preinstantiateSingleton方法之前，会看一下程序员是否进行了扩展，如果进行了扩展，spring就会调用扩展的一些方法将该map传过去。
程序员获取到了map，即获取到了BeanDefinition，在BeanDefinition中有一个是beanClass，存储的就是我们使用@Component等注解的X类。程序员可以修改该beanClass的值，比如将X改为了Y。修改的这一步就是在进行扩展操作。修改完成之后再将值重新放回map中。
此时spring再将map放到spring的单例池中。此时放进去的就是Y而不是X了。
扩展demo
public class IndexService {
public IndexService(){
System.out.println("indexService construct");
}
}
@Component
public class UserService {
public UserService(){
System.out.println("UserService construct");
}
}
@ComponentScan("com.guo.admin.web.spring")
public class SpringTest {
}
//扩展类
@Component
public class BeanDefinationSelf implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
GenericBeanDefinition genericBeanDefinition = (GenericBeanDefinition) beanFactory.getBeanDefinition("userService");
genericBeanDefinition.setBeanClass(IndexService.class);
}
}
//在该类中获取到添加了@Component注解的UserService类，然后将其的BeanClass值设为了IndexService类。
启动类
public class SpringMain {
public static void main(String[] args) {
//初始化spring容器 在初始化的时候完成了依赖注入
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringTest.class);
System.out.println(context.getBean(IndexService.class));
}
}
执行结果如下：可以看到IndexService对象生成了，成为了Spring的bean对象。
如果没有扩展类（将扩展类上的@Component注解注释掉）的话，启动启动类的结果是如下图：
该demo实现了对speing的二次扩展。
spring源码
入口
public AnnotationConfigApplicationContext(Class... componentClasses) {
this();
this.register(componentClasses);
this.refresh();//真正实现spring 的bean初始化的方法。
}
this.refresh()
进入this.refresh();方法中
public void refresh() throws BeansException, IllegalStateException {
synchronized(this.startupShutdownMonitor) {
this.prepareRefresh();
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
//该方法完成了扫描操作--该方法执行完成之后--,an Definition放进了map中
this.prepareBeanFactory(beanFactory);
try {
this.postProcessBeanFactory(beanFactory);
this.invokeBeanFactoryPostProcessors(beanFactory);
this.registerBeanPostProcessors(beanFactory);
this.initMessageSource();
this.initApplicationEventMulticaster();
this.onRefresh();
this.registerListeners();
//该方法完成bean对象的初始化操作。如果bean类对象的构造方法里面有日志输出，则在此方法执行之后，日志会输出出来。
//即该方法中完成了bean对象的生命周期过程
this.finishBeanFactoryInitialization(beanFactory);
this.finishRefresh();
} catch (BeansException var9) {
if (this.logger.isWarnEnabled()) {
this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
}
this.destroyBeans();
this.cancelRefresh(var9);
throw var9;
} finally {
this.resetCommonCaches();
}
}
}
finishBeanFactoryInitialization()
bean对象初始化的方法源码：finishBeanFactoryInitialization();
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
}
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver((strVal) -> {
return this.getEnvironment().resolvePlaceholders(strVal);
});
}
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
String[] var3 = weaverAwareNames;
int var4 = weaverAwareNames.length;
for(int var5 = 0; var5 < var4; ++var5) {
String weaverAwareName = var3[var5];
this.getBean(weaverAwareName);
}
beanFactory.setTempClassLoader((ClassLoader)null);
beanFactory.freezeConfiguration();
//该方法将会实例化所有非懒加载的单例对象
beanFactory.preInstantiateSingletons();
}
preInstantiateSingletons()
实例化非懒加载的单例对象源码：beanFactory.preInstantiateSingletons();
该方法获取所有的bean的名字，通过循环一个一个getBean
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Pre-instantiating singletons in " + this);
}
//该list是所有bean的名字 然后对该list做了一个循环 根据名字去map中获取到对应的beanDefinition对象
List<String> beanNames = new ArrayList(this.beanDefinitionNames);
Iterator var2 = beanNames.iterator();
while(true) {
String beanName;
Object bean;
do {
while(true) {
RootBeanDefinition bd;
do {
do {
do {
if (!var2.hasNext()) {
var2 = beanNames.iterator();
while(var2.hasNext()) {
beanName = (String)var2.next();
Object singletonInstance = this.getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(() -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, this.getAccessControlContext());
} else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
return;
}
beanName = (String)var2.next();
//在这里合并
bd = this.getMergedLocalBeanDefinition(beanName);
} while(bd.isAbstract());//判断该对象是不是
} while(!bd.isSingleton());//判断该对象是不是单例对象
} while(bd.isLazyInit());//判断该对象是不是非懒加载的对象
if (this.isFactoryBean(beanName)) {
bean = this.getBean("&" + beanName);
break;
}
//如果验证结束没有问题（不是懒加载，是单例），则执行getBean方法去完成实例化。
this.getBean(beanName);
}
} while(!(bean instanceof FactoryBean));
FactoryBean<?> factory = (FactoryBean)bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
SmartFactoryBean var10000 = (SmartFactoryBean)factory;
((SmartFactoryBean)factory).getClass();
isEagerInit = (Boolean)AccessController.doPrivileged(var10000::isEagerInit, this.getAccessControlContext());
} else {
isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
}
if (isEagerInit) {
this.getBean(beanName);
}
}
}
getBean(beanName)
getBean()
public Object getBean(String name) throws BeansException {
return this.doGetBean(name, (Class)null, (Object[])null, false);
}
doGetBean()
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
//该行代码非常重要 验证bean的名字是否非法
String beanName = this.transformedBeanName(name);
//bean的名字没有非法情况后，下面该行代码会根据名字去单例池中拿bean，看单例池中是否已经存在了被实例化的该bean对象
Object sharedInstance = this.getSingleton(beanName);
Object bean;
//如果发现该bean对象已经在单例池中存在了，则走这个if方法 ---但是我们需要知道，该doGetBean方法就是在刚开始初始化bean的时候去调用的，所以不可能进入这个if方法中。
if (sharedInstance != null && args == null) {
if (this.logger.isTraceEnabled()) {
if (this.isSingletonCurrentlyInCreation(beanName)) {
this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
} else {
this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
}
//因此，出了if，程序进入了else方法
else {
//该if，是判断该bean对象是否正在创建过程中，如果是，则抛出异常
if (this.isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
BeanFactory parentBeanFactory = this.getParentBeanFactory();
if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
String nameToLookup = this.originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
}
if (args != null) {
return parentBeanFactory.getBean(nameToLookup, args);
}
if (requiredType != null) {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
return parentBeanFactory.getBean(nameToLookup);
}
if (!typeCheckOnly) {
this.markBeanAsCreated(beanName);
}
try {
//在该行代码中解析合并后的bd对象
RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
this.checkMergedBeanDefinition(mbd, beanName, args);
//判断bean类对象上是否添加了@DependOn注解
String[] dependsOn = mbd.getDependsOn();
String[] var11;
if (dependsOn != null) {
var11 = dependsOn;
int var12 = dependsOn.length;
for(int var13 = 0; var13 < var12; ++var13) {
String dep = var11[var13];
if (this.isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
this.registerDependentBean(dep, beanName);
try {
this.getBean(dep);
} catch (NoSuchBeanDefinitionException var24) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
}
}
}
//判断是否是单例对象---如果是单例对象，则进入该if方法 然后执行createBean方法，此时bean才开始实例化了。
if (mbd.isSingleton()) {
sharedInstance = this.getSingleton(beanName, () -> {
try {
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
});
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
var11 = null;
Object prototypeInstance;
try {
this.beforePrototypeCreation(beanName);
prototypeInstance = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
} else {
String scopeName = mbd.getScope();
Scope scope = (Scope)this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
this.beforePrototypeCreation(beanName);
Object var4;
try {
var4 = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
return var4;
});
bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
} catch (IllegalStateException var23) {
throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var23);
}
}
} catch (BeansException var26) {
this.cleanupAfterBeanCreationFailure(beanName);
throw var26;
}
}
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
} else {
return convertedBean;
}
} catch (TypeMismatchException var25) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
} else {
return bean;
}
}
createBean()
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
//校验日志
if (this.logger.isTraceEnabled()) {
this.logger.trace("Creating instance of bean '" + beanName + "'");
}
//将mbd（RootBeanDefinition）赋值给mbdToUse----
RootBeanDefinition mbdToUse = mbd;
//获取mbd的class这个属性的值（值就是bean对象的类的全限定名，这个值就是这个类，获取到了类）
Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try {
//这个方法也是比较重要的一个方法
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException var9) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
}
Object beanInstance;
try {
//第一次调用后置处理器，这里面还是进行验证
beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
if (beanInstance != null) {
return beanInstance;
}
} catch (Throwable var10) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
}
try {
//--------------------------
//该行中的doCreateBean创建bean开始了~~~~ 在该行代码中，完成了原身对象和代理对象的创建（如果只是创建bean则创建bean，如果该bean被aop了，则创建了bean和它的代理bean）
beanInstance = this.doCreateBean(beanName, mbdToUse, args);
if (this.logger.isTraceEnabled()) {
this.logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
} catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
throw var7;
} catch (Throwable var8) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
}
}
doCreateBean()
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
BeanWrapper instanceWrapper = null;
//判断是否是单例 如果是单例 则将cache remove 掉
if (mbd.isSingleton()) {
instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//实例化对象，里面第二次调用后置处理器 这里实例化的是对象，而不是bean，我们需要注意。当该方法执行完成后，构造方法中如果有日志输出，则会输出，说明对象被实例化出来了，但是这并不表示bean创建出来。因为如果我们debug一下，可以看到该bean里面的一些属性还是没有值的，还是null，只是构造方法执行完成了而已。此时实例化的是对象。
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
//debug到这一行的时候，我们可以看到这个bean中的属性还是没有值的，上一行的
//instanceWrapper = thiscreateBeanInstance(beanName, mbd, args)这个方法只是将对象实例化了，但是bean还没有被实例化。
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
synchronized(mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//通过后置处理器来合并beanDefinitation 举例：AService中有两个使用@Autowire注解的属性，该方法就是将所有需要注入的属性都合并起来放到一个list集合中
this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable var17) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
}
mbd.postProcessed = true;
}
}
//判断是否允许循环依赖
//mbd.isSingleton() 默认是单例，所以结果是true
//this.allowCircularReferences 没讲
//this.isSingletonCurrentlyInCreation(beanName) 百分之百是true 理由为：老师还没讲。
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
//如果允许循环依赖的话，则执行if中的方法
if (earlySingletonExposure) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
//第四次调用后置处理器，spring需要将该bean对象提前暴漏出来，并且做aop
this.addSingletonFactory(beanName, () -> {
return this.getEarlyBeanReference(beanName, mbd, bean);
});
}
//将bean对象赋值给 Object exposedObject
Object exposedObject = bean;
try {
//该方法进行属性的填充 就是我们常说的自动注入，里面会完成第五次和第六次的后置处理器的调用
//在该方法中，先判断是否需要进行属性的注入，如果需要，才进行属性的注入工作
this.populateBean(beanName, mbd, instanceWrapper);
//初始化spring，里面会进行第七次 第八次的后置处理器的调用
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
} catch (Throwable var18) {
if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
throw (BeanCreationException)var18;
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
}
if (earlySingletonExposure) {
Object earlySingletonReference = this.getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
String[] dependentBeans = this.getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
String[] var12 = dependentBeans;
int var13 = dependentBeans.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dependentBean = var12[var14];
if (!this.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.");
}
}
}
}
try {
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
} catch (BeanDefinitionValidationException var16) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
}
}
createBeanInstance()
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
} else {
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return this.obtainFromSupplier(instanceSupplier, beanName);
} else if (mbd.getFactoryMethodName() != null) {
return this.instantiateUsingFactoryMethod(beanName, mbd, args);
} else {
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized(mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
return autowireNecessary ? this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null) : this.instantiateBean(beanName, mbd);
} else {
//该行用来获取到构造方法后对构造方法进行推断
Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) {
ctors = mbd.getPreferredConstructors();
//如果构造方法不为null的话，就反射autowireConstructor，如果为null 的话，就instantiateBean执行这个方法，获取默认的无参构造方法实例化对象
return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd);
} else {
return this.autowireConstructor(beanName, mbd, ctors, args);
}
}
}
}
}
instantiateBean
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
try {
Object beanInstance;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged(() -> {
//通过执行instantiate得到默认的构造方法
return thisx.getInstantiationStrategy().instantiate(mbd, beanName, this);
}, this.getAccessControlContext());
} else {
beanInstance = this.getInstantiationStrategy().instantiate(mbd, beanName, this);
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
this.initBeanWrapper(bw);
return bw;
} catch (Throwable var6) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", var6);
}
}
在该方法中通过执行instantiate方法得到默认的构造方法
instantiateClass方法中
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
Assert.notNull(ctor, "Constructor must not be null");
try {
ReflectionUtils.makeAccessible(ctor);
//ctor.newInstance(args)该方法完成对象的实例化
return KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ? BeanUtils.KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args);
} catch (InstantiationException var3) {
throw new BeanInstantiationException(ctor, "Is it an abstract class?", var3);
} catch (IllegalAccessException var4) {
throw new BeanInstantiationException(ctor, "Is the constructor accessible?", var4);
} catch (IllegalArgumentException var5) {
throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", var5);
} catch (InvocationTargetException var6) {
throw new BeanInstantiationException(ctor, "Constructor threw exception", var6.getTargetException());
}
}
插入讲一下spring对AOP的处理
initializeBean()
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(() -> {
this.invokeAwareMethods(beanName, bean);
return null;
}, this.getAccessControlContext());
} else {
//执行或者说回调awre方法（并不是所有的awre方法都在这个方法中进行回调）
this.invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//执行spring的生命周期回调 该方法执行处理的是使用注解的方法
wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
}
try {
//执行生命周期初始化回调方法 这里执行的是接口和xml方法的
this.invokeInitMethods(beanName, wrappedBean, mbd);
} catch (Throwable var6) {
throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
}
if (mbd == null || !mbd.isSynthetic()) {
//下面这一行代码中多后置处理器进行循环，通过其中一个后置处理器处理完成了aop
wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
完成aop代理的方法applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
Object result = existingBean;
Object current;
//获取到所有的后置处理器后进行循环处理
for(Iterator var4 = this.getBeanPostProcessors().iterator(); var4.hasNext(); result = current) {
BeanPostProcessor processor = (BeanPostProcessor)var4.next();
current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
}
return result;
}
处理aop的后置处理器如下图，通过该后置处理器改变了bean，变成了代理对象
策略模式
上图体现了策略模式
所有的后置处理器都实现了BeanPostProcessor，每个方法都有不同的实现。有的没有对bean进行处理，有的则进行了改动。
其中有一个后置处理器的实现是这样的，看下面的代码块
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
//得到所有的注解信息 findLifecycleMetadata（找到生命周期的元数据）
//这里使用@PostConstruct注解的bean里面的这个方法（假设叫init()）就会被找到，找到后被存储了起来
InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata metadata = this.findLifecycleMetadata(bean.getClass());
try {
//在该行代码中通过反射执行元数据方法即可。如上面的init()方法就会被执行
metadata.invokeInitMethods(bean, beanName);
return bean;
} catch (InvocationTargetException var5) {
throw new BeanCreationException(beanName, "Invocation of init method failed", var5.getTargetException());
} catch (Throwable var6) {
throw new BeanCreationException(beanName, "Failed to invoke init method", var6);
}
}
spring创建bean的顺序
spring根据bean的首字母进行排序进行创建
比如有x，y这两个bean要创建，那么会先创建x，后创建y
spring的生命周期有三种方法
这三种方法可以同时存在
1.实现接口
2.spring.xml里面添加标签参数
如下图，回调了A类的aa方法
3.使用注解
如下图，在类的方法上添加该注解
三种方法都存在的时候，spring执行的顺序是什么？
看上图，先执行注解，再执行接口重写方法，最后执行xml
为什么是这个顺序？
代码就是这个顺序
生命周期回调
生命周期回调有两种方法：初始化回调和销毁回调
@PostConstruct注解
生命周期的初始化回调方法。
问题
spring默认支持单例是循环依赖的，如何证明？
在上面的java代码块中，有一行代码是用来判断spring容器是否允许循环依赖的，即下行代码：
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
即spring在创建bean的过程中，该代码会判断有没有开启spring的循环依赖，判断的结果主要取决于allowCircularReferences这个属性的true false值。
通过看代码，我们可以看到该allowCircularReferences的值默认为true。
public AbstractAutowireCapableBeanFactory() {
this.allowCircularReferences = true;
}
如何关闭spring默认的循环依赖？
可以修改allowCircularReferences的值为false。
由于源码我们无法更改，只能在主启动类中进行更改
public class SpringMain {
public static void main(String[] args) {
//初始化spring容器 在初始化的时候完成了依赖注入
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringTest.class);
//这两行代码是新增用来修改allowCircularReferences值的。但是！不起作用的！原因在下面写着。
AbstractAutowireCapableBeanFactory beanFactory = (AbstractAutowireCapableBeanFactory) context.getBeanFactory();
beanFactory.setAllowCircularReferences(false);
System.out.println(context.getBean(IndexService.class));
}
}
在
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringTest.class);
之后对allowCircularReferences进行赋值为false。
但是我们需要注意的是，在
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringTest.class);
执行完成之后，bean对象已经初始化完成，bean的属性也均赋值完成，因此在该行代码之后对allowCircularReferences进行重新赋值是无用的，因为bean已经初始化完成。
解决方案
public class SpringMain {
public static void main(String[] args) {
//这里我们使用无参构造方法创建了context
//然后再执行context的register方法，然后添加我们修改属性值的方法，最后执行refresh方法。
//这样就实现了属性修改。为什么这样能实现属性修改呢？看下面文字讲解。
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(SpringTest.class);
AbstractAutowireCapableBeanFactory beanFactory = (AbstractAutowireCapableBeanFactory) context.getBeanFactory();
beanFactory.setAllowCircularReferences(false);
context.refresh();
System.out.println(context.getBean(IndexService.class));
}
}
当代码为
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringTest.class);
的时候，我们创建context是使用了有参构造，而有参构造的源码为：
public AnnotationConfigApplicationContext(Class... componentClasses) {
this();//调用默认构造方法
this.register(componentClasses);
this.refresh();
}
而我们的解决方案中的代码为：
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
使用的是无参构造创建的context，无参构造的源码为：
public AnnotationConfigApplicationContext() {
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
这个无参构造方法就是 有参构造方法中的 this（）方法。
因此方案一中，
先调用无参构造，再执行register方法，然后执行手动代码（修改属性），最后执行refresh方法，便可以成功修改属性。因为refresh方法才是正式初始化bean的方法。
源码继续跟踪
populateBean()
populateBean()方法源码 该方法实现bean的属性注入
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
if (bw == null) {
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
} else {
boolean continueWithPropertyPopulation = true;
if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
Iterator var5 = this.getBeanPostProcessors().iterator();
while(var5.hasNext()) {
BeanPostProcessor bp = (BeanPostProcessor)var5.next();
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
if (continueWithPropertyPopulation) {
PropertyValues pvs = mbd.hasPropertyValues() ? mbd.getPropertyValues() : null;
if (mbd.getResolvedAutowireMode() == 1 || mbd.getResolvedAutowireMode() == 2) {
MutablePropertyValues newPvs = new MutablePropertyValues((PropertyValues)pvs);
if (mbd.getResolvedAutowireMode() == 1) {
this.autowireByName(beanName, mbd, bw, newPvs);
}
if (mbd.getResolvedAutowireMode() == 2) {
this.autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = this.hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = mbd.getDependencyCheck() != 0;
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
//获取所有的后置处理器 转换为迭代器进行循环处理
Iterator var9 = this.getBeanPostProcessors().iterator();
//在这里进行后置处理器的循环
//也就是说，每个后置处理器依次对该bean进行处理，完成该bean的属性注入操作
while(var9.hasNext()) {
BeanPostProcessor bp = (BeanPostProcessor)var9.next();
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
//该行执行完成之后，bean的属性才被注入进去的。这里插入一个问题，看下面文字。
PropertyValues pvsToUse = ibp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
this.checkDependencies(beanName, mbd, filteredPds, (PropertyValues)pvs);
}
if (pvs != null) {
this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
}
}
}
}
首先，在上面代码块中
Iterator var9 = this.getBeanPostProcessors().iterator();该代码获取到了所有的后置处理器，并转换为了迭代器。
即， this.getBeanPostProcessors()获取到的是一个后置处理器x，y，z等的list集合。当循环到了AutowiredAnnotationBeanPostProcessor这个后置处理器的时候，再执行
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
Iterator var9 = this.getBeanPostProcessors().iterator();
while(var9.hasNext()) {
BeanPostProcessor bp = (BeanPostProcessor)var9.next();
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
PropertyValues pvsToUse = ibp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)这个方法之后，bean对象中如果有使用@Autwired注解注入的属性X，那么在这一行代码执行完成之后，该属性就有值了。
说的再直白一点便是：
如果该X的构造方法中有日志输出，那么在这一行代码执行完成之后，该日志便会输出来。说明该X对象被创建了。但是我们需要注意的是，是X对象被new出来了，而不是被初始化完成了。
如果属性是使用@Resouce这个注解去注入的话，会被@CommonAnnotationBeanPostProcessor注解解析并完成该属性的值的注入。
此时，X被new出来之后，X便要继续走初始化生命周期的流程了。同理，走到这儿的时候，X里面如果有需要注入的属性M，则一样要走M的声明流程。这里就有一个情况，X中有Y属性，Y中有X属性。这种情况怎么走呢？
代码如下：
@Component
public class UserService {
@Autowired
private IndexService indexService;
public UserService() {
System.out.println("UserService construct");
}
}
@Component
public class IndexService {
@Autowired
private UserService userService;
public IndexService() {
System.out.println("indexService construct");
}
}
当程序主启动类启动的时候，会初始化扫描包下面的所有的component。
如果首先初始化的是IndexService，那么执行到populateBean()方法时，需要给IndexService的属性进行值注入。此时IndexService的属性是UserService。
看上图，走到这一步的时候，ibp是AutowiredAnnotation···的后置处理器，（UserService在IndexService里面就是用@Autowired注解去实现注入的），debug的那一行还没有执行的时候，userService的值还是空的，值还没有注入进来。
当执行了这一步的时候，我们可以看到下图，直接跳到了getBean方法，开始getBean（userService）了。
然后也是一模一样的流程，走到下图这一步的时候，userService对象被创建出来了。（执行了构造方法）
然后继续执行，执行到了同样的需要属性注入的地方
该行执行完成之后，马上就跳转到了getBean方法去获取indexService(请看下图)
然后我们可以看到，在doGetBean方法中的第二行方法（下图），indexService的this.getSingleton方法是有值的。
getSingleton()
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
//如果下行判断成立，则会走进if代码里面。里面代码是会去第三个缓存中去获取bean对象
if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
synchronized(this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
看这个源码第一行，通过beanName去singletonObjects中找数据。而这个singletonObjects是去单例池中找数据的。如果IndexService还没有初始化完成，并且也不在创建当中，那么返回的值就是一个null，进不了if代码中，该方法便会返回一个null。
public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}
判断bean是否正在创建中，是通过上块代码块执行的。那么这个
private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap(16));
那么，这个Set是哪儿给赋值的呢？
就是在doGetBean方法中
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized(this.singletonObjects) {
//根据beanName没有获取到数据，就进入下面的if里面
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!)");
}
if (this.logger.isDebugEnabled()) {
this.logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
//这一步是在创建单例对象之前执行的一个方法。
this.beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = this.suppressedExceptions == null;
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet();
}
try {
singletonObject = singletonFactory.getObject();
newSingleton = true;
} catch (IllegalStateException var16) {
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw var16;
}
} catch (BeanCreationException var17) {
BeanCreationException ex = var17;
if (recordSuppressedExceptions) {
Iterator var8 = this.suppressedExceptions.iterator();
while(var8.hasNext()) {
Exception suppressedException = (Exception)var8.next();
ex.addRelatedCause(suppressedException);
}
}
throw ex;
} finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
this.afterSingletonCreation(beanName);
}
if (newSingleton) {
this.addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
this.beforeSingletonCreation(beanName);源码：该方法就是将beanName放到 Set中去，就表示这个bean正在被创建。
protected void beforeSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) &&
//这个方法将bean放到set中，表示该bean正在创建当中。
!this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
然后在this.beforeSingletonCreation(beanName)这一行代码之后的singletonObject = singletonFactory.getObject();，其实执行的就是
return this.createBean(beanName, mbd, args);
这个方法。
三个map缓存bean
在刚进入doGetBean（）方法中的时候，会先执行以下方法判断该bean是否已经存在了
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//从一级缓存中查找 该singletonObjects就是一级缓存
Object singletonObject = this.singletonObjects.get(beanName);
//如果是第一次创建bean对象且正在创建过程中，此时singletonObject为null，但是后面的条件为true，此时进入了if方法中
if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
synchronized(this.singletonObjects) {
//earlySingletonObjects 是第三个map。该map是三级缓存。在三级缓存中没有找到该bean，取出来的值是null
singletonObject = this.earlySingletonObjects.get(beanName);
//allowEarlyReference该值是在调用getSingleton()这个方法的时候写死传进来的，写死为true，因此该if条件满足，进入了if里面的方法
if (singletonObject == null && allowEarlyReference) {
//singletonFactories 是第二个map
//从该map中再次获取一次beanFactory，此时是能够获取到的。
//是在哪里往singletonFactories里面放数据的呢？在doCreateBean方法里面放的，可以看下面的图。
ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
if (singletonFactory != null) {
//从该工厂中获取到bean
singletonObject = singletonFactory.getObject();
//将bean放到三级缓存中
this.earlySingletonObjects.put(beanName, singletonObject);
//将bean从二级缓存中移除，为什么要移除呢？
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
singletonFactories 也是一个map
doCreateBean()方法中
满足是单例，允许循环依赖，当前bean正在创建中这三个条件，便执行addSingletonFactory方法，将bean放在该factory中
小结
一共有三个map
1.singletonObjects 单例池 （可以理解为spring容器）（一级缓存）（存储的是bean对象）
2.singletonFactory 工厂（二级缓存，存放的是工厂）
3.earlySingletonObjects 三级缓存（存储的是对象）
为什么要从二级缓存工厂中拿出对象后，put进三级缓存中，为什么不直接从二级缓存中拿这个对象去使用？
答：防止工厂重复生产对象
具体解析
singletonObject = singletonFactory.getObject();
该getObejct()方法，具体是走下面这个代码
getEarlyBeanReference（）方法如下：
获取到了所有的后置处理器，并进行了循环处理，这样才在工厂中将该bean创建了出来
因此我们每次从二级缓存中执行getObject方法，都是在工厂中创建一次bean对象的过程。为了防止bean对象重复创建（有的bean创建的时间很长，如果重复创建，会影响性能），就出现了三级缓存，我们第一次从二级缓存中创建了对象后，便将其放接了三级缓存中，然后remove了二级缓存。
有三个service：aService,bService,cService，aService和bService中都注入了cService，如果没有三级缓存的话，aService这个bean创建的时候，需要注入cService，工厂创建了一次cService；bService这个bean创建的时候，需要注入cService，工厂又创建了一次cService，那么这样是不太合理的。
二级缓存的作用
1.有两个service，且为循环依赖场景
2.过程如下：
1.spring启动，先进行indexService的bean的创建
2.执行到doCreateBean-createBeanInstance执行了indexService的构造方法， indexService的对象创建完成
3.接下来将该indexService放到二级缓存工厂中
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if (earlySingletonExposure) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
this.addSingletonFactory(beanName, () -> {
return this.getEarlyBeanReference(beanName, mbd, bean);
});
}
4.接下来执行this.populateBean(beanName, mbd, instanceWrapper)方法进行属性的注入，这里的属性指userService。
5.userService同样先进行对象的创建，然后放到二级缓存工厂中，然后进行属性的注入，此时需要注入的属性是indexService
6.在执行populateBean方法的时候，会跳到getBean方法去获取indexService
7.doGetBean方法中会执行getSingleton方法获取indexService
8.getSingleton方法中，先去单例池中获取bean对象，没有获取到（因为此时indexService还只是对象，而不是bean），接下来去三级缓存中获取，也没有获取到（因为还没有往三级缓存中put过）。最后到二级缓存factory中生产对象，执行getObject方法，在该方法中对后置处理器进行了循环，将indexService创建了出来（在此过程中，也完成了indexService 的PostConstruct方法，完成了aop代理）。
9.userService继续执行initializeBean完成初始化
10.将userService放入单例池中
11.将indexService继续执行initializeBean完成初始化
12.将indexService放入单例池中
为什么二级缓存中不放对象，而是放工厂？
放了工厂后，该工厂后期需要对要注入的还不是bean的对象进行改造优化升级，最后改造成bean的。
为什么需要三个缓存map？
第一个map：单例池，因为spring的单例对象只会被实例化一次，所以需要一个单例池来缓存该信息
第二个map：缓存的是工厂，主要是为了解决循环依赖。X中注入Y，Y中注入X，先创建X，接下来注入Y的时候去创建Y，在注入Y的属性X的时候，获取到了第二个缓存map中的X对应的工厂，通过工厂对X进行了加工，这里的加工指对X进行代理操作以及其他等等操作，最后将X赋值给Y的属性。
什么叫spring容器？
spring容器并不是简单的单例池。
在spring中有很多的组件如beanFactory，三个map，各类后置处理器等所有组件的组成叫做spring容器。
为什么在spring判断支持循环依赖后，要提前暴漏自己？
判断是否需要属性注入的源码逻辑
有上图这样一个后置处理器
如果我们扩展这个后置处理器，如下行代码那样写
@Component
public class XXX implements InstantiationAwareBeanPostProcessor {
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
return true;
}
}
项目中的所有的bean各自的属性都无法注入了
spring的生命周期
spring容器启动
随后进行扫描，将类变成bean definition存储到bean defitionMap当中
然后对该map进行遍历，目的是验证是否单例、是否原型、是否懒加载、是否有DepensOn、是否抽象、是否factoryBean、是否这个bean的名字符合等等
随后获取当前实例化的类是否存在单例池当中（是否被创建，如果没有被创建，则去二级缓存中判断是否存在，即判断是否被提前暴漏），是否被提前暴漏，如果没有提前暴漏的话，则spring的bean就会开始创建该bean
创建bean的过程：
通过推断构造方法的过程把当前bean所代表的类当中的构造方法得到一个最佳的构造方法（因为bean代表的是一个JAVA类，一个JAVA类当中可能存在十几个构造方法，不同的注重模型会使用不同的构造方法，因此spring需要推断一下创建该bean的时候需要使用哪个构造方法）
通过反射实例化java对象
根据该java对象对这个bean进行一些初始化的工作，如是否要对该bean进行beanDefinition的合并；如spring容器是否支持循环依赖，如果支持循环依赖的话，需要提前暴漏当前java对象也就是半成品所对应的一个ObjectFactory的工厂类，即提前暴漏该工厂类。
提前暴漏具体指什么？
将要暴漏的对象存储到一个map中，这个map我们称之为是二级缓存。
暴漏执行完成之后，spring会进行属性填充操作，即自动注入。具体指，如A中依赖了B，则将Bset到A中。
set操作执行完成之后，spring会继续执行一些接口的回调操作
然后会进行一个生命周期初始化的回调操作，如添加了注解@PostConstract 或者@InitializerBean等等
如果项目当中有AOP的话，会生成代理，如果没有的话，则不会生成代理。随后会进行事件的发布操作。
bean的声明周期到此完成，该bean对象会被存储到单例池当中。
map解决循环依赖
spring实例化A的时候，会对A进行基本的验证操作，随后查看A是否被提前暴漏，即A对应的ObjectFactory是否有被提前暴漏
此时是没有被提前暴漏的
随后spring会推断出一个合适的构造方法将A实例化出来。
随后A走到了是否要提前暴漏的方法中，因为当前默认容器是都需要提前暴漏的
A被提前暴漏，此时暴漏的是A生成的创建出来的一个ObjectFactory对象，一个工厂对象
随后进行A的属性填充，填充Y
此时发现Y并没有存在spring的容器中，即Y并没有被实例化，此时会进行Y的实例化操作，即进行Y 的生命周期的一系列过程。
在对Y进行属性填充的时候，填充X，发现X并没有被实例化完全（因为此时X实例化流程完成了一半还没有全部完成），会走一遍创建X的流程，在进行创建X的过程中，会发现X已经被提前暴漏了，所以Y能够拿到已经被提前暴漏的ObjectFactory所产生的一个X对象，这样就完成了循环依赖。
注意：此时的spring是单例的，也就是说循环依赖是支持单例的。但是这里需要注意，此时的循环依赖支持的bean对象 A B,不是通过构造函数的方式注入对象的。因为如果AB对象是通过构造方法创建方式的话，那么永远也无法创建该对象出来。
为什么不直接缓存一个X而是缓存一个ObejctFactory呢？
如果缓存的是X，那么从缓存中拿出来的便仅仅是一个X，程序员很难对其进行扩展改变。
但是如果缓存的是ObjectFactory，springFarmwork的内部通过BeanProcessor 这个接口可以对该factory产生X的过程中进行一定的扩展改变干预的，可以得到自己想要的一个Bean对象。
总结：
bean是由一个BeanDefinition来构建的，BeanDefinition可以理解为springBean的一个建模。
参考
b站：https://www.bilibili.com/video/BV1uE411d7L5?p=7&spm_id_from=pageDriver
805
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
