前言
springmvc，springboot，springcloud以及他们很多配套框架，比如各种stater，springsecurity等所有的基础是spring，作为spring家族的源码分析最基础的部分，这篇文章把spring给大家尽量用最简单的方法，把主要流程讲清楚。为后续的springboot，springcloud，以及其他相关框架分析打下基础。
spring框架简单的例子
引入依赖：
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>4.3.11.RELEASE</version> </dependency>定义一个接口：
public interface DemoService { String getData(); }定义接口实现类：
public class DemoServiceImpl implements DemoService { public String getData() { return "hello world"; } }接下来，我们在 resources 目录新建一个配置文件，文件随意，这里命名成application.xml：
<?xml version="1.0" encoding="UTF-8" ?> <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd" default-autowire="byName"> <bean id="demoService" class="com.wang.example.DemoServiceImpl"/> </beans>这样，我们就可以跑起来了：
public class App { public static void main(String[] args) { // 用我们的配置文件来启动一个 ApplicationContext ApplicationContext context = new ClassPathXmlApplicationContext("classpath:application.xml"); System.out.println("context 启动成功"); // 从 context 中取出我们的 Bean，这是spring的方式，不用去new DemoServiceImpl DemoService demoService = context.getBean(demoService.class); // 这句将输出: hello world System.out.println(demoService.getData()); } }这就是一个最简单使用spring的例子，可能很多直接用springboot开发的人都已经不了解这个了，但是如果想要分析spring源码首先要知道它怎么用，如果不知道怎么用，源码分析就无从谈起了。
接下来以这个例子为入口，一起分析下spring的流程。
分析之前我先简单说下流程，后续验证下spring源码的整体流程是不是这样：
会扫描指定的配置文件“classpath:application.xml”，然后扫描解析xml文件，按照里面的节点信息比如“<bean id="demoService"/>”，实例化对应的对象，对象信息就是<bean>节点定义的信息，最后放入到map集合中，叫做“容器”。
后续“context.getBean(demoService.class)”方法其实就是从容器（前面的map集合）中获取到的实例。
这里的map集合其实就是spring容器，对应spring中FactoryBean这个类，看名字就知道它是管理bean的一个类。
看一下BeanFactory的部分源码：
public interface BeanFactory { String FACTORY_BEAN_PREFIX = "&"; Object getBean(String var1) throws BeansException; <T> T getBean(String var1, Class<T> var2) throws BeansException; Object getBean(String var1, Object... var2) throws BeansException; <T> T getBean(Class<T> var1) throws BeansException; <T> T getBean(Class<T> var1, Object... var2) throws BeansException; ... }可以看到它是一个接口，里面定义了获取bean的各种方法，其实就是从map集合中获取的。上面例子中ApplicationContext和FactoryBean什么关系呢？
答案：FactoryBean是ApplicationContext的父类，所以ApplicationContext属于容器
上图是BeanFactory和ApplicationContext类继承关系，以及主要的BeanFactory子类，后续分析会涉及到这张类图，后续说到类图记得回到这里啊。
FileSystemXmlApplicationContext 构造函数需要一个 xml 配置文件在系统中的路径和ClassPathXmlApplicationContext功能差不多，都是扫描xml文件生成实例的容器。
AnnotationConfigApplicationContext 是用于扫描注解生成实例的容器，目前springboot都是用的这个，等到后续分析springboot源码的时候就可以看到了。
知道了类的大体继承关系后，下面开始分析代码：
ClassPathXmlApplicationContext:
public ClassPathXmlApplicationContext( String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException { super(parent); // 把配置文件的路径设置到ApplicationContext，供后续调用解析使用 setConfigLocations(configLocations); if (refresh) { // spring解析的核心方法 refresh(); } }AbstractApplicationContext：
@Override public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { // 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符。不是 // 核心逻辑，知道就行了 prepareRefresh(); // 这个是核心逻辑的第一步， // 1. new DefaultListableBeanFactory() 这是核心的容器BeanFactory，都是通过它 // 获取对应的实例对象的 // 2. loadBeanDefinitions，解析配置文件application.xml中的实例对象，并生成 // 一个一个的BeanDefinition,放入Map<String, BeanDefinition> 的一个map中, // 其中string是bean的名字，BeanDefinition是描述了一个bean类。 // 这个时候还没有开始实例化的操作，只是把类的信息解析到了BeanDefinition中。 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // 做一些准备工作给Beanfactory，其实就是给beanFactory进行了一系列的配置工作，为 // 后续操作做准备。比如：ClassLoader 和post-processors等 prepareBeanFactory(beanFactory); try { // Allows post-processing of the bean factory in context subclasses. // 这里主要提供给子类的一个扩展点，主要是添加BeanPostProcessor，供子类使用，在 // 后续finishBeanFactoryInitialization方法中完成实例化后会调用 postProcessBeanFactory(beanFactory); // Invoke factory processors registered as beans in the context. invokeBeanFactoryPostProcessors(beanFactory); // Register bean processors that intercept bean creation. // 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别 // 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization // 后续会在finishBeanFactoryInitialization中触发 registerBeanPostProcessors(beanFactory); // Initialize message source for this context. initMessageSource(); // 初始化 ApplicationContext 的事件广播器，spring中的publicEvent核心方法就是它， // 用来发送事件通知的，监听器可以监听到发出的事件，这个在实际工作中是有用到的。 initApplicationEventMulticaster(); // Initialize other special beans in specific context subclasses. // 钩子函数，供子类扩展使用的. // -------------------------------------------------------- // springboot中，就是有子类实现了这个方法，进而创建 // 出内嵌了tomcat容器，创建了WebServerStartStopLifecycle，供tomcat启动 // 这块会在我后续文章中说明 onRefresh(); // Check for listener beans and register them. // 注册各种Listeners，上面initApplicationEventMulticaster方法注册了广播器 // 最后发出的广播事件，都是被这里的监听器来监听的。 // -------------------------------------------------------- // springboot启动的时候，会通它做各种的初始化操作，关注我后面的文章 registerListeners(); // 这个是最重要的了，也是核心逻辑实例并初始化所有的singleton beans finishBeanFactoryInitialization(beanFactory); // 调用LifecycleProcessor的onRefresh()方法，并发送ContextRefreshedEvent事件。 // 收尾工作了属于。 // -------------------------------------------------------- // 对于springboot在上面的onRefresh方法中创建了WebServerStartStopLifecycle， // 在这一步会调用WebServerStartStopLifecycle的onRefresh方法，完成springboot内嵌 // tomcat容器的启动。 // 后面我会单独开一篇文章来讲springboot源码会提到这块，请关注我。 finishRefresh(); } .... } }这是主要流程了，里面我都加了注释，和springboot相关的代码我也加了注释。为后续分析springboot源码的文章做准备，希望大家多多关注我后续的文章。
这里只分析spring相关的核心代码：
obtainFreshBeanFactory
finishBeanFactoryInitialization
obtainFreshBeanFactory流程分析
主要完成了创建bean容器，并注册对应的BeanDefinition到容器中
AbstractApplicationContext:
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { // 创建新的 BeanFactory，加载 Bean 定义、注册 Bean refreshBeanFactory(); return getBeanFactory(); }AbstractRefreshableApplicationContext：
protected final void refreshBeanFactory() throws BeansException { // 如果已经加载过 BeanFactory了，并销毁BeanFactory中所有 Bean，关闭 BeanFactory if (hasBeanFactory()) { destroyBeans(); closeBeanFactory(); } try { // 创建BeanFactory，创建的子类是DefaultListableBeanFactory，为什么用这个子类？ // 下面说 DefaultListableBeanFactory beanFactory = createBeanFactory(); beanFactory.setSerializationId(getId()); // 设置 BeanFactory 的两个配置属性：是否允许 Bean 覆盖、是否允许循环引用 customizeBeanFactory(beanFactory); // 加载 Bean 到 BeanFactory 中 loadBeanDefinitions(beanFactory); //把容器设置给当前的ApplicationContext this.beanFactory = beanFactory; } catch (IOException ex) { throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex); } }为什么用DefaultListableBeanFactory子类呢？再看下这个类图
DefaultListableBeanFactory几乎继承了所有的BeanFactory相关的类，它把祖祖辈辈的功能都继承下来了，它最牛逼了，所以就创建它了。
前面代码中也提到BeanDefinition，它是spring中很重要的一个类，保存了xml中bean类的定义信息，英文翻译过来也是这个意思“bean定义”，看下它的代码如下：
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement { // spring中创建类的方式 // singleton 只有一个实例，也即是单例模式。 // prototype访问一次创建一个实例，相当于new。 String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON; String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE; ... // 设置父 BeanName void setParentName(String parentName); // 获取父 BeanName String getParentName(); // 设置 Bean 的类名称 void setBeanClassName(String beanClassName); // 获取 Bean 的类名称 String getBeanClassName(); // 设置 bean 的 scope void setScope(String scope); String getScope(); // 设置是否懒加载 void setLazyInit(boolean lazyInit); boolean isLazyInit(); // 设置该 Bean 依赖的所有的 Bean，注意，这里的依赖不是指属性依赖(如 @Autowire 标记的)， // 是 depends-on="" 属性设置的值。 void setDependsOn(String... dependsOn); // 返回该 Bean 的所有依赖 String[] getDependsOn(); // 设置该 Bean 是否可以注入到其他 Bean 中，只对根据类型注入有效， // 如果根据名称注入，即使这边设置了 false，也是可以的 void setAutowireCandidate(boolean autowireCandidate); // 该 Bean 是否可以注入到其他 Bean 中 boolean isAutowireCandidate(); // 主要的。同一接口的多个实现，如果不指定名字的话，Spring 会优先选择设置 primary 为 true 的 bean void setPrimary(boolean primary); // 是否是 primary 的 boolean isPrimary(); // 如果该 Bean 采用工厂方法生成，指定工厂名称。对工厂不熟悉的读者，请参加附录 void setFactoryBeanName(String factoryBeanName); // 获取工厂名称 String getFactoryBeanName(); // 指定工厂类中的 工厂方法名称 void setFactoryMethodName(String factoryMethodName); // 获取工厂类中的 工厂方法名称 String getFactoryMethodName(); // 构造器参数 ConstructorArgumentValues getConstructorArgumentValues(); // Bean 中的属性值，后面给 bean 注入属性值的时候会说到 MutablePropertyValues getPropertyValues(); // 是否 singleton boolean isSingleton(); // 是否 prototype boolean isPrototype(); // 如果这个 Bean 原生是抽象类，那么不能实例化 boolean isAbstract(); int getRole(); String getDescription(); String getResourceDescription(); BeanDefinition getOriginatingBeanDefinition(); } 可以看到BeanDefinition定义了bean的所有信息，通过它就能把一个bean实例化出来。
接着分析上面的代码：
主要就是如下两个方法了
customizeBeanFactory(beanFactory); loadBeanDefinitions(beanFactory)protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) { if (this.allowBeanDefinitionOverriding != null) { // 设置是否允许用一个同名的bean name覆盖bean类定义，来替换前面的一个。 // 如果允许就替换了，如果不允许就会抛个异常。 // spring中默认是true，允许。 beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding); } if (this.allowCircularReferences != null) { // 设置是否允许循环依赖，并自动解决这个问题。默认是true。 // 循环依赖就是类A依赖B，B里面通过依赖A，这就是循环依赖了。 // spring解决这个问题，思路就是用单例（好多教程叫缓存，无所谓了），就是第一次 // A实例化的时候会放到map容器中，因为依赖B，所以会再实例化B去，实例化 // B的时候发现B又依赖A，所有又去实例化A，这个时候发现A已经在map容器中存在了， // 所以就直接返回，这样就不会再继续循环下去了。 beanFactory.setAllowCircularReferences(this.allowCircularReferences); } }继续分析loadBeanDefinitions，它是最主要的，解析了xml，并注册了BeanDefinition到容器中。
@Override protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException { // 给BeanFactory实例化一个 XmlBeanDefinitionReader,看名字就知道 // 就是解析xml用的 XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory); // Configure the bean definition reader with this context's // resource loading environment. beanDefinitionReader.setEnvironment(this.getEnvironment()); beanDefinitionReader.setResourceLoader(this); beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this)); // 不重要，跳过 initBeanDefinitionReader(beanDefinitionReader); // 继续跟进它，主线逻辑 loadBeanDefinitions(beanDefinitionReader); }loadBeanDefinitions调用最终会把beanDefinition注册到容器中
调用比较多，这个流程我用时序图画出来。
最后调用了这个方法，把BeanDefinition注册到容器中了。下面列出了核心方法。
@Override public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException { ... BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName); // 如果已经存在了这个BeanDefinition if (existingDefinition != null) { // 检查是否允许覆盖 if (!isAllowBeanDefinitionOverriding()) { // 如果不允许覆盖就抛出异常，前面分析过这个属性了 throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition); } // 注册到容器中，这样就覆盖了原来的bean。 this.beanDefinitionMap.put(beanName, beanDefinition); } else { // 不存在该bean if (hasBeanCreationStarted()) { //已经开始创建流程了，用锁锁住，避免冲突 // Cannot modify startup-time collection elements anymore (for stable iteration) synchronized (this.beanDefinitionMap) { // 放到容器中 this.beanDefinitionMap.put(beanName, beanDefinition); List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1); updatedDefinitions.addAll(this.beanDefinitionNames); updatedDefinitions.add(beanName); this.beanDefinitionNames = updatedDefinitions; removeManualSingletonName(beanName); } } else { // 注册beanDefinition到容器中 this.beanDefinitionMap.put(beanName, beanDefinition); this.beanDefinitionNames.add(beanName); removeManualSingletonName(beanName); } this.frozenBeanDefinitionNames = null; } ... }至此，终于把obtainFreshBeanFactory流程讲完了。
接下来继续finishBeanFactoryInitialization核心流程，把类实例化出来，代码如下：
AbstractApplicationContext
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { // 实例化名字为 conversionService 的 Bean。 // 这块挺常用，后面单独说下，beanFactory.getBean这个方法会触发实例化操作。 if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) { beanFactory.setConversionService( beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)); } ... // Stop using the temporary ClassLoader for type matching. beanFactory.setTempClassLoader(null); // 冻结beanDefinition信息，这个时候要开始实例化了，不期望再修改这些信息了。 // 主要就是设置了一个冻结标示 beanFactory.freezeConfiguration(); // 实例化bean流程 beanFactory.preInstantiateSingletons(); }DefaultListableBeanFactory:
@Override public void preInstantiateSingletons() throws BeansException { if (this.logger.isDebugEnabled()) { this.logger.debug("Pre-instantiating singletons in " + this); } List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames); // 触发所有的非懒加载的singleton beans 的初始化操作 for (String beanName : beanNames) { // 合并父 Bean 中的配置，注意 <bean id="" parent="" /> 中的 parent， // 后面会有文章专门讲解 RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); // 非抽象、非懒加载的 singletons单例。 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { // 处理 FactoryBean，注意FactoryBean和BeanFactory的区别，后面单独 // 写文章讲解 if (isFactoryBean(beanName)) { // FactoryBean 的话，在 beanName 前面加上 ‘&’ 符号,然后再调用 getBean， // getBean方法最核心方法了会实例化bean，因为前面加上了‘&’符号，所以 // 获取的就是FactoryBean类型的对象了。 // -------------------------------------------------- // 这里简单普及下你定义一个类实现了FactoryBean中的getObject方法，getBean的时候 // 如果名字前加‘&’会获取这个对象本身，比如Demo类实现了FactoryBean，然后你 // getBean("&demo"),获取的就是Demo本身。 // -------------------------------------------------- // 所以源码中的这个getBean会把你实现了FactoryBean // 的类实例化，并放到spring容器中。 // 后续当你在程序中调用getBean(‘demo’)，名字中不加的时候‘&’符号，进而 // 就会发现容器中已经存在了你的实例对象了（比如上面例子中的Demo）， // 因为这次你没有加“&”符号，流程会有所不同，它会调用demo实例的getObject方法。 // 当然这里只是把实现了FactoryBean的类实例化，并放入容器了 final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName); ... } else { // 对于普通的 Bean，只要调用 getBean(beanName) 这个方法就可以进行初始化了 getBean(beanName); } } } // 到这里说明所有的非懒加载的 singleton beans 已经完成了初始化 // 如果我们定义的 bean 是实现了 SmartInitializingSingleton 接口的，那么在这里得到回调，忽略 for (String beanName : beanNames) { Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton) { final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; if (System.getSecurityManager() != null) { AccessController.doPrivileged(new PrivilegedAction<Object>() { @Override public Object run() { smartSingleton.afterSingletonsInstantiated(); return null; } }, getAccessControlContext()); } else { smartSingleton.afterSingletonsInstantiated(); } } } } 接下来分析getBean，会调用doGetBean方法，分析它：
protected <T> T doGetBean( String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException { String beanName = transformedBeanName(name); Object bean; // 检查对象是否已经实例化过了，如果实例化过了，直接从缓存取出来。 // 如果没有注册过，这里返回肯定就是null了。里面的涉及到三级缓存（很多文章都这样叫）。 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是否实现了FactoryBean，如果是就调用它的getObject方法， // 如果不是就直接返回实例。 bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { .... try { RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); checkMergedBeanDefinition(mbd, beanName, args); // 检查当前bean是否有depends-on相关的配置，如果有就先实例化依赖项。 // 对应的注解@DependsOn 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); } } } // 创建单例对象，主要逻辑. if (mbd.isSingleton()) { sharedInstance = getSingleton(beanName, () -> { try { // 执行具体实例化操作 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); } // 如果不是单例，创建非单例对象 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 { ...省去不重要代码 } } catch (BeansException ex) { cleanupAfterBeanCreationFailure(beanName); throw ex; } } // 如果传入了requiredType，检查requiredType和bean类型是否匹配，它也会尝试转换一下， // finishBeanFactoryInitialization方法的最开始有提到conversionService，就是 // 在这里会尝试做转换，这块平时工作用的也比较多，比如日期格式转换相关的，就是在这里 // 转换的。 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方法，它会执行具体的实例化，并把实例化后的对象放到容器中。
@Override protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { if (logger.isTraceEnabled()) { logger.trace("Creating instance of bean '" + beanName + "'"); } RootBeanDefinition mbdToUse = mbd; // 确保 BeanDefinition 中的 Class 被加载 Class<?> resolvedClass = resolveBeanClass(mbd, beanName); if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { mbdToUse = new RootBeanDefinition(mbd); mbdToUse.setBeanClass(resolvedClass); } // 准备方法覆盖，不重要 try { mbdToUse.prepareMethodOverrides(); } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex); } try { // 提供BeanPostProcessors接口一个机会来替换当前bean，来返回你自己定义的代理 // bean。 // 对应的方法postProcessBeforeInstantiation和postProcessAfterInstantiation. // 方法入参是bean，返回的也是bean，给你机会让你在方法中替换下。 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null) { return bean; } } catch (Throwable ex) { throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex); } try { // 创建实例的核心方法 Object beanInstance = doCreateBean(beanName, mbdToUse, args); if (logger.isTraceEnabled()) { logger.trace("Finished creating instance of bean '" + beanName + "'"); } return beanInstance; } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { // A previously detected exception with proper bean creation context already, // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry. throw ex; } catch (Throwable ex) { throw new BeanCreationException( mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex); } }AbstractAutowireCapableBeanFactory:
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) { // 实例化对象 instanceWrapper = createBeanInstance(beanName, mbd, args); } Object bean = instanceWrapper.getWrappedInstance(); Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } ..... // 解决循环依赖问题的 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 { // 处理依赖注入比如@Autowaried，@Resource，实例对象的属性赋值操作。 populateBean(beanName, mbd, instanceWrapper); // 调用各种回调函数。比如BeanPostProcessor接口的回调, // InitializingBean接口的afterPropertiesSet的回调接口，以及各种 // Aware接口。 exposedObject = initializeBean(beanName, exposedObject, mbd); } .... return exposedObject; }这里省去了不必要的代码。
分析到这里大体的情况已经比较清晰了，如果有兴趣可以再深入分析。
这里把initializeBean方法分析下，因为工作中用的比较多。
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) { if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { invokeAwareMethods(beanName, bean); return null; }, getAccessControlContext()); } else { // 调用各Aware子类的接口 invokeAwareMethods(beanName, bean); } Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { // 调用BeanPostProcessors接口的postProcessBeforeInitialization方法 wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } try { // 调用InitializingBean接口的afterPropertiesSet方法，各种框架种经常 // 用来，做一些启动后的初始化工作。 invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable ex) { throw new BeanCreationException( (mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex); } if (mbd == null || !mbd.isSynthetic()) { // 调用BeanPostProcessors接口的postProcessAfterInitialization方法 wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } return wrappedBean; }总结
把整体的流程串了一遍，里面也有比较详细的注释。这里面涉及到很多spring给开发者留的口，来让开发者进行扩展回调使用，这些扩展口也是很有用。