普通的bean的初始化是在容器啟動初始化階段執行的，而被lazy-init修飾的bean 則是在從容器裡第一次進行context.getBean(“”)時進行觸發。
Spring 啟動的時候會把所有bean資訊(包括XML和註解)解析轉化成Spring能夠識別的BeanDefinition並存到Hashmap裡供下面的初始化時用。
接下來對每個BeanDefinition進行處理，如果是懶載入的則在容器初始化階段不處理，其他的則在容器初始化階段進行初始化並依賴注入。
本文我說了很多次 Spring 容器初始化和bean初始化， 容器的初始化有可能包括bean的初始化主要取決於該bean是否是懶載入的，特此說明怕誤會 。。。

一.先睹為快

話不多說先寫個例子看下這屬性到底有什麼作用，我們定義了一個叫做coffee的普通bean,程式碼如下：

1.普通非懶載入bean的演示

package com.test.spring;

public class Coffee {

    public Coffee() {
        System.out.println("正在初始化bean !!!呼叫無參建構函式");
    }

}

<bean name="coffee" class="com.test.spring.Coffee"/>

@Test
public void testLazyInit() {

    System.out.println("開始初始化Spring容器 ");
    
    // 非懶載入的bean會在容器初始化時進行bean的初始化，後面會拿Spring啟動時的原始碼進行分析
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-beans.xml");
    
   // 非懶載入的bean 的建構函式會在這個位置列印
   System.out.println("Spring容器初始化完畢");

   System.out.println("開始從容器中獲取Bean");

   Coffee coffee = context.getBean("coffee", Coffee.class);

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

執行結果如下：

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);

}

執行結果如下：

二、原理分析

Spring 啟動時主要幹倆件事 :

1.初始化容器

2.對bean進行初始化並依賴注入。（懶載入的bean不做第二件）

但是對於大多數bean來說，bean的初始化以及依賴注入就是在容器初始化階段進行的，只有懶載入的bean是當應用程式第一次進行getBean時進行初始化並依賴注入。
下面貼出程式碼看下
Spring 容器初始化程式碼如下就一行：

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（省略了部分根本次無關的程式碼，望理解，太長了影響閱讀體驗）

[public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        prepareRefresh();

        // Prepare the bean factory for use in this context.
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            postProcessBeanFactory(beanFactory);

            // Invoke factory processors registered as beans in the context.
            invokeBeanFactoryPostProcessors(beanFactory);

            // Register bean processors that intercept bean creation.
            registerBeanPostProcessors(beanFactory);
            // Instantiate all remaining (non-lazy-init) singletons.
            // 初始化所有非 懶載入的bean！！！！
            finishBeanFactoryInitialization(beanFactory);

            // Last step: publish corresponding event.
            finishRefresh();
        }
 }](http://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247492186&idx=3&sn=cbb8fda8f97f28a24939134e711b51a9&chksm=eb50676cdc27ee7afead02ae8c3c0fb6611681c119fa0b3f6dac238676aeb2660a9d77dde392&scene=21#wechat_redirect)

第20行則是跟本次主題有關的，就是說在容器啟動的時候只處理non-lazy-init bean，懶載入的bean在Spring啟動階段根本不做任何處理下面看下原始碼就明白了
點進去第20行的finishBeanFactoryInitialization(beanFactory)裡頭有個初始化non-lazy-init bean的函式 preInstantiateSingletons()
具體邏輯如下

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
ApplicationContext context = new ClassPathXmlApplicationContext("spring-beans.xml");

// lazy-init bean會進行第一次初始化並依賴注入  其他的會從快取裡取
Coffee coffee = context.getBean("coffee", Coffee.class);

來源：小小木的部落格
www.cnblogs.com/wyc1994666/p/10569091.html