本文我说了很多次 Spring 容器初始化和bean初始化,容器的初始化有可能包括bean的初始化主要取决于该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 }
<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 } 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 初始化以及依赖注入的函数
1 @Override 2 public Object getBean(String name) throws BeansException { 3 return doGetBean(name, null, null, false); 4 }
三,总结
对于被修饰为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);