手撕Spring bean的生命週期源碼

學習spring源碼主框架，從源碼角度開發學習Spring bean的生命週期。

spring創建bean方法

org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String, java.lang.Class )

public  T getBean(String name, Class requiredType) throws BeansException {
 //doGetBean是獲取bean的真實方法
 return doGetBean(name, requiredType, null, false);
 }

真正執行spring創建bean方法doGetBean

org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean

protected  T doGetBean(
 final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
 throws BeansException {
 //獲取的beanname可能是重命名後的，這個獲取原始的beanname，這裡做別名解析
 final String beanName = transformedBeanName(name);
 Object bean;
 //先從spring緩存池中獲取bean，這裡是解決循環依賴的根本
 Object sharedInstance = getSingleton(beanName);
 if (sharedInstance != null && args == null) {
 if (logger.isDebugEnabled()) {
 if (isSingletonCurrentlyInCreation(beanName)) {
 logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
 "' that is not fully initialized yet - a consequence of a circular reference");
 }
 else {
 logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
 }
 }
 //如果從緩存中獲取到bean，進行後續處理。
 bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
 } 

 else {
 //判斷當前創建的bean是不是原型的，如果存在循環依賴，則拋異常
 if (isPrototypeCurrentlyInCreation(beanName)) {
 throw new BeanCurrentlyInCreationException(beanName);
 }
 //獲取父工廠
 BeanFactory parentBeanFactory = getParentBeanFactory();
 //判斷父工廠是否為空，以及當前容器中是否包含bean定義
 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
 // Not found -> check parent.
 String nameToLookup = originalBeanName(name);
 //根據構造函數是否有參數，來創建不同的bean
 if (args != null) {
 // Delegation to parent with explicit args.
 return (T) parentBeanFactory.getBean(nameToLookup, args);
 }
 else {
 // No args -> delegate to standard getBean method.
 return parentBeanFactory.getBean(nameToLookup, requiredType);
 }
 }
 
 if (!typeCheckOnly) {
 markBeanAsCreated(beanName);
 }
 try {
 //合併bean定義，存在抽象父bean定義，專門給子bean做繼承的
 final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
 //檢查bean定義的是否為抽象的，如果是則拋出異常
 checkMergedBeanDefinition(mbd, beanName, args);
 //獲取bean初始化的前置依賴beanname
 String[] dependsOn = mbd.getDependsOn();
 if (dependsOn != null) {
 for (String dep : dependsOn) {
 if (isDependent(beanName, dep)) {
 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
 "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
 } 

 //解析以來的bean，並註冊依賴的bean
 registerDependentBean(dep, beanName);
 try {
 //遞歸調用獲取依賴bean
 getBean(dep);
 }
 catch (NoSuchBeanDefinitionException ex) {
 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
 "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
 }
 }
 }
 // 創建bean的實例
 if (mbd.isSingleton()) {
 sharedInstance = getSingleton(beanName, new ObjectFactory<object>() {
 @Override
 public Object getObject() throws BeansException {
 try {
 //構建bean的實例
 return createBean(beanName, mbd, args);
 }
 catch (BeansException ex) {
 // Explicitly remove instance from singleton cache: It might have been put there
 // eagerly by the creation process, to allow for circular reference resolution.
 // Also remove any beans that received a temporary reference to the bean.
 destroySingleton(beanName);
 throw ex;
 }
 }
 });
 //如果獲取的bean是factroybean，那麼要處理工廠bean。
 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
 }
 else if (mbd.isPrototype()) {
 //創建原型bean
 Object prototypeInstance = null;
 try {
 //在原型bena創建之前回調底層spring函數，開放性方法
 beforePrototypeCreation(beanName);
 prototypeInstance = createBean(beanName, mbd, args);
 }
 finally {
 //開放性方法 

 afterPrototypeCreation(beanName);
 }
 //如果獲取的bean是factroybean，那麼要處理工廠bean。
 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
 }
 else {
 String scopeName = mbd.getScope();
 final Scope scope = this.scopes.get(scopeName);
 if (scope == null) {
 throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
 }
 try {
 //根據bean定義的scope來創建bean
 Object scopedInstance = scope.get(beanName, new ObjectFactory<object>() {
 @Override
 public Object getObject() throws BeansException {
 beforePrototypeCreation(beanName);
 try {
 return createBean(beanName, mbd, args);
 }
 finally {
 afterPrototypeCreation(beanName);
 }
 }
 });
 bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
 }
 catch (IllegalStateException ex) {
 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",
 ex);
 }
 }
 }
 catch (BeansException ex) {
 cleanupAfterBeanCreationFailure(beanName);
 throw ex;
 }
 }
 // 判斷獲取的類型是否匹配實際的bean實例
 if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
 try {
 return getTypeConverter().convertIfNecessary(bean, requiredType);
 }
 catch (TypeMismatchException ex) {
 if (logger.isDebugEnabled()) { 

 logger.debug("Failed to convert bean '" + name + "' to required type '" +
 ClassUtils.getQualifiedName(requiredType) + "'", ex);
 }
 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
 }
 }
 return (T) bean;
 }
/<object>/<object>

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean)這個方法是解決spring循環依賴問題

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
 //從一級緩存中獲取實例bean，如果有直接返回對象
 Object singletonObject = this.singletonObjects.get(beanName);
 //singletonObject為空並且 beanname是否正在創建中的標識
 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
 //防止併發獲取bean
 synchronized (this.singletonObjects) {
 //從earlySingletonObjects早期緩衝池中獲取bean
 singletonObject = this.earlySingletonObjects.get(beanName);
 if (singletonObject == null && allowEarlyReference) {
 //從singletonFactories中獲取bean的objectfactory
 ObjectFactory> singletonFactory = this.singletonFactories.get(beanName);
 if (singletonFactory != null) {
 //調用objectfactory的getObject方法獲取singletonObject
 singletonObject = singletonFactory.getObject();
 //同時放到earlySingletonObjects提前暴露出來
 this.earlySingletonObjects.put(beanName, singletonObject);
 //並從singletonFactories移除
 this.singletonFactories.remove(beanName);
 }
 }
 }
 }
 return (singletonObject != NULL_OBJECT ? singletonObject : null);
 }

獲取實例bean

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, org.springframework.beans.factory.ObjectFactory )

public Object getSingleton(String beanName, ObjectFactory> singletonFactory) {
 Assert.notNull(beanName, "'beanName' must not be null");
 synchronized (this.singletonObjects) {
 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 (logger.isDebugEnabled()) {
 logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
 }
 //標識當前正在創建的對象，放到singletonsCurrentlyInCreation緩存中
 beforeSingletonCreation(beanName);
 boolean newSingleton = false;
 boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
 if (recordSuppressedExceptions) {
 this.suppressedExceptions = new LinkedHashSet<exception>();
 }
 try {
 //調用接口objectfacotry的getObject方法， 這個方法被重寫
 singletonObject = singletonFactory.getObject();
 newSingleton = true;
 }
 catch (IllegalStateException ex) {
 // Has the singleton object implicitly appeared in the meantime ->
 // if yes, proceed with it since the exception indicates that state.
 singletonObject = this.singletonObjects.get(beanName);
 if (singletonObject == null) {
 throw ex;
 }
 }
 catch (BeanCreationException ex) {
 if (recordSuppressedExceptions) {
 for (Exception suppressedException : this.suppressedExceptions) {
 ex.addRelatedCause(suppressedException);
 }
 }
 throw ex;
 }
 finally {
 if (recordSuppressedExceptions) {
 this.suppressedExceptions = null; 

 }
 //當前bean已經創建好了，到singletonsCurrentlyInCreation中bean移除掉
 afterSingletonCreation(beanName);
 }
 if (newSingleton) {
 //把創建好的bean加載到緩存池中，並移除二三級緩存
 addSingleton(beanName, singletonObject);
 }
 }
 //對bean判空
 return (singletonObject != NULL_OBJECT ? singletonObject : null);
 }
 }
/<exception>

創建bean實例

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
 if (logger.isDebugEnabled()) {
 logger.debug("Creating instance of bean '" + beanName + "'");
 }
 RootBeanDefinition mbdToUse = mbd;
 // Make sure bean class is actually resolved at this point, and
 // clone the bean definition in case of a dynamically resolved Class
 // which cannot be stored in the shared merged bean definition.
 Class> resolvedClass = resolveBeanClass(mbd, beanName);
 if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
 mbdToUse = new RootBeanDefinition(mbd);
 mbdToUse.setBeanClass(resolvedClass);
 }
 // Prepare method overrides.
 try {
 mbdToUse.prepareMethodOverrides();
 }
 catch (BeanDefinitionValidationException ex) {
 throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
 beanName, "Validation of method overrides failed", ex);
 }
 try {
 // 這裡給後置處理器一個機會去創建代理對象，第一次創建bean到這裡還沒有創建好bean， 僅僅把切面信息解析出來放入緩存中 

 Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
 if (bean != null) {
 return bean;
 }
 }
 catch (Throwable ex) {
 throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
 "BeanPostProcessor before instantiation of bean failed", ex);
 }
 //真正執行創建bean實例的方法doCreateBean
 Object beanInstance = doCreateBean(beanName, mbdToUse, args);
 if (logger.isDebugEnabled()) {
 logger.debug("Finished creating instance of bean '" + beanName + "'");
 }
 return beanInstance;
 }

真正執行創建Bean

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
 throws BeanCreationException {
 // Instantiate the bean.
 BeanWrapper instanceWrapper = null;
 if (mbd.isSingleton()) {
 instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
 }
 if (instanceWrapper == null) {
 //根據@bean， @autowire來創建有參構造函數， 或者無參數構造函數
 instanceWrapper = createBeanInstance(beanName, mbd, args);
 }
 final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
 Class> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
 mbd.resolvedTargetType = beanType;
 
 //允許後置處理器去修改merge後的bean定義
 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;
 }
 }
 // 判斷earlySingletonObjects是否提前暴露bean對象
 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
 isSingletonCurrentlyInCreation(beanName));
 if (earlySingletonExposure) {
 if (logger.isDebugEnabled()) {
 logger.debug("Eagerly caching bean '" + beanName +
 "' to allow for resolving potential circular references");
 }
 //將已經創建好但是屬性還沒有賦值的bean對象，通過objectfacotry的形式來加載到緩存中用來解決循環依賴的問題 

 addSingletonFactory(beanName, new ObjectFactory<object>() {
 @Override
 public Object getObject() throws BeansException {
 return getEarlyBeanReference(beanName, mbd, bean);
 }
 });
 }
 // Initialize the bean instance.
 Object exposedObject = bean;
 try {
 //為剛剛創建的bean對象進行賦值
 populateBean(beanName, mbd, instanceWrapper);
 if (exposedObject != null) {
 //初始化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(
 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<string> actualDependentBeans = new LinkedHashSet<string>(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."); 

 }
 }
 }
 }
 try {
 //註冊自定義銷燬bean的方法
 registerDisposableBeanIfNecessary(beanName, bean, mbd);
 }
 catch (BeanDefinitionValidationException ex) {
 throw new BeanCreationException(
 mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
 }
 return exposedObject;
 }
/<string>/<string>/<object>

初始化已經創建好的bean實例

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
 //權限校驗是否判斷是否可以回調底層組件方法
 if (System.getSecurityManager() != null) {
 AccessController.doPrivileged(new PrivilegedAction<object>() {
 @Override
 public Object run() {
 invokeAwareMethods(beanName, bean);
 return null;
 }
 }, getAccessControlContext());
 }
 else {
 invokeAwareMethods(beanName, bean);
 }
 Object wrappedBean = bean;
 if (mbd == null || !mbd.isSynthetic()) {
 //實現自定義的bean的後置處理器的前置方法
 wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
 }
 try {
 //調用自定義的init方法或InitializingBean
 invokeInitMethods(beanName, wrappedBean, mbd);
 }
 catch (Throwable ex) { 

 throw new BeanCreationException(
 (mbd != null ? mbd.getResourceDescription() : null),
 beanName, "Invocation of init method failed", ex);
 }
 if (mbd == null || !mbd.isSynthetic()) {
 //實現自定義的bean的後置處理器的後置方法
 wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
 }
 return wrappedBean;
 }
/<object>

以上，就是spring ioc模塊bean生命週期的源代碼解析。

》》》相比讚賞，更喜歡被轉發