Spring源碼分析之 lazy-init 實現原理

  普通的bean的初始化是在容器啓動初始化階段執行的,而被lazy-init修飾的bean 則是在從容器裏第一次進行context.getBean(「」)時進行觸發。Spring 啓動的時候會把全部bean信息(包括XML和註解)解析轉化成Spring可以識別的BeanDefinition並存到Hashmap裏供下面的初始化時用。接下來對每一個BeanDefinition進行處理,若是是懶加載的則在容器初始化階段不處理,其餘的則在容器初始化階段進行初始化並依賴注入。

本文我說了不少次 Spring 容器初始化bean初始化,容器的初始化有可能包括bean的初始化主要取決於該bean是不是懶加載的,特此說明怕誤會 。。。:)spring

一.先睹爲快
話很少說先寫個例子看下這屬性到底有什麼做用,咱們定義了一個叫作coffee的普通bean,代碼以下:
1.普通非懶加載bean的演示
1 package com.test.spring;
2 
3 public class Coffee {
4 
5     public Coffee() {
6         System.out.println("正在初始化bean !!!調用無參構造函數");
7     }
8     
9 }複製代碼
<bean name="coffee" class="com.test.spring.Coffee"/>複製代碼

1 @Test
 2 public void testLazyInit() {
 3 
 4     System.out.println("開始初始化Spring容器 ");
 5     // 非懶加載的bean會在容器初始化時進行bean的初始化,後面會拿Spring啓動時的源碼進行分析
 6     ApplicationContext context = new ClassPathXmlApplicationContext("spring-beans.xml");
 7    // 非懶加載的bean 的構造函數會在這個位置打印
 8     System.out.println("Spring容器初始化完畢");
 9     
10    System.out.println("開始從容器中獲取Bean");
11 
12    Coffee coffee = context.getBean("coffee", Coffee.class);
13 
14    System.out.println("獲取完畢 bean :" + coffee);
15 }複製代碼
運行結果以下:
2.非懶加載bean的演示
<bean name="coffee" class="com.test.spring.Coffee" lazy-init="true" />複製代碼

@Test
    public void testLazyInit() {

        System.out.println("開始初始化Spring容器 ");
     // 在初始化容器階段不會對懶加載的bean進行初始化
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-beans.xml");
  
        System.out.println("Spring容器初始化完畢");

        System.out.println("開始從容器中獲取Bean");
     // 在這一階段會對懶加載的bean進行初始化
        Coffee coffee = context.getBean("coffee", Coffee.class);

        System.out.println("獲取完畢 bean :" + coffee);


    }複製代碼

運行結果以下:緩存


二,原理分析bash

Spring 啓動時主要幹倆件事  1.初始化容器 2.對bean進行初始化並依賴注入。(懶加載的bean不作第二件)ide

可是對於大多數bean來講,bean的初始化以及依賴注入就是在容器初始化階段進行的,只有懶加載的bean是當應用程序第一次進行getBean時進行初始化並依賴注入。下面貼出代碼看下函數


Spring 容器初始化代碼以下就一行:post

ApplicationContext context = new ClassPathXmlApplicationContext("spring-beans.xml");
複製代碼

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
            throws BeansException {

        super(parent);
        setConfigLocations(configLocations);
        if (refresh) {
            // Spring ioc 啓動入口 瞭解了refresh 就瞭解了ioc
            refresh();
        }
    }複製代碼

Spring 初始化入口 refresh(省略了部分根本次無關的代碼,望理解,太長了影響閱讀體驗)ui

1 public void refresh() throws BeansException, IllegalStateException {
 2         synchronized (this.startupShutdownMonitor) {
 3             // Prepare this context for refreshing.
 4             prepareRefresh();
 5 
 6             // Prepare the bean factory for use in this context.
 7             prepareBeanFactory(beanFactory);
 8 
 9             try {
10                 // Allows post-processing of the bean factory in context subclasses.
11                 postProcessBeanFactory(beanFactory);
12 
13                 // Invoke factory processors registered as beans in the context.
14                 invokeBeanFactoryPostProcessors(beanFactory);
15 
16                 // Register bean processors that intercept bean creation.
17                 registerBeanPostProcessors(beanFactory);
18                 // Instantiate all remaining (non-lazy-init) singletons.
19                 // 初始化全部非 懶加載的bean!!!!
20                 finishBeanFactoryInitialization(beanFactory);
21 
22                 // Last step: publish corresponding event.
23                 finishRefresh();
24                 }catch(){}
            }
25  }複製代碼

第20行則是跟本次主題有關的,就是說在容器啓動的時候 只處理 non-lazy-init bean,懶加載的bean在Spring啓動階段根本不作任何處理下面看下源碼就明白了this

點進去第20行的finishBeanFactoryInitialization(beanFactory)裏頭有個初始化non-lazy-init bean的函數 preInstantiateSingletons()spa

具體邏輯以下
code

1.對beanNames 集合遍歷獲取每一個BeanDefinition

2.判斷是不是懶加載的,若是不是則繼續處理(non-lazy-init bean 不作處理)

3.判斷是不是factorybean 若是不是則進行實例化並依賴注入


public void preInstantiateSingletons() throws BeansException {
   // 全部beanDefinition集合
   List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
   // 觸發全部非懶加載單例bean的初始化
   for (String beanName : beanNames) {
       // 獲取bean 定義
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      // 判斷是不是懶加載單例bean,若是是單例的而且不是懶加載的則在Spring 容器
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
          // 判斷是不是FactoryBean
         if (isFactoryBean(beanName)) {
                final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                boolean isEagerInit;
                if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                   isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                      @Override
                      public Boolean run() {
                         return ((SmartFactoryBean<?>) factory).isEagerInit();
                      }
                   }, getAccessControlContext());
                }
         }else {
             // 若是是普通bean則進行初始化依賴注入,此 getBean(beanName)接下來觸發的邏輯跟
             // context.getBean("beanName") 所觸發的邏輯是同樣的
            getBean(beanName);
         }
      }
   }
}複製代碼

getBean() 方法是實現bean 初始化以及依賴注入的函數

@Override
public Object getBean(String name) throws BeansException {   
    return doGetBean(name, null, null, false);
}複製代碼


三,總結

對於被修飾爲lazy-init的bean Spring初始化階段不會進行init而且依賴注入,當第一次進行getBean時候進行初始化並依賴注入

對於非懶加載的bean getBean的時候會從緩存裏頭取 由於容器初始化階段已經初始化了

// 容器啓動初始化 會初始化並依賴注入非懶加載的bean
1    ApplicationContext context = new ClassPathXmlApplicationContext("spring-beans.xml");
     // lazy-init bean會進行第一次初始化並依賴注入  其餘的會從緩存裏取
2    Coffee coffee = context.getBean("coffee", Coffee.class);複製代碼
相關文章
相關標籤/搜索