今天开始跟大家一起进入spring源码阅读阶段,我们将从一个大家比较熟悉的高级容器-ClassPathXmlApplicationContext为入口去了解spring容器的加载过程。
ClassPathXmlApplicationContext有许多构造函数,我们找到真的调用的入口。 复制代码
public ClassPathXmlApplicationContext(String[] paths, Class<?> clazz, @Nullable ApplicationContext parent) throws BeansException { //加载容器前的一些处理 super(parent); Assert.notNull(paths, "Path array must not be null"); Assert.notNull(clazz, "Class argument must not be null"); this.configResources = new Resource[paths.length]; for (int i = 0; i < paths.length; i++) { this.configResources[i] = new ClassPathResource(paths[i], clazz); } //真正开始加载容器的方法 refresh(); } 复制代码
这个构造函数中,我们只需要关注最后一个方法refresh(),这个才是容器加载的入口,下面我们跟进去看下具体的内容。
public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { // Prepare this context for refreshing. //刷新容器前的预处理,包括删除旧容器等 prepareRefresh(); // Tell the subclass to refresh the internal bean factory. // 创建bean工厂 // 加载解析XML文件,并完成BeanDefinition的加载和注册 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // 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); // Initialize message source for this context. initMessageSource(); // Initialize event multicaster for this context. initApplicationEventMulticaster(); // Initialize other special beans in specific context subclasses. onRefresh(); // Check for listener beans and register them. registerListeners(); // Instantiate all remaining (non-lazy-init) singletons. // 实例化剩余的单例bean(非懒加载方式) // Bean的IoC、DI和AOP都是发生在这个过程中 finishBeanFactoryInitialization(beanFactory); // Last step: publish corresponding event. finishRefresh(); } 。。。。。 } 复制代码
spring容器的加载有多个步骤,我们主要关系里面的两个步骤
而剩余的其他步骤,主要初始哈一些BeanPostProcessor,然括对BeanDefinition的一些处理,初始化一些特殊的bean,然后注册监听器,最后广播加载完成的消息等一些功能。这些功能分支,大家有兴趣的可以自己进行了解,在这里就不一一详细说明了。今天,我们主要是来看springBean的加载,及初始化流程。也就是,我们主要看finishBeanFactoryInitialization该方法完成的内容。
下面我们就接着看finishBeanFactoryInitialization这个方法到底完成了些什么事情:
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { 。。。。。。。。。 // Instantiate all remaining (non-lazy-init) singletons. // 完成单例Bean的初始化 beanFactory.preInstantiateSingletons(); } 复制代码
这个方法前面的一些内容我们并不需要太多关注,我们看到方法最后,这个preInstantiateSingletons()就是实例化我们单例bean的入口:
public void preInstantiateSingletons() throws BeansException { if (this.logger.isDebugEnabled()) { this.logger.debug("Pre-instantiating singletons in " + this); } // Iterate over a copy to allow for init methods which in turn register new bean definitions. // While this may not be part of the regular factory bootstrap, it does otherwise work fine. List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); // Trigger initialization of all non-lazy singleton beans... // 加载所有非懒加载方式的单例bena for (String beanName : beanNames) { RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { if (isFactoryBean(beanName)) { Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); if (bean instanceof FactoryBean) { final FactoryBean<?> factory = (FactoryBean<?>) bean; boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext()); } else { isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } if (isEagerInit) { getBean(beanName); } } } else { // 普通bean走下面的方法 getBean(beanName); } } } 复制代码
我们来一步步看下这个方法
接着我们顺着getBean方法往下点,最终会来到AbstractBeanFactory中真正创建bean的doCreateBean方法
这里面的代码很长,在这里我们就不贴出来了,大家跟着我的思路往下看就可以了 *
Object sharedInstance = getSingleton(beanName); 复制代码
首先我们看到句代码,这个其实是从spring的缓存容器中获取bean对象,spring容器中一共有三层缓存,一级缓存就是存放spring加载完成的bean对象。而二三级缓存主要是为了解决spring中的循环依赖这个问题(这个问题比较重要,我们后面会在具体的说明这个问题)。
// 从一级缓存也就是map容器中获取对象 Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { synchronized (this.singletonObjects) { // 从二级缓存中尝试获取单例bean singletonObject = this.earlySingletonObjects.get(beanName); // allowEarlyReference //是否允许从三级缓存中获取对象就是是否允许循环依赖 if (singletonObject == null && allowEarlyReference) { //尝试从三级缓存中获取单例bean ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) { //通过单例工厂获取单例bean singletonObject = singletonFactory.getObject(); //将bean放到二级缓存 this.earlySingletonObjects.put(beanName, singletonObject); //将bean从三级缓存中删除 this.singletonFactories.remove(beanName); } } } } return singletonObject; 复制代码
这个就是获取单例bean的过程,其中三级缓存中存放的是bean的工厂对象。
接着我们继续看doCreateBean下面的代码
if (mbd.isSingleton()) { sharedInstance = getSingletion(beanName, () -> { try { // 创建单例Bean的主要方法 return createBean(beanName, mbd, args); } catch (BeansException ex) { // Explicitly remove instance from singleton cache: It might have been put there // eagerly by the creation process, to allow for circular reference resolution. // Also remove any beans that received a temporary reference to the bean. destroySingleton(beanName); throw ex; } }); bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } 复制代码
singletonObject = singletonFactory.getObject(); newSingleton = true; 复制代码
这个getObject()方法真正的实现是之前的这个createBean(beanName, mbd, args); 这个方法是真正去创建一个bean的方法。这个我们等下在看。 这个getSingletion方法的最后就是将创建好的bean加入到map容器中,同时删除二三级缓存
addSingleton(beanName, singletonObject); 复制代码
protected void addSingleton(String beanName, Object singletonObject) { synchronized (this.singletonObjects) { // 加入到一级缓存 this.singletonObjects.put(beanName, singletonObject); // 删除三级缓存 this.singletonFactories.remove(beanName); // 删除二级缓存 this.earlySingletonObjects.remove(beanName); // 将beanName加入到已经创建的beanName集合中 this.registeredSingletons.add(beanName); } } 复制代码
现在我们就去看下最后一个creatBean这个创建bean的方法
。。。。 try { // 完成Bean实例的创建包括-实例化,依赖注入(填充属性值),初始化(调用初始化方法) Object beanInstance = doCreateBean(beanName, mbdToUse, args); if (logger.isDebugEnabled()) { logger.debug("Finished creating instance of bean '" + beanName + "'"); } return beanInstance; } 。。。 复制代码
里面我们关注这个doCreateBean(),我们接着往下找,终于来到了具体创建bean的代码,这代码有点长,我们截取一些片段
// Instantiate the bean. 。。。 //1. 实例化bean对象 if (instanceWrapper == null) { instanceWrapper = createBeanInstance(beanName, mbd, args); } //实例化后的Bean对象 。。。。。 // Eagerly cache singletons to be able to resolve circular references // even when triggered by lifecycle interfaces like BeanFactoryAware. // 如果该对象是单例的,允许循环依赖,且正在创建中 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); // 为解决循环依赖提前暴露单例Bean,将该Bean放入三级缓存中 if (earlySingletonExposure) { if (logger.isDebugEnabled()) { logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } // 把刚创建的bean放入三级缓存中 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } // Initialize the bean instance. Object exposedObject = bean; try { // 属性填充也就是DI的过程 populateBean(beanName, mbd, instanceWrapper); //调用初始化方法,完成初始化操作 exposedObject = initializeBean(beanName, exposedObject, mbd); } 。。。。。。。 return exposedObject; 复制代码
这里面主要可以分成三步
至此,我们已经看完了springIOC的主要加载流程,我们主要对bean的创建过程进行了解读,知道了bean是如何创建出来并加入到容器中。而这里也剩下一个循环依赖的问题,及属性填充的过程我们还没有进行理解和阅读,这两个问题我们留到下面的文章为大家讲解,希望大家多多关注,谢谢阅读。复制代码