Rising Sun 
          
				
          
			          		
		
          
	
          

          

          
	
          
		
          
			
 
BlogJava ::
首頁 ::
新隨筆 ::
聯系 ::
聚合
 ::
管理 ::


			
			
				

          
	
          
		
          
			
			
			
				 
				148 
				隨筆 ::
				0 文章
				::
				22 評論
				::
				0 Trackbacks
			
		
          
	
          

          

			          		
		
          
	
          

          


          


          
	
					

          
	
	
	
          
		
          http://singleant.iteye.com/blog/1177358
           
          接上文 啃啃老菜： Spring IOC核心源碼學習（一） ，本文將以 ClassPathXmlApplicationContext 這個容器的實現作為基礎，學習容器的初始化過程。
          ClassPathXmlApplicationContext 類體系結構
          以下是 ClassPathXmlApplicationContext 的類繼承體系結構，理解這個結構有助于后面的代碼理解。
           

           
          左邊黃色部分是 ApplicationContext 體系繼承結構，右邊是 BeanFactory 的結構體系,兩個結構是典型模板方法設計模式的使用。
          從該繼承體系可以看出：
          1.       BeanFactory 是一個 bean 工廠的最基本定義，里面包含了一個 bean 工廠的幾個最基本的方法，getBean(…) 、 containsBean(…) 等 ,是一個很純粹的bean工廠，不關注資源、資源位置、事件等。ApplicationContext 是一個容器的最基本接口定義，它繼承了 BeanFactory, 擁有工廠的基本方法。同時繼承了ApplicationEventPublisher 、 MessageSource 、 ResourcePatternResolver 等接口，使其 定義了一些額外的功能，如資源、事件等這些額外的功能。
          2.      AbstractBeanFactory 和 AbstractAutowireCapableBeanFactory 是兩個模板抽象工廠類。AbstractBeanFactory 提供了 bean 工廠的抽象基類，同時提供了 ConfigurableBeanFactory 的完整實現。AbstractAutowireCapableBeanFactory 是繼承了 AbstractBeanFactory 的抽象工廠，里面提供了 bean 創建的支持，包括 bean 的創建、依賴注入、檢查等等功能，是一個核心的 bean 工廠基類。
          3.       ClassPathXmlApplicationContext之 所以擁有 bean 工廠的功能是通過持有一個真正的 bean 工廠DefaultListableBeanFactory 的實例，并通過 代理 該工廠完成。
          4.       ClassPathXmlApplicationContext 的初始化過程是對本身容器的初始化同時也是對其持有的DefaultListableBeanFactory 的初始化。
           
          下面通過源碼著重介紹一個容器的初始化過程，并重點理解 bean 的創建過程。
           
           
          容器初始化過程
          通過上文 啃啃老菜： Spring IOC核心源碼學習（一） 已經可以了解一個容器的大概過程是：
           

           
           
          整個過程可以理解為是容器的初始化過程。第一個過程是 ApplicationContext 的職責范圍，第二步是 BeanFactory的職責范圍。可以看出 ApplicationContext 是一個運行時的容器需要提供不容資源環境的支持，屏蔽不同環境的差異化。而 BeanDifinition 是內部關于 bean 定義的基本結構。 Bean 的創建就是基于它，回頭會介紹一下改結構的定義。下面看一下整個容器的初始化過程。
           
          容器的初始化是通過調用 refresh() 來實現。該方法是非常重要的一個方法，定義在 AbstractApplicationContext接口里。 AbstractApplicationContext 是容器的最基礎的一個抽象父類。也就是說在該里面定義了一個容器初始化的基本流程，流程里的各個方法有些有提供了具體實現，有些是抽象的 ( 因為不同的容器實例不一樣 ) ，由繼承它的每一個具體容器完成定制。看看 refresh 的基本流程：
          Java代碼  收藏代碼
          1. public void refresh() throws BeansException, IllegalStateException {  
          2.         synchronized (this.startupShutdownMonitor) {  
          3.             // Prepare this context for refreshing.  
          4.             prepareRefresh();  
          5.             // Tell the subclass to refresh the internal bean factory.  
          6.             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();  
          7.             // Prepare the bean factory for use in this context.  
          8.             prepareBeanFactory(beanFactory);  
          9.             try {  
          10.                 // Allows post-processing of the bean factory in context subclasses.  
          11.                 postProcessBeanFactory(beanFactory);  
          12.                 // Invoke factory processors registered as beans in the context.  
          13.                 invokeBeanFactoryPostProcessors(beanFactory);  
          14.                 // Register bean processors that intercept bean creation.  
          15.                 registerBeanPostProcessors(beanFactory);  
          16.                 // Initialize message source for this context.  
          17.                 initMessageSource();  
          18.                 // Initialize event multicaster for this context.  
          19.                 initApplicationEventMulticaster();  
          20.                 // Initialize other special beans in specific context subclasses.  
          21.                 onRefresh();  
          22.                 // Check for listener beans and register them.  
          23.                 registerListeners();  
          24.                 // Instantiate all remaining (non-lazy-init) singletons.  
          25.                 finishBeanFactoryInitialization(beanFactory);  
          26.                 // Last step: publish corresponding event.  
          27.                 finishRefresh();  
          28.             }  
          29.             catch (BeansException ex) {  
          30.                 // Destroy already created singletons to avoid dangling resources.  
          31.                 beanFactory.destroySingletons();  
          32.                 // Reset 'active' flag.  
          33.                 cancelRefresh(ex);  
          34.                 // Propagate exception to caller.  
          35.                 throw ex;  
          36.             }  
          37.         }  
          38.     }  
           
          解釋如下：
           

           
           
          Bean 的創建過程
          Bean的創建過程基本是BeanFactory所要完成的事情.
          根據以上過程，將會重點帶著以下兩個個問題來理解核心代碼：
          1.Bean 的創建時機
          bean 是在什么時候被創建的，有哪些規則。
          2.Bean 的創建過程
          bean 是怎么創建的，會選擇哪個構造函數？依賴如何注入？ InitializingBean 的 set 方法什么時候被調用？實現ApplicationContextAware, BeanFactoryAware,BeanNameAware, ResourceLoaderAware 這些接口的 bean 的set 方法何時被調用？
           
          在解釋這兩個問題前，先看一下 BeanDefinition 接口的定義。
            
           
          從該接口定義可以看出，通過 bean 定義能夠得到 bean 的詳細信息，如類名子、工廠類名稱、 scope 、是否單例、是否抽象、是否延遲加載等等。基于此，來看一下以下兩個問題：
           
           
           
           
          問題 1 ： Bean 的創建時機
          bean 是在什么時候被創建的，有哪些規則？
          容器初始化的時候會預先對單例和非延遲加載的對象進行預先初始化。其他的都是延遲加載是在第一次調用getBean 的時候被創建。從 DefaultListableBeanFactory 的 preInstantiateSingletons 里可以看到這個規則的實現。
          Java代碼  收藏代碼
          1. public void preInstantiateSingletons() throws BeansException {  
          2.         if (this.logger.isInfoEnabled()) {  
          3.             this.logger.info("Pre-instantiating singletons in " + this);  
          4.         }  
          5.   
          6.         synchronized (this.beanDefinitionMap) {  
          7.             for (Iterator it = this.beanDefinitionNames.iterator(); it.hasNext();) {  
          8.                 String beanName = (String) it.next();  
          9.                 RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);  
          10.                 <span style="color: #ff0000;">if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {</span>  
          11.   
          12.   
          13.   
          14. //對非抽象、單例的和非延遲加載的對象進行實例化。  
          15.                     if (isFactoryBean(beanName)) {  
          16.                         FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);  
          17.                         if (factory instanceof SmartFactoryBean && ((SmartFactoryBean) factory).isEagerInit()) {  
          18.                             getBean(beanName);  
          19.                         }  
          20.                     }  
          21.                     else {  
          22.                         getBean(beanName);  
          23.                     }  
          24.                 }  
          25.             }  
          26.         }  
          27.     }  
           

           從上面來看對于以下配置，只有 singletonBean 會被預先創建。
          Xml代碼  收藏代碼
          1. <?xml version="1.0" encoding="GB2312"?>  
          2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">  
          3. <beans default-autowire="byName">  
          4.     <bean id="otherBean"          class="com.test.OtherBean" scope="prototype"/>  
          5.     <bean id="myBean"          class="com.test.MyBean" lazy-init="true"/>  
          6.     <bean id="singletonBean"          class="com.test.SingletonBean"/>  
          7. </beans>  
           
           
           
           
          問題二：Bean 的創建過程
          對于 bean 的創建過程其實都是通過調用工廠的 getBean 方法來完成的。這里面將會完成對構造函數的選擇、依賴注入等。
           
          無論預先創建還是延遲加載都是調用getBean實現，AbstractBeanFactory 定義了 getBean 的過程：
          Java代碼  收藏代碼
          1. protected Object doGetBean(  
          2.             final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {  
          3.         final String beanName = transformedBeanName(name);  
          4.         Object bean = null;  
          5.         // Eagerly check singleton cache for manually registered singletons.  
          6.         Object sharedInstance = getSingleton(beanName);  
          7.         if (sharedInstance != null && args == null) {  
          8.             if (logger.isDebugEnabled()) {  
          9.                 if (isSingletonCurrentlyInCreation(beanName)) {  
          10.                     logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +  
          11.                             "' that is not fully initialized yet - a consequence of a circular reference");  
          12.                 }  
          13.                 else {  
          14.                     logger.debug("Returning cached instance of singleton bean '" + beanName + "'");  
          15.                 }  
          16.             }  
          17.             bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);  
          18.         }  
          19.         else {  
          20.             // Fail if we're already creating this bean instance:  
          21.             // We're assumably within a circular reference.  
          22.             if (isPrototypeCurrentlyInCreation(beanName)) {  
          23.                 throw new BeanCurrentlyInCreationException(beanName);  
          24.             }  
          25.   
          26.             // Check if bean definition exists in this factory.  
          27.             BeanFactory parentBeanFactory = getParentBeanFactory();  
          28.             if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {  
          29.                 // Not found -> check parent.  
          30.                 String nameToLookup = originalBeanName(name);  
          31.                 if (args != null) {  
          32.                     // Delegation to parent with explicit args.  
          33.                     return parentBeanFactory.getBean(nameToLookup, args);  
          34.                 }  
          35.                 else {  
          36.                     // No args -> delegate to standard getBean method.  
          37.                     return parentBeanFactory.getBean(nameToLookup, requiredType);  
          38.                 }  
          39.             }  
          40.   
          41.             if (!typeCheckOnly) {  
          42.                 markBeanAsCreated(beanName);  
          43.             }  
          44.   
          45.             final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);  
          46.             checkMergedBeanDefinition(mbd, beanName, args);  
          47.   
          48.             // Guarantee initialization of beans that the current bean depends on.  
          49.             String[] dependsOn = mbd.getDependsOn();  
          50.             if (dependsOn != null) {  
          51.                 for (int i = 0; i < dependsOn.length; i++) {  
          52.                     String dependsOnBean = dependsOn[i];  
          53.                     getBean(dependsOnBean);  
          54.                     registerDependentBean(dependsOnBean, beanName);  
          55.                 }  
          56.             }  
          57.             // Create bean instance.  
          58.             <span style="color: #ff0000;">if (mbd.isSingleton()) {//單例對象創建過程,間接通過getSingleton方法來創建，里面會實現將單例對象緩存</span>  
          59.   
          60.   
          61.   
          62.   
          63.                 sharedInstance = getSingleton(beanName, new ObjectFactory() {  
          64.                     public Object getObject() throws BeansException {  
          65.                         try {  
          66.                             return createBean(beanName, mbd, args);  
          67.                         }  
          68.                         catch (BeansException ex) {  
          69.                             // Explicitly remove instance from singleton cache: It might have been put there  
          70.                             // eagerly by the creation process, to allow for circular reference resolution.  
          71.                             // Also remove any beans that received a temporary reference to the bean.  
          72.                             destroySingleton(beanName);  
          73.                             throw ex;  
          74.                         }  
          75.                     }  
          76.                 });  
          77.                 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);  
          78.             }  
          79.   
          80.             <span style="color: #ff0000;">else if (mbd.isPrototype()) {//非單例對象創建</span>  
          81.   
          82.   
          83.   
          84.   
          85.                 // It's a prototype -> create a new instance.  
          86.                 Object prototypeInstance = null;  
          87.                 try {  
          88.                     beforePrototypeCreation(beanName);  
          89.                     prototypeInstance = createBean(beanName, mbd, args);<span style="color: #ff0000;">//直接調用createBean</span>  
          90.   
          91.   
          92.   
          93.   
          94.                 }  
          95.                 finally {  
          96.                     afterPrototypeCreation(beanName);  
          97.                 }  
          98.                 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);  
          99.             }  
          100.   
          101.             else {  
          102.                 String scopeName = mbd.getScope();  
          103.                 final Scope scope = (Scope) this.scopes.get(scopeName);  
          104.                 if (scope == null) {  
          105.                     throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");  
          106.                 }  
          107.                 try {  
          108.                     Object scopedInstance = scope.get(beanName, new ObjectFactory() {  
          109.                         public Object getObject() throws BeansException {  
          110.                             beforePrototypeCreation(beanName);  
          111.                             try {  
          112.                                 return createBean(beanName, mbd, args);  
          113.                             }  
          114.                             finally {  
          115.                                 afterPrototypeCreation(beanName);  
          116.                             }  
          117.                         }  
          118.                     });  
          119.                     bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);  
          120.                 }  
          121.                 catch (IllegalStateException ex) {  
          122.                     throw new BeanCreationException(beanName,  
          123.                             "Scope '" + scopeName + "' is not active for the current thread; " +  
          124.                             "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",  
          125.                             ex);  
          126.                 }  
          127.             }  
          128.         }  
          129.         // Check if required type matches the type of the actual bean instance.  
          130.         if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {  
          131.             throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());  
          132.         }  
          133.         return bean;  
          134.     }  
           
           
           
           
          GetBean 的大概過程：
          1.       先試著從單例緩存對象里獲取。
          2.       從父容器里取定義，有則由父容器創建。
          3.       如果是單例，則走單例對象的創建過程：在 spring 容器里單例對象和非單例對象的創建過程是一樣的。都會調用父類 AbstractAutowireCapableBeanFactory 的 createBean 方法。 不同的是單例對象只創建一次并且需要緩存起來。 DefaultListableBeanFactory 的父類 DefaultSingletonBeanRegistry 提供了對單例對象緩存等支持工作。所以是單例對象的話會調用 DefaultSingletonBeanRegistry 的 getSingleton 方法，它會間接調用AbstractAutowireCapableBeanFactory 的 createBean 方法。
          如果是 Prototype 多例則直接調用父類 AbstractAutowireCapableBeanFactory 的 createBean 方法。
           
          bean的創建是由AbstractAutowireCapableBeanFactory來定義：
           
          Java代碼  收藏代碼
          1. protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)  
          2.             throws BeanCreationException {  
          3.         AccessControlContext acc = AccessController.getContext();  
          4.         return AccessController.doPrivileged(new PrivilegedAction() {  
          5.             public Object run() {  
          6.                 if (logger.isDebugEnabled()) {  
          7.                     logger.debug("Creating instance of bean '" + beanName + "'");  
          8.                 }  
          9.                 // Make sure bean class is actually resolved at this point.  
          10.                 resolveBeanClass(mbd, beanName);  
          11.                 // Prepare method overrides.  
          12.                 try {  
          13.                     mbd.prepareMethodOverrides();  
          14.                 }  
          15.                 catch (BeanDefinitionValidationException ex) {  
          16.                     throw new BeanDefinitionStoreException(mbd.getResourceDescription(),  
          17.                             beanName, "Validation of method overrides failed", ex);  
          18.                 }  
          19.                 try {  
          20.                     // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.  
          21.                     Object bean = resolveBeforeInstantiation(beanName, mbd);  
          22.                     if (bean != null) {  
          23.                         return bean;  
          24.                     }  
          25.                 }  
          26.                 catch (Throwable ex) {  
          27.                     throw new BeanCreationException(mbd.getResourceDescription(), beanName,  
          28.                             "BeanPostProcessor before instantiation of bean failed", ex);  
          29.                 }  
          30.                 Object beanInstance = doCreateBean(beanName, mbd, args);  
          31.                 if (logger.isDebugEnabled()) {  
          32.                     logger.debug("Finished creating instance of bean '" + beanName + "'");  
          33.                 }  
          34.                 return beanInstance;  
          35.             }  
          36.         }, acc);  
          37.     }  
           
          createBean 會調用 doCreateBean 方法：
           
          Java代碼  收藏代碼
          1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {  
          2.         // Instantiate the bean.  
          3.         BeanWrapper instanceWrapper = null;  
          4.         if (mbd.isSingleton()) {  
          5.             instanceWrapper = (BeanWrapper) this.factoryBeanInstanceCache.remove(beanName);  
          6.         }  
          7.         if (instanceWrapper == null) {  
          8.             instanceWrapper = createBeanInstance(beanName, mbd, args);  
          9.         }  
          10.         final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);  
          11.         Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);  
          12.   
          13.         // Allow post-processors to modify the merged bean definition.  
          14.         synchronized (mbd.postProcessingLock) {  
          15.             if (!mbd.postProcessed) {  
          16.                 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);  
          17.                 mbd.postProcessed = true;  
          18.             }  
          19.         }  
          20.   
          21.         // Eagerly cache singletons to be able to resolve circular references  
          22.         // even when triggered by lifecycle interfaces like BeanFactoryAware.  
          23.         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&  
          24.                 isSingletonCurrentlyInCreation(beanName));  
          25.         if (earlySingletonExposure) {  
          26.             if (logger.isDebugEnabled()) {  
          27.                 logger.debug("Eagerly caching bean '" + beanName +  
          28.                         "' to allow for resolving potential circular references");  
          29.             }  
          30.             addSingletonFactory(beanName, new ObjectFactory() {  
          31.                 public Object getObject() throws BeansException {  
          32.                     return getEarlyBeanReference(beanName, mbd, bean);  
          33.                 }  
          34.             });  
          35.         }  
          36.         // Initialize the bean instance.  
          37.         Object exposedObject = bean;  
          38.         try {  
          39.             populateBean(beanName, mbd, instanceWrapper);  
          40.             exposedObject = initializeBean(beanName, exposedObject, mbd);  
          41.         }  
          42.         catch (Throwable ex) {  
          43.             if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {  
          44.                 throw (BeanCreationException) ex;  
          45.             }  
          46.             else {  
          47.                 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);  
          48.             }  
          49.         }  
          50.         if (earlySingletonExposure) {  
          51.             Object earlySingletonReference = getSingleton(beanName, false);  
          52.             if (earlySingletonReference != null) {  
          53.                 if (exposedObject == bean) {  
          54.                     exposedObject = earlySingletonReference;  
          55.                 }  
          56.                 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {  
          57.                     String[] dependentBeans = getDependentBeans(beanName);  
          58.                     Set actualDependentBeans = new LinkedHashSet(dependentBeans.length);  
          59.                     for (int i = 0; i < dependentBeans.length; i++) {  
          60.                         String dependentBean = dependentBeans[i];  
          61.                         if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {                         actualDependentBeans.add(dependentBean);  
          62.                         }  
          63.                     }  
          64.                     if (!actualDependentBeans.isEmpty()) {  
          65.                         throw new BeanCurrentlyInCreationException(beanName,  
          66.                                 "Bean with name '" + beanName + "' has been injected into other beans [" +  
          67.                                 StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +  
          68.                                 "] in its raw version as part of a circular reference, but has eventually been " +  
          69.                                 "wrapped. This means that said other beans do not use the final version of the " +  
          70.                                 "bean. This is often the result of over-eager type matching - consider using " +  
          71.                                 "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");  
          72.                     }  
          73.                 }  
          74.             }  
          75.         }  
          76.         // Register bean as disposable.  
          77.         registerDisposableBeanIfNecessary(beanName, bean, mbd);  
          78.         return exposedObject;  
          79.     }  
           
           
          doCreateBean 的流程：
          1.     會創建一個 BeanWrapper 對象 用于存放實例化對象。
          2.     如果沒有指定構造函數，會通過反射拿到一個默認的構造函數對象，并賦予beanDefinition.resolvedConstructorOrFactoryMethod 。
          3.     調用 spring 的 BeanUtils 的 instantiateClass 方法，通過反射創建對象。
          4.     applyMergedBeanDefinitionPostProcessors
          5.     populateBean(beanName, mbd, instanceWrapper); 根據注入方式進行注入。根據是否有依賴檢查進行依賴檢查。
          執行 bean 的注入里面會選擇注入類型：
          Java代碼  收藏代碼
          1. if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||  
          2.                 mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {  
          3.             MutablePropertyValues newPvs = new MutablePropertyValues(pvs);  
          4.   
          5.             // Add property values based on autowire by name if applicable.  
          6.             if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {  
          7.                 autowireByName(beanName, mbd, bw, newPvs);  
          8.             }<span style="color: #ff0000;">//根據名字注入</span>  
          9.   
          10.   
          11.   
          12.   
          13.   
          14.             // Add property values based on autowire by type if applicable.  
          15.             if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {  
          16.                 autowireByType(beanName, mbd, bw, newPvs);  
          17.             }<span style="color: #ff0000;">//根據類型注入</span>  
          18.   
          19.   
          20.   
          21.   
          22.   
          23.             pvs = newPvs;  
          24.         }  
           
          6.      initializeBean(beanName, exposedObject, mbd);
          判斷是否實現了 BeanNameAware 、 BeanClassLoaderAware 等 spring 提供的接口，如果實現了，進行默認的注入。同時判斷是否實現了 InitializingBean 接口，如果是的話，調用 afterPropertySet 方法。
           
          Java代碼  收藏代碼
          1. protected Object initializeBean(String beanName, Object bean, RootBeanDefinition mbd) {  
          2.         if (bean instanceof BeanNameAware) {  
          3.             ((BeanNameAware) bean).setBeanName(beanName);  
          4.         }  
          5.         if (bean instanceof BeanClassLoaderAware) {  
          6.             ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());  
          7.         }  
          8.         if (bean instanceof BeanFactoryAware) {  
          9.             ((BeanFactoryAware) bean).setBeanFactory(this);  
          10.         }  
          11.         Object wrappedBean = bean;  
          12.         if (mbd == null || !mbd.isSynthetic()) {  
          13.             wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);  
          14.         }  
          15. <span style="color: #ff0000;">      try {  
          16.             invokeInitMethods(beanName, wrappedBean, mbd);  
          17.         }</span>  
          18.   
          19.   
          20.   
          21.   
          22.         catch (Throwable ex) {  
          23.             throw new BeanCreationException(  
          24.                     (mbd != null ? mbd.getResourceDescription() : null),  
          25.                     beanName, "Invocation of init method failed", ex);  
          26.         }  
          27.   
          28.         if (mbd == null || !mbd.isSynthetic()) {  
          29.             wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);  
          30.         }  
          31.         return wrappedBean;  
          32.     }  
           其中invokeInitMethods實現如下：
          Java代碼  收藏代碼
          1. protected void invokeInitMethods(String beanName, Object bean, RootBeanDefinition mbd)  
          2.         throws Throwable {  
          3.   
          4.     boolean isInitializingBean = (bean instanceof InitializingBean);  
          5.     if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {  
          6.         if (logger.isDebugEnabled()) {  
          7.             logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");  
          8.         }  
          9.         ((InitializingBean) bean).afterPropertiesSet();<span style="color: #ff0000;">//調用afterPropertiesSet方法</span>  
          10.   
          11.   
          12.   
          13.   
          14.     }  
          15.   
          16.     String initMethodName = (mbd != null ? mbd.getInitMethodName() : null);  
          17.     if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&  
          18.             !mbd.isExternallyManagedInitMethod(initMethodName)) {  
          19.         invokeCustomInitMethod(beanName, bean, initMethodName, mbd.isEnforceInitMethod());  
          20.     }  
          21. }  
           
           
           
          總結
          以上基本描述了 spring 容器的初始化過程和 bean 的創建過程。主要還是從大處著眼，很多細節沒有涉及到。代碼閱讀總體感覺就是 spring 的代碼抽象很好，結合結構讀起來還是蠻順利的。后面的學習將從細節著手。
          下面源碼學習預告：
          1.       Spring 的聲明式標簽如實現
          2.       Spring aop 代理如何實現
          
	
          
	
	
          
		posted on 2013-02-28 11:04 brock 閱讀(826) 評論(0)  編輯  收藏  所屬分類: 學習總結 
	
          

          







          
	    
    




          








          

				

          




    







          
        
	




主站蜘蛛池模板：
炎陵县|
凌源市|
鄂州市|
新郑市|
静海县|
三台县|
赣州市|
靖安县|
汉沽区|
芦溪县|
临澧县|
彰化市|
沙雅县|
荥阳市|
白水县|
保亭|
共和县|
板桥市|
蒙山县|
商城县|
凤阳县|
沧州市|
和静县|
安福县|
西畴县|
靖安县|
拉萨市|
晴隆县|
博兴县|
武清区|
遂川县|
安岳县|
土默特左旗|
原平市|
巧家县|
区。|
渭源县|
苏尼特左旗|
九寨沟县|
贵南县|
湟中县|