Spring源码分析之 lazy-init 实现原理

　　普通的bean的初始化是在容器启动初始化阶段执行的，而被lazy-init修饰的bean 则是在从容器里第一次进行context.getBean(“”)时进行触发。Spring 启动的时候会把全部bean信息(包括XML和注解)解析转化成Spring可以识别的BeanDefinition并存到Hashmap里供下面的初始化时用。接下来对每一个BeanDefinition进行处理，若是是懒加载的则在容器初始化阶段不处理，其余的则在容器初始化阶段进行初始化并依赖注入。

本文我说了不少次 Spring 容器初始化和bean初始化，容器的初始化有可能包括bean的初始化主要取决于该bean是不是懒加载的，特此说明怕误会 。。。:)

一.先睹为快

话很少说先写个例子看下这属性到底有什么做用，咱们定义了一个叫作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);


    }复制代码

运行结果以下：

二，原理分析

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（省略了部分根本次无关的代码，望理解，太长了影响阅读体验）

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启动阶段根本不作任何处理下面看下源码就明白了

点进去第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
1    ApplicationContext context = new ClassPathXmlApplicationContext("spring-beans.xml");
     // lazy-init bean会进行第一次初始化并依赖注入  其余的会从缓存里取
2    Coffee coffee = context.getBean("coffee", Coffee.class);复制代码