Spring IOC源码分析

阅读前建议读者先掌握Spring中的基本概念，本文从源码角度分析IOC容器的创建过程，大体涉及两个重要部分，一个是Bean容器的创建，一个是Bean的生命周期，建议在阅读时自己跟着源码一起走一遍流程。

注意：因为版本的不同，源码小部分会有一定变化，不过不影响大体流程，核心部分都还是相同的。然后本文不对Spring中涉及的一些概念做解释，仅分析启动流程。

让我们先来看一下最基本的Spring容器的demo

public static void main(String[] args){
	ApplicationContext context=new ClassPathXmlApplicationContext("classpath:application.xml");
}

整个容器启动流程就是从ClassPathXmlApplicationContext()这个构造开始，从类名来看很容易知道是在classpath中根据xml文件来构建ApplicationContext。除了xml的方式，还有其他方案可以选择。

我们可以看到，除了ClassPathXmlApplicationContext之外，还有FileSystemXmlApplicationContext和AnnotationConfigApplicationContext这两种配置方式，具体怎么使用请自行查阅资料。

接下来还有一个比较重要的继承体系，就是BeanFactory，其实ApplicationContext也是一个BeanFactory

AutowireCapableBeanFatory就是用来自动装配Bean的。可以看到ApplicationContext并没有继承它，但是提供了一个特殊的方法getAutowireCapableBeanFactory()。另外两个二级接口ListableBeanFactory和HierarchicalBeanFactory，从名字可以看出来，一个是可以获取多个Bean，一个是可以将多个BeanFactory设置继承关系。BeanFactory做为顶层接口，只提供了获取单个Bean的接口，这也是最重要的一个方法getBean()。

以上的继承体系请自行查阅源码，简单看下各个接口都提供哪些方法即可。

启动流程分析

容器的启动流程就是从ClassPathXmlApplicationContext的构造开始，

	public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
		this(new String[] {configLocation}, true, null);
	}

	public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {
		super(parent);
        //根据路径进行分割，处理为配置文件数组
		setConfigLocations(configLocations);
		if (refresh) {
            //核心方法
			refresh();
		}
	}

refresh()是整个IOC的核心方法，为什么要叫refresh呢，是因为ApplicationContext可以重新创建，这样还会将原来的容器销毁，然后再执行一次初始化操作，这个操作就是刷新。

	@Override
	public void refresh() throws BeansException, IllegalStateException {
        //同步，避免启动和销毁是并发执行
		synchronized (this.startupShutdownMonitor) {
            
            //刷新前的准备工作
			prepareRefresh();
            
            //将配置文件解析成BeanDefinition对象，注册到BeanFactory中，并没有初始化Bean
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
            
            //设置BeanFactory的类加载器，添加几个BeanPostProcessor，注册几个特殊的bean
			prepareBeanFactory(beanFactory);
			try {
                //容器扩展点!!!
                //如果Bean实现了BeanFactoryPostProcessor这个接口，那么在容器初始化后，
                //Spring会调用实现类的postProcessBeanFactory方法。
                //具体的子类可以在这一步注册特殊的BeanPostProcessors
				postProcessBeanFactory(beanFactory);
                
                //回调BeanFactoryPostProcessor实现类的postProcessBeanFactory方法
				invokeBeanFactoryPostProcessors(beanFactory);
                
                //注册BeanPostProcessor实现类，注意，一个是BeanFactory的后置处理器，
                //一个是Bean的后置处理器。
                //此接口的两个方法: postProcessBeforeInitialization和postProcessAfterInitialization
                //分别在Bean的初始化之前和初始化之后执行。
				registerBeanPostProcessors(beanFactory);
                
                //资源国际化，不重要
				initMessageSource();
                
                //初始化Application的事件传播器，不是本期重点
				initApplicationEventMulticaster();
                
                //钩子方法
                //具体子类可以在这里初始化一些特殊的Bean
				onRefresh();
                
                //注册事件监听器，需要实现ApplicationListener接口
				registerListeners();
                
                //初始化所有的单例Bean，lazy-init除外
				finishBeanFactoryInitialization(beanFactory);
                
                //广播事件，ApplicationContext完成初始化
				finishRefresh();
			}
			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}
                //销毁已经初始化的单例Bean
				destroyBeans();
				cancelRefresh(ex);
				throw ex;
			}

			finally {
				resetCommonCaches();
			}
		}
	}

接下来按顺序解析重点方法

prepareRefresh()，容器刷新前的准备工作

	protected void prepareRefresh() {
        //记录刷新时间
		this.startupDate = System.currentTimeMillis();
		this.closed.set(false);
		this.active.set(true);
		//......
        
		initPropertySources();

        //验证配置文件
		getEnvironment().validateRequiredProperties();

		//......
	}

obtainFreshBeanFactory()，创建容器并注册BeanDefinition

#AbstractApplicationContext

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        //刷新BeanFactory
		refreshBeanFactory();
        //返回刷新后的BeanFactory
		return getBeanFactory();
	}

#AbstractRefreshableApplicationContext

	@Override
	protected final void refreshBeanFactory() throws BeansException {
        //如果已经创建过BeanFactory，就销毁所有Bean，关闭BeanFactory
        //这里指的是当前ApplicationContext中的BeanFactory
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
            //创建一个DefaultListableBeanFactory对象，该方法仅创建了一个对象并返回
            //这里为什么要实例化DefaultListableBeanFactory?
            //请回到上面的继承图，可以发现该对象实现了所有的接口
			DefaultListableBeanFactory beanFactory = createBeanFactory();
            
            //序列化
			beanFactory.setSerializationId(getId());
            
            //设置BeanFactory的属性，是否允许Bean覆盖，是否允许循环引用
			customizeBeanFactory(beanFactory);
            
            //加载BeanDefinition到BeanFactory中
			loadBeanDefinitions(beanFactory);
            
            //将创建好的beanFactory赋值给当前ApplicationContext
            //虽然ApplicationContext也是BeanFactory的子接口，但其实是
            //内部持有一个BeanFactory的实例，具体操作都由该实例完成
			this.beanFactory = beanFactory;
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

在此处涉及到了BeanDefinition，BeanDefinition其实就是一个Bean的定义信息对象，它保存了用户在配置文件中定义好的Bean信息，例如这个Bean是属于哪个类，是否单例，是否懒加载等等。具体信息请自行查看BeanDefinition接口。

接下来继续看customizeBeanFactory(beanFactory);

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

#AbstractXmlApplicationContext

	@Override
	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        //创建XmlBeanDefinitionReader对象，用于从配置文件加载Bean信息并转成BeanDefinition
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		beanDefinitionReader.setEnvironment(this.getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
		initBeanDefinitionReader(beanDefinitionReader);
        //这个方法内部所有流程就是使用XmlBeanDefinitionReader对象，去解析
        //xml配置文件，并将文件中的bean信息转为BeanDefinition注册到BeanFactory中
        //内部涉及的都是一些解析工作，此处就不再展开
		loadBeanDefinitions(beanDefinitionReader);
	}

到这里容器就已经创建完成了，并且容器保存了所有Bean的BeanDefinition信息。

prepareBeanFactory(beanFactory)，准备BeanFactory

这一步也就是为BeanFactory进行一些设置

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		//设置BeanFactory的类加载器
		beanFactory.setBeanClassLoader(getClassLoader());
		if (!shouldIgnoreSpel) {
			beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		}
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		//添加一个BeanPostProcessor，实现了Aware接口的Bean，在初始化时，由该processor进行回调
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    
    	//如果有Bean依赖于以下接口的实现类，在自动装配的时候忽略
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);

		//某些特殊的bean依赖下面几个，会注入响应的值。
    	//前面提到过的，ApplicationContext持有一个BeanFactory，就是这里的第一行
    	//并且ApplicationContext继承了后面的几个接口
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		//注册监听器
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// Detect a LoadTimeWeaver and prepare for weaving, if found.
		if (!NativeDetector.inNativeImage() && 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()));
		}

		// 以下是注册一些系统环境配置相关的Bean
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
		if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
			beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
		}
	}

prepareBeanFactory(beanFactory)方法执行完，后面的一些方法都只是一些注册处理器和处理回调，直接跳到

finishBeanFactoryInitialization(beanFactory);

finishBeanFactoryInitialization(beanFactory)，初始化单例Bean

到目前为止，BeanFactory已经创建完成，并且回调了BeanFactoryPostProcessor的postProcessBeanFactory()方法，初始化了BeanPostProcessor的实现类。加下来就是初始化单例Bean的流程。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		
		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));
		}

		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		beanFactory.setTempClassLoader(null);

    	//冻结所有BeanDefinition，表明注册的BeanDefinition不会被进一步修改或后处理
		beanFactory.freezeConfiguration();
		
    	//初始化单例Bean
		beanFactory.preInstantiateSingletons();
	}

#DefaultListableBeanFactory

	@Override
	public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}

		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
		//触发非懒加载以外的单例bean初始化
		for (String beanName : beanNames) {
            //合并父Bean的配置，<bean id="" class="" parent=""/>这里的parent
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            //非抽象，单例，非懒加载需要初始化
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                //是否是FactoryBean，不了解的请自行查阅概念
				if (isFactoryBean(beanName)) {
                    //FactoryBean的beanName会在前面加上&符号，再调用getBean()
					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()
					getBean(beanName);
				}
			}
		}
		//到这里所有的非懒加载的单例Bean已经完成了初始化
		//......
	}

接下来就要去到BeanFactory最核心的方法getBean()了。

#AbstractBeanFactory

	@Override
	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}

	//doGetBean的思想是，初始化过就从容器中拿，否则就进行初始化
	protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {
		//获取beanName，涉及到别名和FactoryBean的情况
		String beanName = transformedBeanName(name);
        
        //要返回的Bean实例
		Object beanInstance;
        
		//从容器中拿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就直接返回，
            //是FactoryBean，就返回它创建的那个实例对象
			beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}
			
            //下面这个if分支，是判断BeanDefinition是否在容器中
            //如果当前容器不存在，就返回父容器的查询结果
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				String nameToLookup = originalBeanName(name);
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly);
				}
				else if (args != null) {
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else if (requiredType != null) {
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
				else {
					return (T) parentBeanFactory.getBean(nameToLookup);
				}
			}

			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

            //到这里就要开始创建Bean了，对于singleton的Bean来说，容器还未创建过此Bean，
            //对于prototype来说，就是创建一个新的Bean
			StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
					.tag("beanName", name);
			try {
				if (requiredType != null) {
					beanCreation.tag("beanType", requiredType::toString);
				}
				RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);
				
				//先初始化该Bean所依赖的所有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);
						try {
                            //初始化依赖的bean
							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 {
                            //创建bean的逻辑
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							destroySingleton(beanName);
							throw ex;
						}
					});
					beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				//原型对象创建
				else if (mbd.isPrototype()) {
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						//创建bean的逻辑
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					beanInstance = 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 {
                                //创建bean的逻辑
								return createBean(beanName, mbd, args);
							}
							finally {
								afterPrototypeCreation(beanName);
							}
						});
						beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
					catch (IllegalStateException ex) {
						throw new ScopeNotActiveException(beanName, scopeName, ex);
					}
				}
			}
			catch (BeansException ex) {
				beanCreation.tag("exception", ex.getClass().toString());
				beanCreation.tag("message", String.valueOf(ex.getMessage()));
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
			finally {
				beanCreation.end();
			}
		}
		//检查以下类型是否正确，并返回bean对象
		return adaptBeanInstance(name, beanInstance, requiredType);
	}

接下来就是分析创建Bean的逻辑，createBean()

#AbstractAutowireCapableBeanFactory

	@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 实例
            //涉及到InstantiationAwareBeanPostProcessor接口
			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 {
            //创建Bean，往里面看
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
		}
	}

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
    
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
            //说明不是FactoryBean，这里实例化Bean
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
    	//返回该包装对象中保存的真正bean实例
		Object bean = instanceWrapper.getWrappedInstance();
    	//获取bean实例的类型
		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));
		}

		Object exposedObject = bean;
		try {
            //填充属性，在前面bean只是被实例化，相当于new出来，并没有赋值
			populateBean(beanName, mbd, instanceWrapper);
            //处理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);
			}
		}
		//......
		return exposedObject;
	}

这里重点挑里面的三个方法讲解，创建Bean实例的createBeanInstance()方法，依赖注入的populateBean()方法，初始化后的回调initializeBean()。

createBeanInstance()

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable 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());
		}

		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}
		
    	//如果这次不是第一次创建，则可以从第一次创建得知
    	//采用无参构造还是有参构造
		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() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			return autowireConstructor(beanName, mbd, ctors, args);
		}
		ctors = mbd.getPreferredConstructors();
		if (ctors != null) {
			return autowireConstructor(beanName, mbd, ctors, null);
		}
		//无参构造
		return instantiateBean(beanName, mbd);
	}

这里挑无参构造的方法进行查看

protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
		try {
			Object beanInstance;
			if (System.getSecurityManager() != null) {
				beanInstance = AccessController.doPrivileged(
						(PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
						getAccessControlContext());
			}
			else {
                //实例化
				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
			}
			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
			initBeanWrapper(bw);
			return bw;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
		}
	}

	#SimpleInstantiationStrategy
	@Override
	public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
		if (!bd.hasMethodOverrides()) {
			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(
									(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
						}
						else {
							constructorToUse = clazz.getDeclaredConstructor();
						}
						bd.resolvedConstructorOrFactoryMethod = constructorToUse;
					}
					catch (Throwable ex) {
						throw new BeanInstantiationException(clazz, "No default constructor found", ex);
					}
				}
			}
            //使用构造方法对象进行反射实例化
			return BeanUtils.instantiateClass(constructorToUse);
		}
		else {
			return instantiateWithMethodInjection(bd, beanName, owner);
		}
	}

populateBean()

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		//......
		//获取bean实例的所有属性
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
		
    	//获取依赖注入的方式
		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
                //按名称装配
				autowireByName(beanName, mbd, bw, newPvs);
			}
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
                //按类型装配
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}
		//......
		if (pvs != null) {
            //设置bean实例的属性值
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

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 {
            //回调实现了BeanNameAware、BeanClassLoaderAware、BeanFactoryAware接口的实现类
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
            //BeanPostProcessor的postProcessBeforeInitialization回调
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
            //init-method回调
			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);
		}
		//返回包装Bean实例
		return wrappedBean;
	}

到这里，单实例Bean的创建就完成了。

我们用一张图来梳理一下整体流程

上图包含了容器创建过程和bean的创建过程

本文仅仅从源码角度分析了IOC容器创建的大体流程，没有去扣细节点，有兴趣的朋友可以自行查看源码，对每个流程的详细情况再做更深的理解。