Spring Bean的生命週期源碼詳解 - 【Spring底層原理】
1、源碼分析
先分析源碼，再來總結，從啓動類開始，只會截取部分重要代碼，但方法調用不會斷java
先來看看bean生命週期源碼的腦圖，能夠跟着這個腦圖來分析源碼 若是看不清腦圖能夠用電腦打開該連接查看：assets.processon.com/chart_image…spring
源碼分析：從AnnotationConfigApplicationContext開始緩存
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
this();
// 將beanDefinition對象存儲到beanDefinitionMap
this.register(componentClasses);
// Bean生命週期相關
this.refresh();
}
複製代碼
1. register方法
這個方法的主要做用及時
beanDefinition對象存儲到beanDefinitionMap中，在spring中，beanDefinition是用來封裝一些類的信息的，好比這個類有哪些註解，是否懶加載等，經spring掃描後，都會封裝到beanDefinition中，而若是有多個這樣的類，就將beanDefinition存儲到beanDefinitionMap中。markdown在這個方法，還有一個很重要的做用就是將咱們的配置類放入spring容器當中，所謂的配置類，也能夠理解爲一個對象，這個配置類須要咱們手動掃描，手動將配置類加入到spring容器中，而在配置類進行@Bean註解注入的類則是經過配置類自動掃描注入的。app
2. refresh方法
挑主要的方法進行查看：ide
這裏和生命週期相關的主要就是下面這兩個類函數
- invokeBeanFactoryPostProcessors：進行一些掃描工做，將符合spring規則的類掃描到加入beanDefinitionMap當中
- 在這裏還會執行beanFactoryPostProcessor，對bean進行一些拓展，俗一些就是能夠管理咱們的bean工廠內全部的beandefinition（未實例化）數據，能夠爲所欲爲的修改屬性。
- finishBeanFactoryInitialization：實例化Bean就是在這裏完成的
public void refresh() throws BeansException, IllegalStateException {
synchronized(this.startupShutdownMonitor) {
......
try {
......
// 進行一些掃描工做，將符合spring規則的類掃描到加入beanDefinitionMap當中
this.invokeBeanFactoryPostProcessors(beanFactory);
......
// 實例化Bean就是在這裏完成的
this.finishBeanFactoryInitialization(beanFactory);
......
}
}
}
複製代碼
接下來我們的重頭戲就是跟蹤finishBeanFactoryInitialization方法，探究bean是如何實例化的，finishBeanFactoryInitialization調用preInstantiateSingletons方法進行實例化單例,，進入preInstantiateSingletons方法查看源碼：這個方法就是一些簡單的驗證oop
【1】preInstantiateSingletons方法進行驗證源碼分析
- 拿到全部的bean，存到beanNames集合中
- 遍歷beanNames集合獲取beanName
- 經過beanName做爲key去beanDefinitionMap當中獲取一個beanDefinition對象
- 驗證是否抽象，是否單例，是否懶加載，是不是一個FactoryBean等（普通的bean和>FactoryBean不同，通常爲否）
- 爲否，則調用getBean方法，將遍歷出的bean的名稱做爲參數傳入
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Pre-instantiating singletons in " + this);
}
// 拿到全部的bean，存到beanNames集合中
List<String> beanNames = new ArrayList(this.beanDefinitionNames);
Iterator var2 = beanNames.iterator();
// 遍歷beanNames集合獲取beanName
while(true) {
String beanName;
Object bean;
do {
while(true) {
RootBeanDefinition bd;
do {
do {
......
// 經過beanName做爲key去beanDefinitionMap當中獲取一個beanDefinition對象
bd = this.getMergedLocalBeanDefinition(beanName);
// 對當前的beanDefinition進行簡單的驗證，如是否抽象，是否單例，是否懶加載等（通常狀況下是成立的）
} while(bd.isAbstract());
} while(!bd.isSingleton());
} while(bd.isLazyInit());
// 驗證是不是一個FactoryBean（普通的bean和FactoryBean不同，通常爲否）
if (this.isFactoryBean(beanName)) {
bean = this.getBean("&" + beanName);
break;
}
// 爲否，則調用getBean方法
this.getBean(beanName);
}
} while(!(bean instanceof FactoryBean));
.....
}
}
複製代碼
【2】getBean調用doGetBeanpost
點擊進入getBean方法，這是一個空殼方法，因此咱們點進doGetBean()
public Object getBean(String name) throws BeansException {
return this.doGetBean(name, (Class)null, (Object[])null, false);
}
複製代碼
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
// 對beanName進行合法性驗證
String beanName = this.transformedBeanName(name);
/* * 1.第一次會從緩存中拿，第一次確定是拿不到的，這是爲了解決循環依賴 * 2.驗證當前對象是否存在容器中（通常不存在，爲空，下面判斷進入else） */
Object sharedInstance = this.getSingleton(beanName);
Object bean;
// 不等於null的狀況：存在循環依賴的時候bean會被提早建立
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);
} else {
// 判斷這個對象是否存在正在建立的原型集合當中(通常不存在)
if (this.isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
......
// 判斷是否單例
if (mbd.isSingleton()) {
// 第二次調用getSingleton
// 實例化bean，bean的生命週期都在這個getSingleton走完
// lambda表達式理解爲對singletonObject = singletonFactory.getObject();中getObject進行重寫
sharedInstance = this.getSingleton(beanName, () -> {
try {
// 完成bean的建立
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
});
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
......
}
複製代碼
其實這裏有個比較重要的知識點，解決循環依賴的三級緩存，這裏提一下，後面會專門出文章講解循環依賴，有疑惑的夥伴能夠跳過，只要知道能夠用來建立bean就能夠了
爲了解決spring的循環依賴，有個三級緩存，什麼是緩存？點進
getSingleton查看，能夠看到一個singletonObjects，這個singletonObjects就是緩存，而這個singletonObjects的map就是spring的單例池，單例池就是已經實例化好的對象我就放進去，我要用的時候直接從池子裏面拿，不用再實例化一遍，這時候從單例池中get，全部的對象第一次實例化都要過來這裏，第一次單例池裏面確定是沒有的。
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
synchronized(this.singletonObjects) {
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
複製代碼
我們再往回看
doGetBean方法，第一次從緩存取結束後，會走到下一次的getSingleton方法，這裏調用比較複雜，而且涉及到spring的三級緩存，暫時不講這麼多，就直接看調用createBean方法
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized(this.singletonObjects) {
// 判斷bean是否建立（通常是null）
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 {
// 調用getObject方法至關於調用上面的this.getSingleton，也就是調用createBean方法
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;
}
}
複製代碼
【3】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 + "'");
}
RootBeanDefinition mbdToUse = mbd;
// 獲得bean的class類
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 {
// 在這個方法裏面建立bean，調用doCreateBean建立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，這個方法最終完成了bean的實例化
在doCreateBean這個方法中，完成了bean的實例化，屬性注入和初始化，bean的實例化就是在createBeanInstance方法執行的
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//建立bean實例，並將實例包裹在BeanWrapper實現類對象中返回。
//createBeanInstance(beanName, mbd, args)包含三種建立bean的方式
// 1.經過工廠方法建立bean實例
// 2.經過構造方法自動注入的方式建立實例
// 3.經過無參構造方法建立實例
//在這裏會打印類的構造函數可是屬性並無注入
//
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// 經過post-processors去修改合併beanDefinition
synchronized(mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
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;
}
}
// 緩存一個對象去解決循環依賴
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);
});
}
Object exposedObject = bean;
try {
// 完成屬性填充，判斷屬性是否須要注入，完成自動注入（調用set方法進行賦值）
this.populateBean(beanName, mbd, instanceWrapper);
// 主要執行各類生命週期和回掉方法以及aop等，執行部分aware接口
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);
}
......
}
複製代碼
【4】推斷合適的構造方法
爲了再對bean的實例化一探究竟，咱們再點進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();
// 若是沒有推斷出合適的構造方法（或者沒有提供特殊的構造方法），則使用默認的構造方法
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(() -> {
// 調用默認構造方法
return this.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 var5) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", var5);
}
}
複製代碼
調用默認構造方法
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
if (!bd.hasMethodOverrides()) {
Constructor constructorToUse;
synchronized(bd.constructorArgumentLock) {
constructorToUse = (Constructor)bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
clazz.getClass();
constructorToUse = (Constructor)AccessController.doPrivileged(() -> {
return clazz.getDeclaredConstructor();
});
} else {
// 獲得默認的構造方法
constructorToUse = clazz.getDeclaredConstructor();
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
} catch (Throwable var9) {
throw new BeanInstantiationException(clazz, "No default constructor found", var9);
}
}
}
// 經過默認構造方法去實例化對象
return BeanUtils.instantiateClass(constructorToUse, new Object[0]);
} else {
return this.instantiateWithMethodInjection(bd, beanName, owner);
}
}
複製代碼
最後到了這裏，也就是經過反射來實例化對象
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
Assert.notNull(ctor, "Constructor must not be null");
try {
ReflectionUtils.makeAccessible(ctor);
// 經過反射來實例化對象
if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
return BeanUtils.KotlinDelegate.instantiateClass(ctor, args);
} else {
Class<?>[] parameterTypes = ctor.getParameterTypes();
Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
Object[] argsWithDefaultValues = new Object[args.length];
for(int i = 0; i < args.length; ++i) {
if (args[i] == null) {
Class<?> parameterType = parameterTypes[i];
argsWithDefaultValues[i] = parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null;
} else {
argsWithDefaultValues[i] = args[i];
}
}
return ctor.newInstance(argsWithDefaultValues);
}
} catch (InstantiationException var6) {
throw new BeanInstantiationException(ctor, "Is it an abstract class?", var6);
} catch (IllegalAccessException var7) {
throw new BeanInstantiationException(ctor, "Is the constructor accessible?", var7);
} catch (IllegalArgumentException var8) {
throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", var8);
} catch (InvocationTargetException var9) {
throw new BeanInstantiationException(ctor, "Constructor threw exception", var9.getTargetException());
}
}
複製代碼
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
if (!bd.hasMethodOverrides()) {
Constructor constructorToUse;
synchronized(bd.constructorArgumentLock) {
constructorToUse = (Constructor)bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
clazz.getClass();
// 實例化對象
constructorToUse = (Constructor)AccessController.doPrivileged(() -> {
return clazz.getDeclaredConstructor();
});
} else {
constructorToUse = clazz.getDeclaredConstructor();
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
} catch (Throwable var9) {
throw new BeanInstantiationException(clazz, "No default constructor found", var9);
}
}
}
return BeanUtils.instantiateClass(constructorToUse, new Object[0]);
} else {
return this.instantiateWithMethodInjection(bd, beanName, owner);
}
}
複製代碼
至此，便實例化完成，在bean實例化以後，終於把這個bean，加入到了spring的單例池，從二級和三級緩存移除這個bean，之後能夠直接從單例池中拿了，十分方便
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);
}
}
複製代碼
【5】初始化回調方法
回到doCreateBean方法來看看initializeBean這個方法，這裏主要是執行一些初始化回調方法
- invokeAwareMethods：執行部分aware方法（BeanNameAware、BeanClassLoaderAware、BeanFactoryAware）
- applyBeanPostProcessorsBeforeInitialization：執行另一部分aware以及註解版的生命週期初始化回調方法
- invokeInitMethods：執行接口版的生命週期初始化回調方法
- applyBeanPostProcessorsAfterInitialization：完成aop，生成代理，事件發佈，監聽
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 {
// 執行部分aware方法（BeanNameAware、BeanClassLoaderAware、BeanFactoryAware）
this.invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 執行另一部分aware以及註解版的生命週期初始化回調方法
wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
}
try {
// 執行接口版的生命週期初始化回調方法
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;
}
複製代碼
private void invokeAwareMethods(String beanName, Object bean) {
// 將bean傳入，判斷bean是否實現了aware接口，只要bean實現了xxxaware，這個條件必定知足
if (bean instanceof Aware) {
// 再判斷是哪一種類型的aware
if (bean instanceof BeanNameAware) {
((BeanNameAware)bean).setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = this.getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware)bean).setBeanClassLoader(bcl);
}
}
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware)bean).setBeanFactory(this);
}
}
}
複製代碼
2、總結
看了源碼，我們再來總結一下：
- 實例化spring容器
- 掃描符合
springbean規則的class集合 - 遍歷這個集合當中的類，封裝成一個
beanDefinition對象，裝入beanDefinitionMap（配置類也是一個bean，在beanDefinitionMap中） - 遍歷
beanDefinitionMap獲得beanDefinition對象 - 解析驗證
- 驗證是否懶加載、是否單例、是否抽象......，驗證經過後獲得class對象
- 經過class獲得全部的構造方法，計算推斷出合理的構造方法
- 經過合理的構造方法反射實例化一個對象
- 合併
beanDefinition - 提早暴露工廠（三級緩存）
- 判斷是否須要完成屬性的填充，自動注入屬性
- 執行部分aware接口
- 執行另一部分aware接口，執行註解版的生命週期初始化回調方法
- 執行接口版的生命週期初始化回調方法
- 完成aop，生成代理，事件發佈，監聽
- 放入單例池
singletonobjects - 銷燬
看到過一張finishBeanFactoryInitialization調用的流程圖，思路很清晰，這裏用一下，能夠一塊兒配合理解
引用地址：blog.csdn.net/lclcsdnblin…
相關文章
- 1. Spring Bean——理解Bean的生命週期
- 2. Spring源碼之bean的生命週期
- 3. Spring源碼-Bean的生命週期
- 4. Spring詳解Bean的生命週期
- 5. spring之Bean的生命週期詳解
- 6. Spring Bean的生命週期詳解
- 7. Spring之Bean的生命週期詳解
- 8. 詳解Spring中Bean的生命週期
- 9. spring Bean生命週期源碼分析
- 10. Spring的Bean生命週期理解
- 更多相關文章...
- • Spring Bean的生命週期 - Spring教程
- • Rust 生命週期 - RUST 教程
- • Docker 清理命令
- • Spring Cloud 微服務實戰(三) - 服務註冊與發現
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
