SpringBean的初始化和实例化的区别实例化：是对象创建的过程。⽐如使⽤构造⽅法new对象，为对象在内存中分配空间。
初始化：是为对象中的属性赋值的过程。
在Spring中，AbstractAutowireCapableBeanFactory类的doCreateBean()⽅法描述了这个过程。
/**
* Actually create the specified bean. Pre-creation processing has already happened
* at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
* <p>Differentiates between default bean instantiation, use of a
* factory method, and autowiring a constructor.
* @param beanName the name of the bean
* @param mbd the merged bean definition for the bean
* @param args explicit arguments to use for constructor or factory method invocation
* @return a new instance of the bean
* @throws BeanCreationException if the bean could not be created
* @see #instantiateBean
* @see #instantiateUsingFactoryMethod
* @see #autowireConstructor
*/
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = ve(beanName);
}
if (instanceWrapper == null) {
//<1>实例化bean
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = WrappedInstance();
Class<?> beanType = WrappedClass();
if (beanType != NullBean.class) {
}
/
/ Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//<2>应⽤后置处理器修改bean definition
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new ResourceDescription(), 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.
//<3>饥饿加载单例bean，解决循环依赖问题
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
"' to allow for resolving potential circular references");
}
//<4>如何解决循环依赖问题的呢，就是提前将实例化的bean放⼊缓存，以beanName->bean的引⽤的⽅式放⼊map，在createBean的上⼀步getBean的时候会从缓存  addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
//<5>初始化bean实例
Object exposedObject = bean;
try {
//<6>设置属性，如果属性是依赖注⼊的其他bean，⾛⼀遍getBean⽅法
populateBean(beanName, mbd, instanceWrapper);
实例化类和实例化对象//<7>初始化，调⽤aware⽅法、bean后置处理器的初始化前⽅法、初始化⽅法、bean后置处理器的初始化后⽅法
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
}
}
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<String> 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 [" +
"] 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 {
//<8>注册需要执⾏销毁回调的单例bean，⽐如在销毁⽅法中释放资源。
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
}
return exposedObject;
}
``<1>``实例化bean
``<2>``应⽤后置处理器修改bean definition
``<3>``饥饿加载单例bean，解决循环依赖问题
``<4>``如何解决循环依赖问题的呢，就是提前将实例化的bean放⼊缓存，以beanName->bean的引⽤的⽅式放⼊map，在createBean的上⼀步getBean的时候会从缓存中先拿bean。
``<5>``初始化bean实例
``<6>``设置属性，如果属性是依赖注⼊的其他bean，⾛⼀遍getBean⽅法
``<7>``初始化，调⽤aware⽅法、bean后置处理器的初始化前⽅法、初始化⽅法、bean后置处理器的初始化后⽅法
``<8>``注册需要执⾏销毁回调的单例bean，⽐如在销毁⽅法中释放资源。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。