深入理解Spring IOC源码分析
Spring容器初始化
本文使用的是Spring 5.1.7版本
写在前面:我们看源码一般有3种方式。
- 第一种直接用class文件,IDEA会帮我们反编译成看得懂的java代码
- 第二种是用maven的download Sources
- 第三种是直接下载源码编译
如果随便看看,那么第二种就行了。如果想仔细研究,可以选第三种,这样可以给代码加注释,或者修改一些东西等等。
Spring源码构建
- 下载源码(github)
- 安装gradle
- 导入项目
- 编译工程(顺序:core->xom->context->beans->aspects->aop)
- 编译方法:工程->tasks->compileTestJava
- 编译完成后,新建一个测试module,用gradle的方式,build.gradle为:
group 'org.springframework' version '5.1.21.BUILD-SNAPSHOT' apply plugin: 'java' sourceCompatibility = 1.8 repositories { mavenCentral() } dependencies { compile(project(":spring-context")) testCompile group: 'junit', name: 'junit', version: '4.12' }
如果运行报错,需要设置IDEA。 需要将Preferences > Build, Execution, Deployment > Build Tools > Gradle > Runner里的 Delegate IDE build/run actions to gradle勾选上。
Spring IOC容器初始化的关键环节就在AbstractApplicationContext的refresh方法中。
public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { //第一步:刷新前的预处理 prepareRefresh(); // 第二步:获取BeanFactory;加载BeanDefition并注册到BeanDefitionRegistry ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // 第三步:BeanFactory的预准备工作 prepareBeanFactory(beanFactory); try { // 第四步:BeanFactory准备工作完成之后进行的后置处理 postProcessBeanFactory(beanFactory); // 第五步:实例化并调用实现了BeanFactoryPostProcessor接口的Bean invokeBeanFactoryPostProcessors(beanFactory); // 第六步:注册BeanPostProcessor,在创建bean的前后等执行。 registerBeanPostProcessors(beanFactory); // 第七步:初始化MessageSource组件(做国际化功能;消息绑定,消息解析) initMessageSource(); // 第八步:初始化事件派发器 initApplicationEventMulticaster(); //第九步:提供给子类重写,容器刷新的适合可以自定义逻辑 onRefresh(); // 第十步:注册应用监听器。就是注册实现了ApplicationListener接口的监听器bean registerListeners(); // 第十一步:初始化所有剩下的非懒加载的单例bean, //填充属性 //初始化方法调用 //调用BeanPostProcessor对bean进行后置处理 finishBeanFactoryInitialization(beanFactory); // 第十二步:完成context的刷新。主要是调用LifecycleProcessor的onRefresh方法,并且发布ContextRefreshedEvent事件 finishRefresh(); } catch (BeansException ex) { if (logger.isWarnEnabled()) { logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex); } // Destroy already created singletons to avoid dangling resources. destroyBeans(); // Reset 'active' flag. cancelRefresh(ex); // Propagate exception to caller. throw ex; } finally { // Reset common introspection caches in Spring's core, since we // might not ever need metadata for singleton beans anymore... resetCommonCaches(); } } }
接下来我们分析第二步中的两个子流程:
2.1. 获取BeanFactory子流程
时序图如下:
2.2. BeanDefinition加载解析及注册⼦流程
BeanDefinition加载流程入口在AbstractRefreshableApplicationContext#refreshBeanFactory ⽅法中,会调用到loadBeanDefinitions方法,这个方法最终会由XmlBeanDefinitionReader的loadBeanDefinitions方法来完成。然后会调用它自己的doLoadBeanDefinitions方法。
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException { try { //读取xml信息,将xml信息保存到Document中 Document doc = doLoadDocument(inputSource, resource); //解析doc,封装到BeanDefinition对象并进行注册 int count = registerBeanDefinitions(doc, resource); if (logger.isDebugEnabled()) { logger.debug("Loaded " + count + " bean definitions from " + resource); } return count; } //省略部分代码....
继续跟踪registerBeanDefinitions方法。
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader(); //获取已有的BeanDefinition的数量 int countBefore = getRegistry().getBeanDefinitionCount(); //注册BeanDefinitions documentReader.registerBeanDefinitions(doc, createReaderContext(resource)); //返回新注册的BeanDefinition的数量 return getRegistry().getBeanDefinitionCount() - countBefore; }
它又交由documentReader来执行registerBeanDefinitions方法。documentReader接收后调用本类的doRegisterBeanDefinitions来执行。这个方法里我们需要关注parseBeanDefinitions.preProcessXml和postProcessXml都是留给子类实现的。
protected void doRegisterBeanDefinitions(Element root) { //省略部分代码... preProcessXml(root); parseBeanDefinitions(root, this.delegate); postProcessXml(root); this.delegate = parent; }
跟踪parseBeanDefinitions方法,可以看到由DefaultBeanDefinitionDocumentReader#parseDefaultElement在进行解析
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) { //import处理 if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) { importBeanDefinitionResource(ele); } //alias处理 else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { processAliasRegistration(ele); } //解析bean元素 else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { processBeanDefinition(ele, delegate); } //嵌套bean处理 else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { // recurse doRegisterBeanDefinitions(ele); } }
最后跟踪processBeanDefinition的代码
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) { //解析bean元素为BeanDefinition,但是此时使用BeanDefinitionHolder又包装了一层 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); if (bdHolder != null) { bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); try { // 完成BeanDefinition的注册 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); } catch (BeanDefinitionStoreException ex) { getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, ex); } // Send registration event. getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder)); } }
到这里就完成了BeanDefinition的注册。我们发现,所谓的注册就是把 XML 中定义的Bean信息封装为BeanDefinition对象之后放⼊⼀个Map中。
this.beanDefinitionMap.put(beanName, beanDefinition);
简略的时序图如下:
接下来我们分析一下Bean创建的流程。Bean创建是在refresh主流程中的第十一步里面。
11.1 Bean创建子流程
我们进入finishBeanFactoryInitialization方法。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { //省略部分代码... String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); for (String weaverAwareName : weaverAwareNames) { getBean(weaverAwareName); } // Stop using the temporary ClassLoader for type matching. beanFactory.setTempClassLoader(null); // Allow for caching all bean definition metadata, not expecting further changes. beanFactory.freezeConfiguration(); // 实例化所有非懒加载的bean beanFactory.preInstantiateSingletons(); }
跟踪preInstantiateSingletons方法
public void preInstantiateSingletons() throws BeansException { if (logger.isTraceEnabled()) { logger.trace("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); // 遍历所有的beanName for (String beanName : beanNames) { RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { //如果是工厂bean,即实现了FactoryBean接口 if (isFactoryBean(beanName)) { Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); if (bean instanceof FactoryBean) { 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); } } } //省略... }
我们发现不管是工厂Bean,还是普通Bean都会调用getBean(beanName);方法。然后调用到doGetBean方法。
protected <T> T doGetBean( String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException { String beanName = transformedBeanName(name); Object bean; // 从缓存中拿 Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { if (logger.isTraceEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"); } else { logger.trace("Returning cached instance of singleton bean '" + beanName + "'"); } } bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { //如果已经有创建过程中的同beanName的bean,抛异常 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // 从parentBeanFactory里找对应的bean BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. String nameToLookup = originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { return ((AbstractBeanFactory) parentBeanFactory).doGetBean( nameToLookup, requiredType, args, typeCheckOnly); } else if (args != null) { // Delegation to parent with explicit args. return (T) parentBeanFactory.getBean(nameToLookup, args); } else if (requiredType != null) { // No args -> delegate to standard getBean method. return parentBeanFactory.getBean(nameToLookup, requiredType); } else { return (T) parentBeanFactory.getBean(nameToLookup); } } if (!typeCheckOnly) { //打一个已创建的标记 markBeanAsCreated(beanName); } try { RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); checkMergedBeanDefinition(mbd, beanName, args); // 保证当前bean所依赖的bean的初始化 String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { for (String dep : dependsOn) { if (isDependent(beanName, dep)) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } registerDependentBean(dep, beanName); try { getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex); } } } //创建bean // 单例bean if (mbd.isSingleton()) { sharedInstance = getSingleton(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); } //多例bean else if (mbd.isPrototype()) { // It's a prototype -> create a new instance. Object prototypeInstance = null; try { beforePrototypeCreation(beanName); prototypeInstance = createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } else { String scopeName = mbd.getScope(); if (!StringUtils.hasLength(scopeName)) { throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'"); } Scope scope = this.scopes.get(scopeName); if (scope == null) { throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); } try { Object scopedInstance = scope.get(beanName, () -> { beforePrototypeCreation(beanName); try { return createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } }); bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); } catch (IllegalStateException ex) { throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider " + "defining a scoped proxy for this bean if you intend to refer to it from a singleton", ex); } } } catch (BeansException ex) { cleanupAfterBeanCreationFailure(beanName); throw ex; } } // 检查所需类型是否与实际bean实例的类型匹配。 if (requiredType != null && !requiredType.isInstance(bean)) { try { T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType); if (convertedBean == null) { throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } return convertedBean; } catch (TypeMismatchException ex) { if (logger.isTraceEnabled()) { logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", ex); } throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } } return (T) bean; }
可以看到经过一些判断和校验,会调createBean方法去创建bean,然后调用doCreateBean去完成创建。
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { // Instantiate the bean. BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { //创建bean实例,但是尚未设置属性 instanceWrapper = createBeanInstance(beanName, mbd, args); } Object bean = instanceWrapper.getWrappedInstance(); Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } //允许后处理器修改合并的bean定义 synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex); } mbd.postProcessed = true; } } //急切地缓存单例,以便能够解析循环引用 //即使由BeanFactoryAware等生命周期接口触发。 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { if (logger.isTraceEnabled()) { logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } // Initialize the bean instance. Object exposedObject = bean; try { //设置属性 populateBean(beanName, mbd, instanceWrapper); //应用初始化方法,调用BeanPostProcessor后置处理器 exposedObject = initializeBean(beanName, exposedObject, mbd); } catch (Throwable ex) { if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { throw (BeanCreationException) ex; } else { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex); } } if (earlySingletonExposure) { Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) { if (exposedObject == bean) { exposedObject = earlySingletonReference; } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { String[] dependentBeans = getDependentBeans(beanName); Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been " + "wrapped. This means that said other beans do not use the final version of the " + "bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example."); } } } } // Register bean as disposable. try { registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } return exposedObject; }
在上述的方法中会先实例化一个bean,然后注入property里面配置的属性,最后执行初始化相关方法。
简单时序图:
- 入门必备,深入理解Spring Redis Data,源码分析,RedisDesktopManager
- 深入理解 spring 容器,源码分析加载过程
- 深入理解Spring系列之十:DispatcherServlet请求分发源码分析
- 深入研究Spring-IoC:源码分析依赖注入
- 深入研究Spring-IoC:源码分析容器创建
- Spring源码分析-IOC之ListableBeanFactory
- spring源码与架构分析——Spring框架的一些理解
- 【Android 开发】深入理解内存缓存类LruCache:源码分析
- Spring源码分析-IOC之DisposableBean
- 深入理解Spark 2.1 Core (二):DAG调度器的原理与源码分析
- Spring Boot 源码深入分析
- 深入理解Spring的两大特征(IOC和AOP)
- 【转】Java程序员从笨鸟到菜鸟之(八十一)细谈Spring(十)深入源码分析Spring之HibernateTemplate 和HibernateDaoSupport
- spring IOC源码分析(1)
- spring源码分析之IOC初始化
- Spring源码分析之ioc注入
- spring源码学习之路---深度分析IOC容器初始化过程(四)
- Spring的IOC逐层深入——源码解析之IoC的根本BeanFactory(五)
- 深入理解Spring 之 源码剖析AOP(注解方式)
- spring IoC源码分析(1)