spring5源码解析——第三部分

一、前情回顾

        上一节，我们讲解了刷新bean工厂后，初始化bean之前，spring容器所做的一些初始化行为，详情可以查看spring5源码解析——第二部分。本节内容，我们着重分析一下spring初始化容器中bean的过程，这部分也是比较重要的一部分。

        为了叙述方便，再把spring初始化方法的 内容粘贴一下：

	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			//主要是获取当前刷新时间，以及设置容器的同步标识
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			//刷新beanFactory，调用子类的实现（委派模式，委派子类实现）
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			//为beanFactory配置容器特性，如类加载器，事件处理器等
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				//注册一些beanFactory的后置处理器
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				//执行beanFactory的后置处理器回调
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				//注册bean的后置处理器
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				//初始化信息源（国际化相关）
				initMessageSource();

				// Initialize event multicaster for this context.
				//初始化事件传播器
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				//调用子类的某些特殊bean的初始化方法
				onRefresh();

				// Check for listener beans and register them.
				//注册事件监听器
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				//实例化其他所有的单例bean
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				//发布一些事件
				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.
				//销毁所有的bean
				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();
			}
		}
	}

二、finishBeanFactoryInitialization()

        此方法便是spring实例化所有非懒加载的单例bean的地方：

	/**
	 * 完成bean工厂的初始化，初始化所有剩余的单例bean。
	 */
	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		//初始化转换服务，对某些bean属性进行转换使用
		//CONVERSION_SERVICE_BEAN_NAME = "conversionService"
		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(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		//尽早实例化 实现了LoadTimeWeaverAware接口的bean，以便于这些bean在后续的bean初始化时可以被使用
		//LoadTimeWeaverAware的setLoadTimeWeaver方法会传入一个LoadTimeWeaver类型的实例，此实例用于字节码增强
		//可以给bean 提供更强的扩展性
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		//停止使用临时ClassLoader进行类型匹配。
		beanFactory.setTempClassLoader(null);

		//缓存所有bean定义元数据，以防被修改
		beanFactory.freezeConfiguration();

		// Instantiate all remaining (non-lazy-init) singletons.
		//对非lazy-init的单例bean进行预实例化处理
		beanFactory.preInstantiateSingletons();
	}

        其中，缓存所有bean定义数据的方法定义在DefaultListableBeanFactory中，内容如下：

	@Override
	public void freezeConfiguration() {
		//设置缓存标识为true
		this.configurationFrozen = true;
        //将目前的bean定义名称转为字符串数组存起来
		this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);
	}

        而初始化所有单例bean的方法为DefaultListableBeanFactory中的preInstantiateSingletons方法：

	@Override
	public void preInstantiateSingletons() throws BeansException {
		if (this.logger.isDebugEnabled()) {
			this.logger.debug("Pre-instantiating singletons in " + this);
		}
		
		//获取所有的bean名称
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
		
		//遍历并初始化bean
		for (String beanName : beanNames) {
			//根据bean名称获取对应的bean定义
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			//bean不是抽象的，是单例的，不是懒加载的
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				//如果指定名称的bean是FactoryBean类型
				if (isFactoryBean(beanName)) {
					//加上获取factoryBean的bean名称前缀“&”，调用getBean，触发实例化
					final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
					//标识factoryBean是否立即预初始化对应的bean对象，主要是根据SmartFactoryBean接口中的isEagerInit方法
					boolean isEagerInit;
					//判断系统是否设置了安全管理器，如果是，则访问factory对象的时候，需要加上安全拦截
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>) () ->
								((SmartFactoryBean<?>) factory).isEagerInit(),
								getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					//如果需要就将真实bean也初始化
					if (isEagerInit) {
						getBean(beanName);
					}
				}
				else {
					getBean(beanName);
				}
			}
		}

		//触发实现了SmartInitializingSingleton接口的bean的afterSingletonsInstantiated方法
		//bean如果实现了此接口，则可以通过此方法做一些必须得在所有bean初始化后的行为。
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

        其中初始化bean的方法为getBean（beanName）方法，而此方法是在DefaultListableBeanFactory的父类AbstractBeanFactory中定义的：

        

	//doGetBean才是真正获取被管理的bean
	@Override
	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}

	//doGetBean(name, null, null, false);
	@SuppressWarnings("unchecked")
	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

		//如果指定的是别名，将别名转换为规范的bean名称
		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		//从单例缓存中查看是否有存在的目标bean
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			//如果ioc中已经有指定名称的单例bean创建，则直接返回
			if (logger.isDebugEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			//获取给定bean的实例对象，主要完成FactoryBean的相关工作（FactoryBean是创建实例的工厂，跟BeanFactory（管理bean）不同）
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			//如果已经在创建此Bean，则失败
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// Check if bean definition exists in this factory.
			//从父工厂中获取Bean的定义
			BeanFactory parentBeanFactory = getParentBeanFactory();
			//当前容器有父容器并且当前容器没有此bean 的定义
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly);
				}
				else if (args != null) {
					// Delegation to parent with explicit args.
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}
			//创建的bean是否需要类型检查，一般不需要（几个重载方法的入参都是false）
			if (!typeCheckOnly) {
				//标记此bean被创建
				markBeanAsCreated(beanName);
			}

			try {
				//根据当前bean名称获取父级bean定义
				//主要解决当前bean继承时，子类和父类公共属性问题
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				//保证当前bean所依赖的bean的初始化。
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						//检查此bean 依赖的bean是否也同样依赖此bean，即循环依赖问题
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						//注册依赖bean
						registerDependentBean(dep, beanName);
						//确保依赖的bean 初始化了
						getBean(dep);
					}
				}

				// Create bean instance.
				//创建此bean 的实例，
				if (mbd.isSingleton()) {
					//使用匿名内部类创建bean实例对象，并注册给所依赖的对象
					sharedInstance = getSingleton(beanName, () -> {
						try {
							//创建一个指定bean 的实例对象，如果有父类继承，则合并子类和父类的定义
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							// Explicitly remove instance from singleton cache: It might have been put there
							// eagerly by the creation process, to allow for circular reference resolution.
							// Also remove any beans that received a temporary reference to the bean.
							//从单例缓存中显式删除实例：它可能是在创建过程中急切地放在那里的
							// 以允许循环引用解析。同时删除所有临时引用该bean的bean。
							destroySingleton(beanName);
							throw ex;
						}
					});
					//获得给定的Bean对象
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				//如果是原型模式的bean
				else if (mbd.isPrototype()) {
					// It's a prototype -> create a new instance.
					Object prototypeInstance = null;
					try {
						//回调方法，默认实现是注册当前原型模式的bean
						beforePrototypeCreation(beanName);
						//创建实例
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						//回调
						afterPrototypeCreation(beanName);
					}
					//获取bean实例
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}
				//既不是单例，也不是原型，那就根据 bean定义中的scope配置的bean生命周期范围
				//选择实例化bean 的方法，这种方式在web应用中比较常用，比如request或者session或者application
				else {
					String scopeName = mbd.getScope();
					final Scope scope = this.scopes.get(scopeName);
					//如果没有配置，则bean不合法报错
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
					}
					try {
						Object scopedInstance = scope.get(beanName, () -> {
							beforePrototypeCreation(beanName);
							try {
								return createBean(beanName, mbd, args);
							}
							finally {
								afterPrototypeCreation(beanName);
							}
						});
						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
					catch (IllegalStateException ex) {
						throw new BeanCreationException(beanName,
								"Scope '" + scopeName + "' is not active for the current thread; consider " +
								"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
								ex);
					}
				}
			}
			catch (BeansException ex) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}

		// Check if required type matches the type of the actual bean instance.
		//检查所需类型是否与实际bean实例的类型匹配。
		if (requiredType != null && !requiredType.isInstance(bean)) {
			//包装成所需类型的bean
			try {
				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
				//如果为空则报错，因为bean类型与所需类型不匹配
				if (convertedBean == null) {
					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
				}
				return convertedBean;
			}
			catch (TypeMismatchException ex) {
				//如果包装失败，则bean还是与所需类型不匹配
				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;
	}

        可以看到，getBean方法内部调用doGetBean方法，我们仔细分析一下doGetBean方法内容。

	//如果指定的是别名，将别名转换为规范的bean名称
	final String beanName = transformedBeanName(name);

	protected String transformedBeanName(String name) {
		return canonicalName(BeanFactoryUtils.transformedBeanName(name));
	}

	public static String transformedBeanName(String name) {
		Assert.notNull(name, "'name' must not be null");
		String beanName = name;
		//String FACTORY_BEAN_PREFIX = "&";
		//如果bean名称以&开头，则裁剪掉&，因为以&开头的bean为factoryBean
		//而并非实际被beanFactory创造出来的bean
		while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
			beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
		}
		return beanName;
	}

	public String canonicalName(String name) {
		String canonicalName = name;
		// Handle aliasing...
		String resolvedName;
		do {
			resolvedName = this.aliasMap.get(canonicalName);
			if (resolvedName != null) {
				canonicalName = resolvedName;
			}
		}
		while (resolvedName != null);
		return canonicalName;
	}

        首先是处理bean别名，调用AbstractBeanFactory的transformedBeanName方法，方法内调用了BeanFactoryUtils的transformedBeanName方法首先对FactoryBean名称进行处理，截取掉开头的“&”，其次将处理结果传入AbstractBeanFactory的父类SimpleAliasRegistry的canonicalName方法中，根据别名获取规范名称。之前加载bean定义的时候，为配置了别名的bean定义注册过别名

代码类似this.aliasMap.put(alias, name);其中alias别名为key，而value为规范名称name。所以此处自然就可以根据提供的别名来直接调用map的get方法获取规范名称。

        接下来下一句：

Object sharedInstance = getSingleton(beanName);

        此方法定义在AbstractBeanFactory的父类DefaultSingletonBeanRegistry中，用途就是先从缓存中尝试获取bean，如果获取成功就不需要再次创建：

	@Override
	@Nullable
	public Object getSingleton(String beanName) {
		return getSingleton(beanName, true);
	}	

    @Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		//从已经创建了的单例bean缓存中获取
		Object singletonObject = this.singletonObjects.get(beanName);
		//如果单例bean是空的，并且此单例bean目前正在创建
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			//上锁
			synchronized (this.singletonObjects) {
				//从尚未创建完成的单例bean缓存中获取
				singletonObject = this.earlySingletonObjects.get(beanName);
				//如果singletonObject为空并且允许提前引用
				if (singletonObject == null && allowEarlyReference) {
                    //获取单例bean的创建工厂
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
                        //创建单例bean
						singletonObject = singletonFactory.getObject();
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
	}

        紧接着是处理工厂bean的逻辑，当前bean实例可能是工厂bean，而用户可能想获取的是工厂bean创建出来的bean，此方法中就是处理此种情况的。

bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

         具体方法内容如下：

	protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

		//如果指定的名称是factoryBean的引用，即以&开头
		//并且bean实例也不是创建bean实例对象的工厂bean
		//则抛出错误，此bean并不是工厂bean
		if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
			throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
		}

		//如果bean实例不是工厂bean，或者指定的名称是factoryBean的引用

		//此处的if条件比较巧妙，如果bean实例不是工厂bean，则前半条件为true，直接执行返回bean实例
		// 而不走工厂bean的特殊逻辑
		//而如果bean实例是工厂bean，则前半条件为false，如果此时名称就是工厂bean的引用，则也直接返回
		//说明用户就是想要工厂bean，而非工厂bean所创建的bean
		//如果此时名称不是工厂bean的引用，则不执行返回操作，而是继续之后的逻辑，也就是处理工厂bean的特殊逻辑

		//补充：spring如果存在名为user的工厂bean，此bean能够创建一个User类型的bean
		// 那么调用getBeanByName("user")，得到的是User类型的Bean
		// 调用getBeanByName("&user")，得到的是工厂bean
		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}

		//处理bean是工厂bean并且名称不是解引用的情况
		Object object = null;
		if (mbd == null) {
			//从工厂bean的缓存中获取指定名称的bean
			object = getCachedObjectForFactoryBean(beanName);
		}
		if (object == null) {
			//如果缓存中没有，则使用当前的工厂bean创建一个实例
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			// Caches object obtained from FactoryBean if it is a singleton.
			if (mbd == null && containsBeanDefinition(beanName)) {
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			//如果从容器中得到了bean定义信息，并且bean定义信息不是虚构的，则让工厂bean生产
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			//调用该FactoryBeanRegistrySupport类的getObjectFromFactoryBean方法
			//用工厂bean生产一个指定的bean
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}

        其中最后的getBojectFromFactoryBean方法是使用工厂bean创建bean实例的方法，其中根据：

	protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
		//如果工厂bean创建的bean是单例
		if (factory.isSingleton() && containsSingleton(beanName)) {
			//多线程同步，以防数据不一致
			synchronized (getSingletonMutex()) {
				//获取bean对象实例
				Object object = this.factoryBeanObjectCache.get(beanName);
				//如果为空
				if (object == null) {
					object = doGetObjectFromFactoryBean(factory, beanName);

					//双端检索
					Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
					if (alreadyThere != null) {
						object = alreadyThere;
					}
					else {
						if (shouldPostProcess) {
							try {
								object = postProcessObjectFromFactoryBean(object, beanName);
							}
							catch (Throwable ex) {
								throw new BeanCreationException(beanName,
										"Post-processing of FactoryBean's singleton object failed", ex);
							}
						}
						//将实例对象放入缓存
						this.factoryBeanObjectCache.put(beanName, object);
					}
				}
				return object;
			}
		}
        //否则每次都新建一个
		else {
			Object object = doGetObjectFromFactoryBean(factory, beanName);
			if (shouldPostProcess) {
				try {
					object = postProcessObjectFromFactoryBean(object, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
				}
			}
			return object;
		}
	}

        方法中的大致逻辑就是查看缓存中是否已经存在要创建的目标bean实例，如果存在直接返回，如果不存在，则上锁然后创建bean实例，并再次判断上锁后到创建完这段时间，目标实例是否已经存在于缓存中了，如果不存在，则将实例放入缓存。

        再回到AbstractBeanFactory的doGetBean方法中，如果getSingleton方法未获取到对象，则检查父容器是否为空，并且当前容器中是否有目标bean 的定义，如果父容器不为空并且当前容器中没有目标bean定义，则调用父容器的getBean方法创建bean实例，代码如下：

//如果已经在创建此Bean，则失败
if (isPrototypeCurrentlyInCreation(beanName)) {
	throw new BeanCurrentlyInCreationException(beanName);
}

// Check if bean definition exists in this factory.
//从父工厂中获取Bean的定义
BeanFactory parentBeanFactory = getParentBeanFactory();
//当前容器有父容器并且当前容器没有此bean 的定义
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 {
		
		return parentBeanFactory.getBean(nameToLookup, requiredType);
	}
}

        如果上述条件不满足，则继续往下，判断此次调用doGetBean是否只是用于类型检查而非真正创建bean实例，如果是，则不会将当前bean标记为已创建，如果不是，则将当前bean标记为已创建或者正在创建，然后获取此bean的所有依赖bean，判断其中是否存在循环依赖，即此bean依赖的其他bean中，是否存在也依赖了此bean的情况，如果有，则抛出循环依赖异常。如果没有，将依赖关系注册，并先对依赖bean实例化。

//保证当前bean所依赖的bean的初始化。
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
	for (String dep : dependsOn) {
		//检查此bean 依赖的bean是否也同样依赖此bean，即循环依赖问题
		if (isDependent(beanName, dep)) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
		}
		//注册dep被beanName所依赖，也就是在dependentBeanMap中添加dep：{beanName}
		//所以由此可得dependentBeanMap中的key是bean名称，value是依赖key的其他bean名称
		registerDependentBean(dep, beanName);
		//确保依赖的bean 初始化了
		getBean(dep);
	}
}

                当依赖bean实例化结束后，正式开始本bean的实例化：

    //创建此bean 的实例，
	if (mbd.isSingleton()) {
		//使用匿名内部类创建bean实例对象，并注册给所依赖的对象
		sharedInstance = getSingleton(beanName, () -> {
			try {
				//创建一个指定bean 的实例对象，如果有父类继承，则合并子类和父类的定义
				return createBean(beanName, mbd, args);
			}
			catch (BeansException ex) {
				// Explicitly remove instance from singleton cache: It might have been put there
				// eagerly by the creation process, to allow for circular reference resolution.
				// Also remove any beans that received a temporary reference to the bean.
				//从单例缓存中显式删除实例：它可能是在创建过程中急切地放在那里的
				// 以允许循环引用解析。同时删除所有临时引用该bean的bean。
				destroySingleton(beanName);
				throw ex;
			}
		});
		//获得给定的Bean对象
		bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
	}

           其中，关键方法即createBean，此方法在AbstractBeanFactory中为抽象方法，委托给了子类实现，此处是模板方法，真正的实现是在AbstractAutowireCapableBeanFactory类中，大致逻辑为首先设置好此bean定义对应的class类型，然后为bean中方法覆盖做准备，主要是校验是否有需要覆盖的方法，并且这些方法是否有重载情况，接着判断容器中是否有InstantiationAwareBeanPostProcessor，如果有，则执行对应的方法来创建bean，如果没有则调用doCreateBean方法创建bean：

	@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		if (logger.isDebugEnabled()) {
			logger.debug("Creating instance of bean '" + beanName + "'");
		}
		RootBeanDefinition mbdToUse = mbd;

		// Make sure bean class is actually resolved at this point, and
		// clone the bean definition in case of a dynamically resolved Class
		// which cannot be stored in the shared merged bean definition.
		//判断需要创建的bean是否可以实例化，即是否可以通过当前的类加载器加载
		//resolveBeanClass只是返回此bean定义对应的Class类型
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		// Prepare method overrides.
		//校验和准备bean中方法覆盖
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
			//让InstantiationAwareBeanPostProcessor有机会返回代理而不是目标bean实例。
			//如果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 {
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isDebugEnabled()) {
				logger.debug("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
		catch (BeanCreationException ex) {
			// A previously detected exception with proper bean creation context already...
			throw ex;
		}
		catch (ImplicitlyAppearedSingletonException ex) {
			// An IllegalStateException to be communicated up to DefaultSingletonBeanRegistry...
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
		}
	}

        下面看看doCreateBean方法的逻辑：

	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		//尝试从未完成的factoryBean缓存中移除，如果移除成功，则表示此bean为工厂bean
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		//如果不在factoryBeanInstanceCache中，则创建实例
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		//调用后置处理器
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		//急切地缓存单例，以便能够解析循环引用//即使在由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, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		//bean对象的初始化，依赖注入在此处处理
		Object exposedObject = bean;
		try {
			//将bean实例对象封装，并且将bean定义中配置的属性值赋给实例对象
			populateBean(beanName, mbd, instanceWrapper);
			//初始化bean，为bean实例对象应用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) {
			//获取先前注册的单例bean
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					//初始化完成
					exposedObject = earlySingletonReference;
				}
				//当前bean依赖其他bean，并且当发生循环引用时不允许创建新的实例对象
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					//获取当前bean所依赖的其他bean
					for (String dependentBean : dependentBeans) {
						//对依赖的bean进行类型检查
						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.
		//注册完成依赖注入的bean
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

        首先第一个重要方法为createBeanInstance，用于创建bean实例，主要逻辑是如果bean定义了实例供应方，则从实例供应方获取实例，如果bean定义了工厂方法，则使用工厂方法创建bean实例，否则使用bean的构造函数创建bean实例并包装为BeanWrapper：

	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// Make sure bean class is actually resolved at this point.
		//确保bean已经解析，是可实例化的
		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());
		}
		//如果此bean定义了实例供应方，则通过配置的供应方获取实例
		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		if (mbd.getFactoryMethodName() != null)  {
			//如果此bean指定了工厂方法，则调用指定的工厂方法进行实例化（解析bean定义时候分析过）
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// Shortcut when re-creating the same 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) {
				//配置了自动装配属性，使用容器的自动装配进行实例化
				//容器的自动装配根据参数类型匹配Bean的构造方法
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				//使用默认的无参构造方法进行实例化
				return instantiateBean(beanName, mbd);
			}
		}

		// Need to determine the constructor...
		//使用Bean的构造方法进行实例化
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
			//使用容器的自动装配特性，调用匹配的构造方法进行实例化
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// No special handling: simply use no-arg constructor.
		//没有特殊处理，使用默认的无参构造函数实例化
		return instantiateBean(beanName, mbd);
	}

        接着回到doCreateBean，获得创建的BeanWrapper对象后，判断bean的类型是否为NullBean，如果是NullBean，则不会将此类型标记为已解析类型，接着调用所有的MergedBeanDefinitionPostProcessor后置处理器，以便能够在初始化bean之前对bean定义进行修改，然后判断是否允许循环引用，来决定是否缓存此时未创建完成的bean，以便解析循环引用。

        

final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
//如果bean是NullBean类型（如果创建出来的实例是null，spring会将其转为NullBean类型）
//则不会标记为已解析的类型
if (beanType != NullBean.class) {
	mbd.resolvedTargetType = beanType;
}

// Allow post-processors to modify the merged bean definition.
//调用所有的MergedBeanDefinitionPostProcessor后置处理器，以便能够在初始化前修改bean定义
synchronized (mbd.postProcessingLock) {
	if (!mbd.postProcessed) {
		try {
			applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Post-processing of merged bean definition failed", ex);
		}
		mbd.postProcessed = true;
	}
}

// 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, () -> getEarlyBeanReference(beanName, mbd, bean));
}

        接下来就是bean的初始化，将bean的依赖注入到bean实例中。首先就是populateBean方法：

	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		if (bw == null) {
			//如果bean实例为空，并且bean定义中有property属性，报错，无法应用在空的bean上
			if (mbd.hasPropertyValues()) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			}
			else {
				// 跳过实例属性填充
				return;
			}
		}

		// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
		// state of the bean before properties are set. This can be used, for example,
		// to support styles of field injection.
		//在设置属性之前，让任何InstantionawareBeanPostProcessors有机会修改bean的状态。
		//此标识为了在后置处理器报错时终止初始化操作
		boolean continueWithPropertyPopulation = true;

		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}

		if (!continueWithPropertyPopulation) {
			return;
		}

		//获取bean定义的属性值(比如xml文件中bean标签里头的<property>标签定义的内容)
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

			// Add property values based on autowire by name if applicable.
			//按照名称自动注入
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}

			// Add property values based on autowire by type if applicable.
			//按照类型自动注入
			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) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			if (hasInstAwareBpps) {
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvs == null) {
							return;
						}
					}
				}
			}
			if (needsDepCheck) {
				checkDependencies(beanName, mbd, filteredPds, pvs);
			}
		}

		if (pvs != null) {
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

        其中，自动注入分为了根据名称以及根据类型，我们一个个分析，首先是根据名称：

	protected void autowireByName(
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
		//获取当前bean未被装配的非简单属性名称
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		for (String propertyName : propertyNames) {
			//判断容器中是否存在对应名称的bean
			if (containsBean(propertyName)) {
				//存在就获取
				Object bean = getBean(propertyName);
				//然后添加到属性集合中
				pvs.add(propertyName, bean);
				//再将这些需要注入的bean 注册为当前bean 的依赖
				registerDependentBean(propertyName, beanName);
				if (logger.isDebugEnabled()) {
					logger.debug("Added autowiring by name from bean name '" + beanName +
							"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
				}
			}
			else {
				if (logger.isTraceEnabled()) {
					logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
							"' by name: no matching bean found");
				}
			}
		}
	}

        获取bean中的未被装配的非简单属性名称的方法内容如下：

	protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
		// 用于保存结果，TreeSet可以保证有序且去重
		Set<String> result = new TreeSet<>();
		// 获取当前bean的属性值列表
		PropertyValues pvs = mbd.getPropertyValues();
		// 通过 BeanWrapper 获取当前 bean 的属性描述符数组。
		PropertyDescriptor[] pds = bw.getPropertyDescriptors();
		for (PropertyDescriptor pd : pds) {
			// 符合以下四个条件的，就可以视作未被注入的非简单属性
			// 1. 属性具有setter方法
			// 2. 属性不在依赖检查的排除列表中
			// 3. 属性在当前bean的属性值为空
			// 4. 属性类型不是简单类型
			if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
					!BeanUtils.isSimpleProperty(pd.getPropertyType())) {
				result.add(pd.getName());
			}
		}
		return StringUtils.toStringArray(result);
	}

        下面看看根据类型注入：

	protected void autowireByType(
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

		//获取用户自定义的类型转换器
		TypeConverter converter = getCustomTypeConverter();
		if (converter == null) {
			//BeanWrapper本身也是TypeConverter（继承体系中实现了TypeConverter）
			converter = bw;
		}
		//存放解析的要注入的属性
		Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
		//对Bean对象中非简单属性（如8种原始类型、字符、URL等都是简单属性，不需要Autowire）进行处理，具体方法内容上面已经分析
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		for (String propertyName : propertyNames) {
			try {
				//获取指定属性名称的属性描述器
				PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
				// Don't try autowiring by type for type Object: never makes sense,
				// 不要尝试自动注入Object类型，这永远没有意义
				// 即使他在技术上是一个未被满足注入要求的非简单类型bean
				// even if it technically is a unsatisfied, non-simple property.
				//不对Object类的属性进行自动依赖注入
				if (Object.class != pd.getPropertyType()) {
					//获取属性的赋值方法的参数
					MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
					// Do not allow eager init for type matching in case of a prioritized post-processor.

					// 判断当前 bean 是否是实现了 PriorityOrdered 接口的优先级处理器。
					// 如果是，则不允许在类型匹配时进行急切初始化
					boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
					//创建一个用于描述依赖关系的对象
					DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
					//根据容器的bean定义解析依赖关系，获取自动装配的参数值
					Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
					if (autowiredArgument != null) {
						//获取自动装配参数值成功，则放入属性集合中
						pvs.add(propertyName, autowiredArgument);
					}
					for (String autowiredBeanName : autowiredBeanNames) {
						//为当前指定名称的bean注册所依赖Bean名称，以便在销毁时处理
						registerDependentBean(autowiredBeanName, beanName);
						if (logger.isDebugEnabled()) {
							logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +
									propertyName + "' to bean named '" + autowiredBeanName + "'");
						}
					}
					autowiredBeanNames.clear();
				}
			}
			catch (BeansException ex) {
				throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
			}
		}
	}

        执行完根据类型自动注入后，接着把所有的InstantiationAwareBeanPostProcessor的postProcessPropertyValues方法执行一遍：

		//调用所有InstantiationAwareBeanPostProcessor的postProcessPropertyValues方法
		//其中我们熟知的@Autowire注解就是在AutowiredAnnotationBeanPostProcessor
		//的postProcessPropertyValues方法中进行依赖注入的，通过调用InjectionMetadata类的inject方法
		//主要内容就是利用反射进行依赖注入，感兴趣的可以去追一下源码，逻辑并不复杂
		if (hasInstAwareBpps || needsDepCheck) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			if (hasInstAwareBpps) {
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvs == null) {
							return;
						}
					}
				}
			}
			if (needsDepCheck) {
				checkDependencies(beanName, mbd, filteredPds, pvs);
			}
		}

        populateBean方法就结束了。紧接着是initializeBean方法，主要是执行一些bean的后置处理器以及bean定义的初始化方法：

	protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		//如果bean实例是某些Aware的实现类，那便把相关值赋给此bean（比如BeanFactoryAware，就会把beanFactory赋给此bean，以供使用）
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		//调用后置处理器的before方法
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}
		//调用初始化方法
		try {
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		//调用后置处理器的after方法
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

	private void invokeAwareMethods(final String beanName, final Object bean) {
		if (bean instanceof Aware) {
			if (bean instanceof BeanNameAware) {
				((BeanNameAware) bean).setBeanName(beanName);
			}
			if (bean instanceof BeanClassLoaderAware) {
				ClassLoader bcl = getBeanClassLoader();
				if (bcl != null) {
					((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
				}
			}
			if (bean instanceof BeanFactoryAware) {
				((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
			}
		}
	}

	@Override
	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
			Object current = beanProcessor.postProcessBeforeInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}

	protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {

		boolean isInitializingBean = (bean instanceof InitializingBean);
		if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
			if (logger.isDebugEnabled()) {
				logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
			}
			if (System.getSecurityManager() != null) {
				try {
					AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
						((InitializingBean) bean).afterPropertiesSet();
						return null;
					}, getAccessControlContext());
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
				((InitializingBean) bean).afterPropertiesSet();
			}
		}

		if (mbd != null && bean.getClass() != NullBean.class) {
			String initMethodName = mbd.getInitMethodName();
			if (StringUtils.hasLength(initMethodName) &&
					!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
					!mbd.isExternallyManagedInitMethod(initMethodName)) {
				invokeCustomInitMethod(beanName, bean, mbd);
			}
		}
	}

        这部分逻辑比较简单，不做具体分析。至此bean创建的整个流程便分析完毕了.

三、finishRefresh()

       内容不是很重要，就直接放源码了：

	protected void finishRefresh() {
		// 清除上下文级资源缓存
		//this.resourceCaches.clear();
		clearResourceCaches();

		// 为此上下文初始化生命周期处理器。
		//在bean容器中查找名为lifecycleProcessor，类型为LifecycleProcessor的bean，赋值给this.lifecycleProcessor
		//beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
		//如果没有则往bean容器中放一个DefaultLifecycleProcessor
		initLifecycleProcessor();

		// 首先将刷新传递给生命周期处理器。
		//启动生命周期bean，并标记容器为运行状态 DefaultLifecycleProcessor.onRefresh
		getLifecycleProcessor().onRefresh();

		// 发布最终事件。
		publishEvent(new ContextRefreshedEvent(this));

		// Participate in LiveBeansView MBean, if active.
		LiveBeansView.registerApplicationContext(this);
	}

        至此spring5的源码分析告一段落，之后打算先写Mybatis源码分析，然后是SpringMVC。再然后的话再考虑吧！