SpringBoot 启动流程（二）：Spring IOC容器源码分析

阳光穿透心脏的1/2处 2022-12-11 09:15 184阅读 0赞

### 目录 ###

*  1 SpringApplication的run方法
 *  2 获取ApplicationContext
 *  3 具体启动过程

第一篇，讲解了SpringBoot 启动流程中，SpringApplication的构造方法，构造方法中进行了WebApplicationType的推断、ApplicationContextInitializer、ApplicationListener的实例初始化工作。

SpringApplication的run方法，完成了整个SpringBoot项目的启动过程。run方法主要包括六个阶段：

> 第一步：获取并启动Spring框架事件监听器，  
> 第二步：构造应用上下文环境，  
> 第三步：初始化应用上下文，  
> 第四步：刷新应用上下文前的准备阶段，  
> 第五步：刷新应用上下文

# 1 SpringApplication的run方法 #

以下是run方法的核心代码：  
//SpringApplication.java

/** * Run the Spring application, creating and refreshing a new * {@link ApplicationContext}. * * @param args the application arguments (usually passed from a Java main method) * @return a running {@link ApplicationContext} * * 运行spring应用，并刷新一个新的 ApplicationContext（Spring的上下文） * ConfigurableApplicationContext 是 ApplicationContext 接口的子接口。在 ApplicationContext * 基础上增加了配置上下文的工具。 ConfigurableApplicationContext是容器的高级接口 */
    	public ConfigurableApplicationContext run(String... args) { 
    		//记录程序运行时间
    		StopWatch stopWatch = new StopWatch();
    		stopWatch.start();
    		// ConfigurableApplicationContext Spring 的上下文
    		ConfigurableApplicationContext context = null;
    		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    		configureHeadlessProperty();
    		//从META-INF/spring.factories中获取监听器
    		//1、获取并启动监听器
    		SpringApplicationRunListeners listeners = getRunListeners(args);
    		listeners.starting();
    		try { 
    			ApplicationArguments applicationArguments = new DefaultApplicationArguments(
    					args);
    			//2、构造应用上下文环境
    			ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
    			//处理需要忽略的Bean
    			configureIgnoreBeanInfo(environment);
    			//打印banner
    			Banner printedBanner = printBanner(environment);
    			///3、初始化应用上下文
    			context = createApplicationContext();
    			//实例化SpringBootExceptionReporter.class，用来支持报告关于启动的错误
    			exceptionReporters = getSpringFactoriesInstances(
    					SpringBootExceptionReporter.class,
    					new Class[]{ ConfigurableApplicationContext.class}, context);
    			//4、刷新应用上下文前的准备阶段
    			prepareContext(context, environment, listeners, applicationArguments, printedBanner);
    			//5、刷新应用上下文
    			refreshContext(context);
    			//6、刷新应用上下文后的扩展接口
    			afterRefresh(context, applicationArguments);
    			//时间记录停止
    			stopWatch.stop();
    			if (this.logStartupInfo) { 
    				new StartupInfoLogger(this.mainApplicationClass)
    						.logStarted(getApplicationLog(), stopWatch);
    			}
    			//发布容器启动完成事件
    			listeners.started(context);
    			callRunners(context, applicationArguments);
    		} catch (Throwable ex) { 
    			handleRunFailure(context, ex, exceptionReporters, listeners);
    			throw new IllegalStateException(ex);
    		}
    
    		try { 
    			listeners.running(context);
    		} catch (Throwable ex) { 
    			handleRunFailure(context, ex, exceptionReporters, null);
    			throw new IllegalStateException(ex);
    		}
    		return context;
    	}

**如果完整分析整个启动过程的源码，必然造成全文枯燥，没有重点，不易理解。所以文章将会围绕Spring IOC的核心知识展开。**

# 2 获取ApplicationContext #

run方法的返回结果是ConfigurableApplicationContext，注意这一行代码：

//SpringApplication

context = createApplicationContext();

跟进代码：  
//SpringApplication

/** * Strategy method used to create the {@link ApplicationContext}. By default this * method will respect any explicitly set application context or application context * class before falling back to a suitable default. * * @return the application context (not yet refreshed) * @see #setApplicationContextClass(Class) */
    	protected ConfigurableApplicationContext createApplicationContext() { 
    		Class<?> contextClass = this.applicationContextClass;
    		if (contextClass == null) { 
    			try { 
    				switch (this.webApplicationType) { 
    					case SERVLET:
    						contextClass = Class.forName(DEFAULT_WEB_CONTEXT_CLASS);
    						break;
    					case REACTIVE:
    						contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
    						break;
    					default:
    						contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
    				}
    			} catch (ClassNotFoundException ex) { 
    				throw new IllegalStateException(
    						"Unable create a default ApplicationContext, "
    								+ "please specify an ApplicationContextClass",
    						ex);
    			}
    		}
    		return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
    	}

在SpringBoot工程中，应用类型分为三种：NONE、SERVLET、REACTIVE。　对应三种应用类型，SpringBoot项目有三种对应的应用上下文，我们以web工程为例，即其上下文为  
**AnnotationConfigServletWebServerApplicationContext**。

在继续分析代码前，先介绍下BeanFactory

**BeanFactory简介**  
BeanFactory，从名字上也很好理解，生产 bean 的工厂，它负责生产和管理各个 bean 实例。

我们以DefaultListableBeanFactory来看下BeanFactory的继承关系。DefaultListableBeanFactory是BeanFactory的具体实现，也就是说很多具体生产和管理bean的工作，都在DefaultListableBeanFactory。（非常重要）

我们来看下和 BeanFactory 接口相关的主要的继承结构：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1amluZ2dlbg_size_16_color_FFFFFF_t_70_pic_center]

*  ApplicationContext 继承了 ListableBeanFactory，这个 Listable 的意思就是，通过这个接口，我们可以获取多个 Bean，大家看源码会发现，最顶层 BeanFactory 接口的方法都是获取单个 Bean 的。
 *  ApplicationContext 继承了 HierarchicalBeanFactory，Hierarchical 单词本身已经能说明问题了，也就是说我们可以在应用中起多个 BeanFactory，然后可以将各个 BeanFactory 设置为父子关系。
 *  AutowireCapableBeanFactory 这个名字中的 Autowire 大家都非常熟悉，它就是用来自动装配 Bean 用的，但是仔细看上图，ApplicationContext 并没有继承它，不过不用担心，不使用继承，不代表不可以使用组合，如果你看到 ApplicationContext 接口定义中的最后一个方法 getAutowireCapableBeanFactory() 就知道了。
 *  ConfigurableListableBeanFactory 也是一个特殊的接口，看图，特殊之处在于它继承了第二层所有的三个接口，而 ApplicationContext 没有。这点之后会用到。  
    请先不用花时间在其他的接口和类上，先理解我说的这几点就可以了。

**那么上面获得的AnnotationConfigServletWebServerApplicationContext和BeanFactory是什么关系呢**

关于他的继承体系如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1amluZ2dlbg_size_16_color_FFFFFF_t_70_pic_center 1]  
应用上下文（ApplicationContext）可以理解成IoC容器的高级表现形式，应用上下文确实是在IoC容器的基础上丰富了一些高级功能。应用上下文对IoC容器是持有的关系。他的一个属性beanFactory就是IoC容器（DefaultListableBeanFactory）。所以他们之间是持有和扩展的关系。接下来看GenericApplicationContext类：

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry { 
        private final DefaultListableBeanFactory beanFactory;
        ...
        public GenericApplicationContext() { 
            this.beanFactory = new DefaultListableBeanFactory();
        }
        ...
    }

GenericApplicationContext类的构造函数中，初始化了一个DefaultListableBeanFactory对象。DefaultListableBeanFactory类是BeanFactory接口的具体实现。AnnotationConfigServletWebServerApplicationContext继承自GenericApplicationContext类，证明当初始化AnnotationConfigServletWebServerApplicationContext时，BeanUtils.instantiateClass(contextClass) 这个方法中，会初始化一个空的DefaultListableBeanFactory。  
从而IoC容器也创建了。

> 看到这里的时候，我觉得读者就应该站在高处看 ApplicationContext 了，ApplicationContext 继承自 BeanFactory，但是它不应该被理解为 BeanFactory 的实现类，而是说其内部持有一个实例化的 BeanFactory（DefaultListableBeanFactory）。以后所有的 BeanFactory 相关的操作其实是委托给这个实例来处理的。

# 3 具体启动过程 #

继续跟踪代码：  
// SpringApplication.java run方法

// 5、刷新应用上下文
    refreshContext(context);

继续跟踪源码：  
//AbstractApplicationContext

@Override
    	public void refresh() throws BeansException, IllegalStateException { 
    		// 来个锁，不然 refresh() 还没结束，你又来个启动或销毁容器的操作，那不就乱套了嘛
    		synchronized (this.startupShutdownMonitor) { 
    			// Prepare this context for refreshing.
    			// 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
    			prepareRefresh();
    
    			// Tell the subclass to refresh the internal bean factory.
    			// 这步比较关键，这步完成后，配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中，
    			// 当然，这里说的 Bean 还没有初始化，只是配置信息都提取出来了，
    			// 注册也只是将这些信息都保存到了注册中心(说到底核心是一个 beanName-> beanDefinition 的 map)
    			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    			// Prepare the bean factory for use in this context.
    			// 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
    			prepareBeanFactory(beanFactory);
    
    			try { 
    				// Allows post-processing of the bean factory in context subclasses.
    				// 【这里需要知道 BeanFactoryPostProcessor 这个知识点，Bean 如果实现了此接口，
    				// 那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。】
    
    				// 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
    				// 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
    				postProcessBeanFactory(beanFactory);
    
    				// Invoke factory processors registered as beans in the context.
    				// 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法
    				invokeBeanFactoryPostProcessors(beanFactory);
    
    				// Register bean processors that intercept bean creation.
    				// 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
    				// 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
    				// 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化
    				registerBeanPostProcessors(beanFactory);
    
    				// Initialize message source for this context.
    				// 初始化当前 ApplicationContext 的 MessageSource，国际化这里就不展开说了，不然没完没了了
    				initMessageSource();
    
    				// Initialize event multicaster for this context.
    				// 从方法名就可以知道，典型的模板方法(钩子方法)，
    				// 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
    				initApplicationEventMulticaster();
    
    				// Initialize other special beans in specific context subclasses.
    				//初始化其他特殊的Bean
    				onRefresh();
    
    				// Check for listener beans and register them.
    				// 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过
    				registerListeners();
    
    				// Instantiate all remaining (non-lazy-init) singletons.
    				// 重点，重点，重点
    				// 初始化所有的 singleton beans
    				//（lazy-init 的除外）
    				finishBeanFactoryInitialization(beanFactory);
    
    				// Last step: publish corresponding event.
    				// 最后，广播事件，ApplicationContext 初始化完成
    				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();
    			}
    		}
    	}

创建 Bean 容器，加载并注册 Bean，我们回到 refresh() 方法中的下一行 obtainFreshBeanFactory()。  
注意，这个方法是全文最重要的部分之一，这里将会初始化 BeanFactory、加载 Bean、注册 Bean 等等。当然，这步结束后，Bean 并没有完成初始化。这里指的是 Bean 实例并未在这一步生成。

// AbstractApplicationContext.java

/** * Tell the subclass to refresh the internal bean factory. * * @return the fresh BeanFactory instance * @see #refreshBeanFactory() * @see #getBeanFactory() * 告诉子类刷新内部bean工厂 */
    	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { 
    		// 关闭旧的 BeanFactory (如果有)，创建新的 BeanFactory，加载 Bean 定义、注册 Bean 等等
    		refreshBeanFactory();
    		// 返回刚刚创建的 BeanFactory
    		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    		if (logger.isDebugEnabled()) { 
    			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    		}
    		return beanFactory;
    	}

继续跟进代码：  
// AbstractRefreshableApplicationContext.java

/** * This implementation performs an actual refresh of this context's underlying * bean factory, shutting down the previous bean factory (if any) and * initializing a fresh bean factory for the next phase of the context's lifecycle. */
    	@Override
    	protected final void refreshBeanFactory() throws BeansException { 
    		// 如果 ApplicationContext 中已经加载过 BeanFactory 了，销毁所有 Bean，关闭 BeanFactory
    		// 注意，应用中 BeanFactory 本来就是可以多个的，这里可不是说应用全局是否有 BeanFactory，而是当前
    		// ApplicationContext 是否有 BeanFactory
    		if (hasBeanFactory()) { 
    			destroyBeans();
    			closeBeanFactory();
    		}
    		try { 
    			// 初始化一个 DefaultListableBeanFactory，为什么用这个，我们马上说。
    			DefaultListableBeanFactory beanFactory = createBeanFactory();
    			// 用于 BeanFactory 的序列化，我想不部分人应该都用不到
    			beanFactory.setSerializationId(getId());
    			// 下面这两个方法很重要，别跟丢了，具体细节之后说
    			// 设置 BeanFactory 的两个配置属性：是否允许 Bean 覆盖、是否允许循环引用
    			customizeBeanFactory(beanFactory);
    			// 加载 Bean 到 BeanFactory 中
    			loadBeanDefinitions(beanFactory);
    			synchronized (this.beanFactoryMonitor) { 
    				this.beanFactory = beanFactory;
    			}
    		} catch (IOException ex) { 
    			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    		}
    	}

在继续往下之前，我们需要先了解 BeanDefinition。我们说 BeanFactory 是 Bean 容器，那么 Bean 又是什么呢？

这里的 BeanDefinition 就是我们所说的 Spring 的 Bean，我们自己定义的各个 Bean 其实会转换成一个个 BeanDefinition 存在于 Spring 的 BeanFactory 中。

所以，如果有人问你 Bean 是什么的时候，你要知道 Bean 在代码层面上可以简单认为是 BeanDefinition 的实例。

> BeanDefinition 中保存了我们的 Bean 信息，比如这个 Bean 指向的是哪个类、是否是单例的、是否懒加载、这个 Bean 依赖了哪些 Bean 等等。

**BeanDefinition 接口定义**  
我们来看下 BeanDefinition 的接口定义：

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement { 
    
       // 我们可以看到，默认只提供 sington 和 prototype 两种，
       // 很多读者可能知道还有 request, session, globalSession, application, websocket 这几种，
       // 不过，它们属于基于 web 的扩展。
       String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
       String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
    
       // 比较不重要，直接跳过吧
       int ROLE_APPLICATION = 0;
       int ROLE_SUPPORT = 1;
       int ROLE_INFRASTRUCTURE = 2;
    
       // 设置父 Bean，这里涉及到 bean 继承，不是 java 继承。请参见附录的详细介绍
       // 一句话就是：继承父 Bean 的配置信息而已
       void setParentName(String parentName);
    
       // 获取父 Bean
       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 是被设置为 abstract，那么不能实例化，
       // 常用于作为 父bean 用于继承，其实也很少用......
       boolean isAbstract();
    
       int getRole();
       String getDescription();
       String getResourceDescription();
       BeanDefinition getOriginatingBeanDefinition();
    }

这个 BeanDefinition 其实已经包含很多的信息了，暂时不清楚所有的方法对应什么东西没关系，希望看完本文后读者可以彻底搞清楚里面的所有东西。

这里接口虽然那么多，但是没有类似 getInstance() 这种方法来获取我们定义的类的实例，真正的我们定义的类生成的实例到哪里去了呢？别着急，这个要很后面才能讲到。

有了 BeanDefinition 的概念以后，我们再往下看 refreshBeanFactory() 方法中的剩余部分：

customizeBeanFactory(beanFactory);
    loadBeanDefinitions(beanFactory);

**customizeBeanFactory**  
customizeBeanFactory(beanFactory) 比较简单，就是配置是否允许 BeanDefinition 覆盖、是否允许循环引用。

//AbstractRefreshableApplicationContext.java

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) { 
       if (this.allowBeanDefinitionOverriding != null) { 
          // 是否允许 Bean 定义覆盖
          beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
       }
       if (this.allowCircularReferences != null) { 
          // 是否允许 Bean 间的循环依赖
          beanFactory.setAllowCircularReferences(this.allowCircularReferences);
       }
    }

BeanDefinition 的覆盖问题可能会有开发者碰到这个坑，就是在配置文件中定义 bean 时使用了相同的 id 或 name，默认情况下，allowBeanDefinitionOverriding 属性为 null，如果在同一配置文件中重复了，会抛错，但是如果不是同一配置文件中，会发生覆盖。

循环引用也很好理解：A 依赖 B，而 B 依赖 A。或 A 依赖 B，B 依赖 C，而 C 依赖 A。

默认情况下，Spring 允许循环依赖，当然如果你在 A 的构造方法中依赖 B，在 B 的构造方法中依赖 A 是不行的。

至于这两个属性怎么配置？我在附录中进行了介绍，尤其对于覆盖问题，很多人都希望禁止出现 Bean 覆盖，可是 Spring 默认是不同文件的时候可以覆盖的。

之后的源码中还会出现这两个属性，读者有个印象就可以了，它们不是非常重要。

**加载 Bean: loadBeanDefinitions**

接下来是最重要的 loadBeanDefinitions(beanFactory) 方法了，这个方法将根据配置，加载各个 Bean，然后放到 BeanFactory 中。

读取配置的操作在 AnnotatedBeanDefinitionReader中，其负责加载配置、解析。

// AnnotationConfigWebApplicationContext.java

/** * Register a {@link org.springframework.beans.factory.config.BeanDefinition} for * any classes specified by {@link #register(Class...)} and scan any packages * specified by {@link #scan(String...)}. * <p>For any values specified by {@link #setConfigLocation(String)} or * {@link #setConfigLocations(String[])}, attempt first to load each location as a * class, registering a {@code BeanDefinition} if class loading is successful, * and if class loading fails (i.e. a {@code ClassNotFoundException} is raised), * assume the value is a package and attempt to scan it for annotated classes. * <p>Enables the default set of annotation configuration post processors, such that * {@code @Autowired}, {@code @Required}, and associated annotations can be used. * <p>Configuration class bean definitions are registered with generated bean * definition names unless the {@code value} attribute is provided to the stereotype * annotation. * @param beanFactory the bean factory to load bean definitions into * @see #register(Class...) * @see #scan(String...) * @see #setConfigLocation(String) * @see #setConfigLocations(String[]) * @see AnnotatedBeanDefinitionReader * @see ClassPathBeanDefinitionScanner */
    	@Override
    	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) { 
    		AnnotatedBeanDefinitionReader reader = getAnnotatedBeanDefinitionReader(beanFactory);
    		ClassPathBeanDefinitionScanner scanner = getClassPathBeanDefinitionScanner(beanFactory);
    
    		BeanNameGenerator beanNameGenerator = getBeanNameGenerator();
    		if (beanNameGenerator != null) { 
    			reader.setBeanNameGenerator(beanNameGenerator);
    			scanner.setBeanNameGenerator(beanNameGenerator);
    			beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
    		}
    
    		ScopeMetadataResolver scopeMetadataResolver = getScopeMetadataResolver();
    		if (scopeMetadataResolver != null) { 
    			reader.setScopeMetadataResolver(scopeMetadataResolver);
    			scanner.setScopeMetadataResolver(scopeMetadataResolver);
    		}
    
    		if (!this.annotatedClasses.isEmpty()) { 
    			if (logger.isInfoEnabled()) { 
    				logger.info("Registering annotated classes: [" +
    						StringUtils.collectionToCommaDelimitedString(this.annotatedClasses) + "]");
    			}
    			reader.register(ClassUtils.toClassArray(this.annotatedClasses));
    		}
    
    		if (!this.basePackages.isEmpty()) { 
    			if (logger.isInfoEnabled()) { 
    				logger.info("Scanning base packages: [" +
    						StringUtils.collectionToCommaDelimitedString(this.basePackages) + "]");
    			}
    			scanner.scan(StringUtils.toStringArray(this.basePackages));
    		}
    
    		String[] configLocations = getConfigLocations();
    		if (configLocations != null) { 
    			for (String configLocation : configLocations) { 
    				try { 
    					Class<?> clazz = ClassUtils.forName(configLocation, getClassLoader());
    					if (logger.isInfoEnabled()) { 
    						logger.info("Successfully resolved class for [" + configLocation + "]");
    					}
    					reader.register(clazz);
    				}
    				catch (ClassNotFoundException ex) { 
    					if (logger.isDebugEnabled()) { 
    						logger.debug("Could not load class for config location [" + configLocation +
    								"] - trying package scan. " + ex);
    					}
    					int count = scanner.scan(configLocation);
    					if (logger.isInfoEnabled()) { 
    						if (count == 0) { 
    							logger.info("No annotated classes found for specified class/package [" + configLocation + "]");
    						}
    						else { 
    							logger.info("Found " + count + " annotated classes in package [" + configLocation + "]");
    						}
    					}
    				}
    			}
    		}
    	}

接下来用刚刚初始化的 Reader 开始来加载loadBeanDefinitions，可以选择性跳过，不是很重要。代码位置在 reader.register()方法;具体加载过程略过。

上面介绍了obtainFreshBeanFactory()的过程。接下来，我们开始说说注册 Bean 吧。

回到AbstractApplicationContext：  
// AbstractApplicationContext

@Override
    public void refresh() throws BeansException, IllegalStateException { 
       // 来个锁，不然 refresh() 还没结束，你又来个启动或销毁容器的操作，那不就乱套了嘛
       synchronized (this.startupShutdownMonitor) { 
    
          // 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
          prepareRefresh();
    
          // 这步比较关键，这步完成后，配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中，
          // 当然，这里说的 Bean 还没有初始化，只是配置信息都提取出来了，
          // 注册也只是将这些信息都保存到了注册中心(说到底核心是一个 beanName-> beanDefinition 的 map)
          ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
          // 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
          // 这块待会会展开说
          prepareBeanFactory(beanFactory);
    
          try { 
             // 【这里需要知道 BeanFactoryPostProcessor 这个知识点，Bean 如果实现了此接口，
             // 那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。】
    
             // 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
             // 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
             postProcessBeanFactory(beanFactory);
             // 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 回调方法
             invokeBeanFactoryPostProcessors(beanFactory);          
    
    
    
             // 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
             // 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
             // 两个方法分别在 Bean 初始化之前和初始化之后得到执行。这里仅仅是注册，之后会看到回调这两方法的时机
             registerBeanPostProcessors(beanFactory);
    
             // 初始化当前 ApplicationContext 的 MessageSource，国际化这里就不展开说了，不然没完没了了
             initMessageSource();
    
             // 初始化当前 ApplicationContext 的事件广播器，这里也不展开了
             initApplicationEventMulticaster();
    
             // 从方法名就可以知道，典型的模板方法(钩子方法)，不展开说
             // 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
             onRefresh();
    
             // 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过
             registerListeners();
    
             // 重点，重点，重点
             // 初始化所有的 singleton beans
             //（lazy-init 的除外）
             finishBeanFactoryInitialization(beanFactory);
    
             // 最后，广播事件，ApplicationContext 初始化完成，不展开
             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.
             // 销毁已经初始化的 singleton 的 Beans，以免有些 bean 会一直占用资源
             destroyBeans();
    
             // Reset 'active' flag.
             cancelRefresh(ex);
    
             // 把异常往外抛
             throw ex;
          }
    
          finally { 
             // Reset common introspection caches in Spring's core, since we
             // might not ever need metadata for singleton beans anymore...
             resetCommonCaches();
          }
       }
    }

准备 Bean 容器: prepareBeanFactory  
之前我们说过，Spring 把我们在 xml 配置的 bean 都注册以后，会"手动"注册一些特殊的 bean。

这里简单介绍下 prepareBeanFactory(factory) 方法：

/** * Configure the factory's standard context characteristics, * such as the context's ClassLoader and post-processors. * @param beanFactory the BeanFactory to configure */
    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { 
       // 设置 BeanFactory 的类加载器，我们知道 BeanFactory 需要加载类，也就需要类加载器，
       // 这里设置为加载当前 ApplicationContext 类的类加载器
       beanFactory.setBeanClassLoader(getClassLoader());
    
       // 设置 BeanExpressionResolver
       beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
       // 
       beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
    
       // 添加一个 BeanPostProcessor，这个 processor 比较简单：
       // 实现了 Aware 接口的 beans 在初始化的时候，这个 processor 负责回调，
       // 这个我们很常用，如我们会为了获取 ApplicationContext 而 implement ApplicationContextAware
       // 注意：它不仅仅回调 ApplicationContextAware，
       // 还会负责回调 EnvironmentAware、ResourceLoaderAware 等，看下源码就清楚了
       beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    
       // 下面几行的意思就是，如果某个 bean 依赖于以下几个接口的实现类，在自动装配的时候忽略它们，
       // Spring 会通过其他方式来处理这些依赖。
       beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
       beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
       beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
       beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
       beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
       beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
    
       /** * 下面几行就是为特殊的几个 bean 赋值，如果有 bean 依赖了以下几个，会注入这边相应的值， * 之前我们说过，"当前 ApplicationContext 持有一个 BeanFactory"，这里解释了第一行。 * ApplicationContext 还继承了 ResourceLoader、ApplicationEventPublisher、MessageSource * 所以对于这几个依赖，可以赋值为 this，注意 this 是一个 ApplicationContext * 那这里怎么没看到为 MessageSource 赋值呢？那是因为 MessageSource 被注册成为了一个普通的 bean */
       beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
       beanFactory.registerResolvableDependency(ResourceLoader.class, this);
       beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
       beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    
       // 这个 BeanPostProcessor 也很简单，在 bean 实例化后，如果是 ApplicationListener 的子类，
       // 那么将其添加到 listener 列表中，可以理解成：注册 事件监听器
       beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
    
       // 这里涉及到特殊的 bean，名为：loadTimeWeaver，这不是我们的重点，忽略它
       // tips: ltw 是 AspectJ 的概念，指的是在运行期进行织入，这个和 Spring AOP 不一样，
       // 感兴趣的读者请参考我写的关于 AspectJ 的另一篇文章 https://www.javadoop.com/post/aspectj
       if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { 
          beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
          // Set a temporary ClassLoader for type matching.
          beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
       }
    
       /** * 从下面几行代码我们可以知道，Spring 往往很 "智能" 就是因为它会帮我们默认注册一些有用的 bean， * 我们也可以选择覆盖 */
    
       // 如果没有定义 "environment" 这个 bean，那么 Spring 会 "手动" 注册一个
       if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { 
          beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
       }
       // 如果没有定义 "systemProperties" 这个 bean，那么 Spring 会 "手动" 注册一个
       if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { 
          beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
       }
       // 如果没有定义 "systemEnvironment" 这个 bean，那么 Spring 会 "手动" 注册一个
       if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { 
          beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
       }
    }

在上面这块代码中，Spring 对一些特殊的 bean 进行了处理，读者如果暂时还不能消化它们也没有关系，慢慢往下看。

**初始化所有的 singleton beans**  
我们的重点当然是 finishBeanFactoryInitialization(beanFactory); 这个巨头了，这里会负责初始化所有的 singleton beans。

注意，后面的描述中，我都会使用初始化或预初始化来代表这个阶段，Spring 会在这个阶段完成所有的 singleton beans 的实例化。

我们来总结一下，到目前为止，应该说 BeanFactory 已经创建完成，并且所有的实现了 BeanFactoryPostProcessor 接口的 Bean 都已经初始化并且其中的 postProcessBeanFactory(factory) 方法已经得到回调执行了。而且 Spring 已经“手动”注册了一些特殊的 Bean，如 environment、systemProperties 等。

剩下的就是初始化 singleton beans 了，我们知道它们是单例的，如果没有设置懒加载，那么 Spring 会在接下来初始化所有的 singleton beans。

// AbstractApplicationContext.java

// 初始化剩余的 singleton beans
    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { 
    
       // 首先，初始化名字为 conversionService 的 Bean。本着送佛送到西的精神，我在附录中简单介绍了一下 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));
       }
    
       // Register a default embedded value resolver if no bean post-processor
       // (such as a PropertyPlaceholderConfigurer bean) registered any before:
       // at this point, primarily for resolution in annotation attribute values.
       if (!beanFactory.hasEmbeddedValueResolver()) { 
          beanFactory.addEmbeddedValueResolver(new StringValueResolver() { 
             @Override
             public String resolveStringValue(String strVal) { 
                return getEnvironment().resolvePlaceholders(strVal);
             }
          });
       }
    
       // 先初始化 LoadTimeWeaverAware 类型的 Bean
       // 之前也说过，这是 AspectJ 相关的内容，放心跳过吧
       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);
    
       // 没什么别的目的，因为到这一步的时候，Spring 已经开始预初始化 singleton beans 了，
       // 肯定不希望这个时候还出现 bean 定义解析、加载、注册。
       beanFactory.freezeConfiguration();
    
       // 开始初始化
       beanFactory.preInstantiateSingletons();
    }

从上面最后一行往里看，我们就又回到 DefaultListableBeanFactory 这个类了，这个类大家应该都不陌生了吧。

**preInstantiateSingletons**  
// DefaultListableBeanFactory

@Override
    public void preInstantiateSingletons() throws BeansException { 
       if (this.logger.isDebugEnabled()) { 
          this.logger.debug("Pre-instantiating singletons in " + this);
       }
       // this.beanDefinitionNames 保存了所有的 beanNames
       List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
    
       // 下面这个循环，触发所有的非懒加载的 singleton beans 的初始化操作
       for (String beanName : beanNames) { 
    
          // 合并父 Bean 中的配置，注意 <bean id="" class="" parent="" /> 中的 parent，用的不多吧，
          // 考虑到这可能会影响大家的理解，我在附录中解释了一下 "Bean 继承"，不了解的请到附录中看一下
          RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    
          // 非抽象、非懒加载的 singletons。如果配置了 'abstract = true'，那是不需要初始化的
          if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { 
             // 处理 FactoryBean(读者如果不熟悉 FactoryBean，请移步附录区了解)
             if (isFactoryBean(beanName)) { 
                // FactoryBean 的话，在 beanName 前面加上 ‘&’ 符号。再调用 getBean，getBean 方法别急
                final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                // 判断当前 FactoryBean 是否是 SmartFactoryBean 的实现，此处忽略，直接跳过
                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 { 
                   isEagerInit = (factory instanceof SmartFactoryBean &&
                         ((SmartFactoryBean<?>) factory).isEagerInit());
                }
                if (isEagerInit) { 
    
                   getBean(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(beanName) 方法了，这个方法我们经常用来从 BeanFactory 中获取一个 Bean，而初始化的过程也封装到了这个方法里。

**getBean**  
在继续前进之前，读者应该具备 FactoryBean 的知识，如果读者还不熟悉，请移步附录部分了解 FactoryBean。

// AbstractBeanFactory 196
    
    @Override
    public Object getBean(String name) throws BeansException { 
       return doGetBean(name, null, null, false);
    }
    
    // 我们在剖析初始化 Bean 的过程，但是 getBean 方法我们经常是用来从容器中获取 Bean 用的，注意切换思路，
    // 已经初始化过了就从容器中直接返回，否则就先初始化再返回
    @SuppressWarnings("unchecked")
    protected <T> T doGetBean(
          final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
          throws BeansException { 
       // 获取一个 “正统的” beanName，处理两种情况，一个是前面说的 FactoryBean(前面带 ‘&’)，
       // 一个是别名问题，因为这个方法是 getBean，获取 Bean 用的，你要是传一个别名进来，是完全可以的
       final String beanName = transformedBeanName(name);
    
       // 注意跟着这个，这个是返回值
       Object bean; 
    
       // 检查下是不是已经创建过了
       Object sharedInstance = getSingleton(beanName);
    
       // 这里说下 args 呗，虽然看上去一点不重要。前面我们一路进来的时候都是 getBean(beanName)，
       // 所以 args 传参其实是 null 的，但是如果 args 不为空的时候，那么意味着调用方不是希望获取 Bean，而是创建 Bean
       if (sharedInstance != null && args == null) { 
          if (logger.isDebugEnabled()) { 
             if (isSingletonCurrentlyInCreation(beanName)) { 
                logger.debug("...");
             }
             else { 
                logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
             }
          }
          // 下面这个方法：如果是普通 Bean 的话，直接返回 sharedInstance，
          // 如果是 FactoryBean 的话，返回它创建的那个实例对象
          // (FactoryBean 知识，读者若不清楚请移步附录)
          bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
       }
    
       else { 
          if (isPrototypeCurrentlyInCreation(beanName)) { 
             // 创建过了此 beanName 的 prototype 类型的 bean，那么抛异常，
             // 往往是因为陷入了循环引用
             throw new BeanCurrentlyInCreationException(beanName);
          }
    
          // 检查一下这个 BeanDefinition 在容器中是否存在
          BeanFactory parentBeanFactory = getParentBeanFactory();
          if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { 
             // 如果当前容器不存在这个 BeanDefinition，试试父容器中有没有
             String nameToLookup = originalBeanName(name);
             if (args != null) { 
                // 返回父容器的查询结果
                return (T) parentBeanFactory.getBean(nameToLookup, args);
             }
             else { 
                // No args -> delegate to standard getBean method.
                return parentBeanFactory.getBean(nameToLookup, requiredType);
             }
          }
    
          if (!typeCheckOnly) { 
             // typeCheckOnly 为 false，将当前 beanName 放入一个 alreadyCreated 的 Set 集合中。
             markBeanAsCreated(beanName);
          }
    
          /* * 稍稍总结一下： * 到这里的话，要准备创建 Bean 了，对于 singleton 的 Bean 来说，容器中还没创建过此 Bean； * 对于 prototype 的 Bean 来说，本来就是要创建一个新的 Bean。 */
          try { 
             final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
             checkMergedBeanDefinition(mbd, beanName, args);
    
             // 先初始化依赖的所有 Bean，这个很好理解。
             // 注意，这里的依赖指的是 depends-on 中定义的依赖
             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);
                   // 先初始化被依赖项
                   getBean(dep);
                }
             }
    
             // 如果是 singleton scope 的，创建 singleton 的实例
             if (mbd.isSingleton()) { 
                sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() { 
                   @Override
                   public Object getObject() throws BeansException { 
                      try { 
                         // 执行创建 Bean，详情后面再说
                         return createBean(beanName, mbd, args);
                      }
                      catch (BeansException ex) { 
                         destroySingleton(beanName);
                         throw ex;
                      }
                   }
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
             }
    
             // 如果是 prototype scope 的，创建 prototype 的实例
             else if (mbd.isPrototype()) { 
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try { 
                   beforePrototypeCreation(beanName);
                   // 执行创建 Bean
                   prototypeInstance = createBean(beanName, mbd, args);
                }
                finally { 
                   afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
             }
    
             // 如果不是 singleton 和 prototype 的话，需要委托给相应的实现类来处理
             else { 
                String scopeName = mbd.getScope();
                final 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, new ObjectFactory<Object>() { 
                      @Override
                      public Object getObject() throws BeansException { 
                         beforePrototypeCreation(beanName);
                         try { 
                            // 执行创建 Bean
                            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;
          }
       }
    
       // 最后，检查一下类型对不对，不对的话就抛异常，对的话就返回了
       if (requiredType != null && bean != null && !requiredType.isInstance(bean)) { 
          try { 
             return getTypeConverter().convertIfNecessary(bean, requiredType);
          }
          catch (TypeMismatchException ex) { 
             if (logger.isDebugEnabled()) { 
                logger.debug("Failed to convert bean '" + name + "' to required type '" +
                      ClassUtils.getQualifiedName(requiredType) + "'", ex);
             }
             throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
          }
       }
       return (T) bean;
    }

大家应该也猜到了，接下来当然是分析 createBean 方法：

/** * Central method of this class: creates a bean instance, * populates the bean instance, applies post-processors, etc. * @see #doCreateBean */
    @Override
    protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException { 
       if (logger.isDebugEnabled()) { 
          logger.debug("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);
       }
    
       // 准备方法覆写，这里又涉及到一个概念：MethodOverrides，它来自于 bean 定义中的 <lookup-method /> 
       // 和 <replaced-method />，如果读者感兴趣，回到 bean 解析的地方看看对这两个标签的解析。
       // 我在附录中也对这两个标签的相关知识点进行了介绍，读者可以移步去看看
       try { 
          mbdToUse.prepareMethodOverrides();
       }
       catch (BeanDefinitionValidationException ex) { 
          throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                beanName, "Validation of method overrides failed", ex);
       }
    
       try { 
          // 让 InstantiationAwareBeanPostProcessor 在这一步有机会返回代理，
          // 在 《Spring AOP 源码分析》那篇文章中有解释，这里先跳过
          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);
       }
       // 重头戏，创建 bean
       Object beanInstance = doCreateBean(beanName, mbdToUse, args);
       if (logger.isDebugEnabled()) { 
          logger.debug("Finished creating instance of bean '" + beanName + "'");
       }
       return beanInstance;
    }

**创建 Bean**  
我们继续往里看 doCreateBean 这个方法：

/** * Actually create the specified bean. Pre-creation processing has already happened * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks. * <p>Differentiates between default bean instantiation, use of a * factory method, and autowiring a constructor. * @param beanName the name of the bean * @param mbd the merged bean definition for the bean * @param args explicit arguments to use for constructor or factory method invocation * @return a new instance of the bean * @throws BeanCreationException if the bean could not be created * @see #instantiateBean * @see #instantiateUsingFactoryMethod * @see #autowireConstructor */
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
          throws BeanCreationException { 
    
       // Instantiate the bean.
       BeanWrapper instanceWrapper = null;
       if (mbd.isSingleton()) { 
          instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
       }
       if (instanceWrapper == null) { 
          // 说明不是 FactoryBean，这里实例化 Bean，这里非常关键，细节之后再说
          instanceWrapper = createBeanInstance(beanName, mbd, args);
       }
       // 这个就是 Bean 里面的 我们定义的类 的实例，很多地方我直接描述成 "bean 实例"
       final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
       // 类型
       Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
       mbd.resolvedTargetType = beanType;
    
       // 建议跳过吧，涉及接口：MergedBeanDefinitionPostProcessor
       synchronized (mbd.postProcessingLock) { 
          if (!mbd.postProcessed) { 
             try { 
                // MergedBeanDefinitionPostProcessor，这个我真不展开说了，直接跳过吧，很少用的
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
             }
             catch (Throwable ex) { 
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                      "Post-processing of merged bean definition failed", ex);
             }
             mbd.postProcessed = true;
          }
       }
    
       // 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));
       if (earlySingletonExposure) { 
          if (logger.isDebugEnabled()) { 
             logger.debug("Eagerly caching bean '" + beanName +
                   "' to allow for resolving potential circular references");
          }
          addSingletonFactory(beanName, new ObjectFactory<Object>() { 
             @Override
             public Object getObject() throws BeansException { 
                return getEarlyBeanReference(beanName, mbd, bean);
             }
          });
       }
    
       // Initialize the bean instance.
       Object exposedObject = bean;
       try { 
          // 这一步也是非常关键的，这一步负责属性装配，因为前面的实例只是实例化了，并没有设值，这里就是设值
          populateBean(beanName, mbd, instanceWrapper);
          if (exposedObject != null) { 
             // 还记得 init-method 吗？还有 InitializingBean 接口？还有 BeanPostProcessor 接口？
             // 这里就是处理 bean 初始化完成后的各种回调
             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<String>(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 " +
                         "'getBeanNamesOfType' 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;
    }

到这里，我们已经分析完了 doCreateBean 方法，总的来说，我们已经说完了整个初始化流程。

接下来我们挑 doCreateBean 中的三个细节出来说说。一个是创建 Bean 实例的 createBeanInstance 方法，一个是依赖注入的 populateBean 方法，还有就是回调方法 initializeBean。

注意了，接下来的这三个方法要认真说那也是极其复杂的，很多地方我就点到为止了，感兴趣的读者可以自己往里看，最好就是碰到不懂的，自己写代码去调试它。

**创建 Bean 实例**  
我们先看看 createBeanInstance 方法。需要说明的是，这个方法如果每个分支都分析下去，必然也是极其复杂冗长的，我们挑重点说。此方法的目的就是实例化我们指定的类。

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) { 
       // 确保已经加载了此 class
       Class<?> beanClass = resolveBeanClass(mbd, beanName);
    
       // 校验一下这个类的访问权限
       if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { 
          throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
       }
    
       if (mbd.getFactoryMethodName() != null)  { 
          // 采用工厂方法实例化，不熟悉这个概念的读者请看附录，注意，不是 FactoryBean
          return instantiateUsingFactoryMethod(beanName, mbd, args);
       }
    
       // 如果不是第一次创建，比如第二次创建 prototype bean。
       // 这种情况下，我们可以从第一次创建知道，采用无参构造函数，还是构造函数依赖注入 来完成实例化
       boolean resolved = false;
       boolean autowireNecessary = false;
       if (args == null) { 
          synchronized (mbd.constructorArgumentLock) { 
             if (mbd.resolvedConstructorOrFactoryMethod != null) { 
                resolved = true;
                autowireNecessary = mbd.constructorArgumentsResolved;
             }
          }
       }
       if (resolved) { 
          if (autowireNecessary) { 
             // 构造函数依赖注入
             return autowireConstructor(beanName, mbd, null, null);
          }
          else { 
             // 无参构造函数
             return instantiateBean(beanName, mbd);
          }
       }
    
       // 判断是否采用有参构造函数
       Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
       if (ctors != null ||
             mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
             mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  { 
          // 构造函数依赖注入
          return autowireConstructor(beanName, mbd, ctors, args);
       }
    
       // 调用无参构造函数
       return instantiateBean(beanName, mbd);
    }

挑个简单的无参构造函数构造实例来看看：

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) { 
       try { 
          Object beanInstance;
          final BeanFactory parent = this;
          if (System.getSecurityManager() != null) { 
             beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() { 
                @Override
                public Object run() { 
    
                   return getInstantiationStrategy().instantiate(mbd, beanName, parent);
                }
             }, getAccessControlContext());
          }
          else { 
             // 实例化
             beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
          }
          // 包装一下，返回
          BeanWrapper bw = new BeanWrapperImpl(beanInstance);
          initBeanWrapper(bw);
          return bw;
       }
       catch (Throwable ex) { 
          throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
       }
    }

我们可以看到，关键的地方在于：

beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);

这里会进行实际的实例化过程，我们进去看看:  
// SimpleInstantiationStrategy

@Override
    public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) { 
    
       // 如果不存在方法覆写，那就使用 java 反射进行实例化，否则使用 CGLIB,
       // 方法覆写 请参见附录"方法注入"中对 lookup-method 和 replaced-method 的介绍
       if (bd.getMethodOverrides().isEmpty()) { 
          Constructor<?> constructorToUse;
          synchronized (bd.constructorArgumentLock) { 
             constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
             if (constructorToUse == null) { 
                final Class<?> clazz = bd.getBeanClass();
                if (clazz.isInterface()) { 
                   throw new BeanInstantiationException(clazz, "Specified class is an interface");
                }
                try { 
                   if (System.getSecurityManager() != null) { 
                      constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() { 
                         @Override
                         public Constructor<?> run() throws Exception { 
                            return clazz.getDeclaredConstructor((Class[]) null);
                         }
                      });
                   }
                   else { 
                      constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
                   }
                   bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                }
                catch (Throwable ex) { 
                   throw new BeanInstantiationException(clazz, "No default constructor found", ex);
                }
             }
          }
          // 利用构造方法进行实例化
          return BeanUtils.instantiateClass(constructorToUse);
       }
       else { 
          // 存在方法覆写，利用 CGLIB 来完成实例化，需要依赖于 CGLIB 生成子类，这里就不展开了。
          // tips: 因为如果不使用 CGLIB 的话，存在 override 的情况 JDK 并没有提供相应的实例化支持
          return instantiateWithMethodInjection(bd, beanName, owner);
       }
    }

到这里，我们就算实例化完成了。我们开始说怎么进行属性注入。

bean 属性注入  
看完了 createBeanInstance(…) 方法，我们来看看 populateBean(…) 方法，该方法负责进行属性设值，处理依赖。

// AbstractAutowireCapableBeanFactory

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) { 
       // bean 实例的所有属性都在这里了
       PropertyValues pvs = mbd.getPropertyValues();
    
       if (bw == null) { 
          if (!pvs.isEmpty()) { 
             throw new BeanCreationException(
                   mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
          }
          else { 
             // Skip property population phase for null instance.
             return;
          }
       }
    
       // 到这步的时候，bean 实例化完成（通过工厂方法或构造方法），但是还没开始属性设值，
       // InstantiationAwareBeanPostProcessor 的实现类可以在这里对 bean 进行状态修改，
       // 我也没找到有实际的使用，所以我们暂且忽略这块吧
       boolean continueWithPropertyPopulation = true;
       if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { 
          for (BeanPostProcessor bp : getBeanPostProcessors()) { 
             if (bp instanceof InstantiationAwareBeanPostProcessor) { 
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                // 如果返回 false，代表不需要进行后续的属性设值，也不需要再经过其他的 BeanPostProcessor 的处理
                if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { 
                   continueWithPropertyPopulation = false;
                   break;
                }
             }
          }
       }
    
       if (!continueWithPropertyPopulation) { 
          return;
       }
    
       if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
             mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { 
          MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
    
          // 通过名字找到所有属性值，如果是 bean 依赖，先初始化依赖的 bean。记录依赖关系
          if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) { 
             autowireByName(beanName, mbd, bw, newPvs);
          }
    
          // 通过类型装配。复杂一些
          if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { 
             autowireByType(beanName, mbd, bw, newPvs);
          }
    
          pvs = newPvs;
       }
    
       boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
       boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
    
       if (hasInstAwareBpps || needsDepCheck) { 
          PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
          if (hasInstAwareBpps) { 
             for (BeanPostProcessor bp : getBeanPostProcessors()) { 
                if (bp instanceof InstantiationAwareBeanPostProcessor) { 
                   InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                   // 这里有个非常有用的 BeanPostProcessor 进到这里: AutowiredAnnotationBeanPostProcessor
                   // 对采用 @Autowired、@Value 注解的依赖进行设值，这里的内容也是非常丰富的，不过本文不会展开说了，感兴趣的读者请自行研究
                   pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                   if (pvs == null) { 
                      return;
                   }
                }
             }
          }
          if (needsDepCheck) { 
             checkDependencies(beanName, mbd, filteredPds, pvs);
          }
       }
       // 设置 bean 实例的属性值
       applyPropertyValues(beanName, mbd, bw, pvs);
    }

**initializeBean**  
属性注入完成后，这一步其实就是处理各种回调了，这块代码比较简单。

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) { 
       if (System.getSecurityManager() != null) { 
          AccessController.doPrivileged(new PrivilegedAction<Object>() { 
             @Override
             public Object run() { 
                invokeAwareMethods(beanName, bean);
                return null;
             }
          }, getAccessControlContext());
       }
       else { 
          // 如果 bean 实现了 BeanNameAware、BeanClassLoaderAware 或 BeanFactoryAware 接口，回调
          invokeAwareMethods(beanName, bean);
       }
    
       Object wrappedBean = bean;
       if (mbd == null || !mbd.isSynthetic()) { 
          // BeanPostProcessor 的 postProcessBeforeInitialization 回调
          wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
       }
    
       try { 
          // 处理 bean 中定义的 init-method，
          // 或者如果 bean 实现了 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()) { 
          // BeanPostProcessor 的 postProcessAfterInitialization 回调
          wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
       }
       return wrappedBean;
    }

大家发现没有，BeanPostProcessor 的两个回调都发生在这边，只不过中间处理了 init-method，是不是和读者原来的认知有点不一样了？

文章大部分参考：https://javadoop.com/post/spring-ioc\#toc\_6，有些地方可能结合springboot进行调整。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1amluZ2dlbg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/262cb5f5619142d5adcd2219a5d5eb34.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1amluZ2dlbg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/df4f91330f014c25845e9d8222af763f.png