Spring源码分析——SpringIOC

最新推荐文章于 2024-07-08 18:16:19 发布

黄俊懿

最新推荐文章于 2024-07-08 18:16:19 发布

阅读量270

点赞数 1

分类专栏： Spring 文章标签： spring java bean ioc

本文链接：https://blog.csdn.net/weixin_43889578/article/details/108024536

版权

Spring 专栏收录该内容

14 篇文章 8 订阅

订阅专栏

Spring源码分析——SpringIOC

Spring源码分析——SpringIOC

Spring源码分析——SpringIOC

开始

在Spring中，有两种配置方式，一种是xml版本的，另外一种是注解版本的。他们分别对应不同的ApplicationContext。xml版本的是ClassPathXmlApplicationContext，而注解版本的是AnnotationConfigApplicationContext。

// 用我们的配置文件来启动一个 ApplicationContext
ApplicationContext context = new ClassPathXmlApplicationContext("classpath:application.xml");

AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);

ApplicationContext子类的构造参数

先看ClassPathXmlApplicationContext的构造方法

org.springframework.context.support.ClassPathXmlApplicationContext#ClassPathXmlApplicationContext(java.lang.String[], boolean, org.springframework.context.ApplicationContext)

	public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {

		super(parent);
		/*简单的把传入进来的配置文件的classpath路径设置到成员变量configLocations中*/
		setConfigLocations(configLocations);
		if (refresh) {
			/*核心部分，进行BeanFactory的创建，扫描配置文件加载BeanDefinition，Bean的创建和初始化*/
			refresh();
		}
	}

然后就是AnnotationConfigApplicationContext的构造方法

org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(java.lang.Class<?>…)

	public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
		this();
		/**
		 * 解析并注册配置类，也就是我们配置的AppConfig
		 * 解析成BeanDefinition，注册到BeanFactory的成员变量beanDefinitionMap中
		 * 这里的BeanFactory就是DefaultListableBeanFactory
		 */
		register(componentClasses);
		/*核心部分，进行BeanFactory的创建，扫描配置文件加载BeanDefinition，Bean的创建和初始化*/
		refresh();
	}

可以发现，就是在调用refresh() 方法前做了不同的处理。然后就调用refresh()方法，refresh方法会调用到父类AbstractApplicationContext的refresh方法。

refresh方法时Spring中最重要的方法了
org.springframework.context.support.AbstractApplicationContext#refresh

	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

			/**
			 * Prepare this context for refreshing.
			 * 准备工作，设置启动状态，记录系统时间（不重要）
			 */
			prepareRefresh();

			/**
			 * 创建DefaultListableBeanFactory，
			 * 扫描并注册BeanDefinition到BeanDefinitionMap中，
			 * 返回这个BeanFactory
			 * 注意：
			 * 	如果是注解的bean，不会在这里注册BeanDefinition到BeanDefinitionMap
			 * 	而是在下面的invokeBeanFactoryPostProcessors里，通过bean工厂后置处理器完成
			 */
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			/**
			 * 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
			 */
			prepareBeanFactory(beanFactory);

			try {
				// 这个是留给ApplicationContext子类的扩展点，允许在子类中对bean工厂进行后处理。
				postProcessBeanFactory(beanFactory);

				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
				// 调用上下文中注册为bean的工厂处理器。
				invokeBeanFactoryPostProcessors(beanFactory);

				// 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
				// 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
				// 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化
				registerBeanPostProcessors(beanFactory);
				beanPostProcess.end();

				// 初始化当前 ApplicationContext 的 MessageSource，国际化
				initMessageSource();

				// 初始化当前 ApplicationContext 的事件广播器
				initApplicationEventMulticaster();

				// 从方法名就可以知道，典型的模板方法(钩子方法)，
				// 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
				onRefresh();

				// 注册事件监听器，监听器需要实现 ApplicationListener 接口
				registerListeners();

				/**
				 * 重点方法：
				 * 初始化所有的 singleton beans
				 */
				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.
				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();
				contextRefresh.end();
			}
		}
	}

上面的方法没必要全都看，我们分析IOC，主要看3个方法就够了

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); 这个是BeanFactory的创建，以及解析配置文件，加载BeanDefinition
invokeBeanFactoryPostProcessors(beanFactory); 这个是触发Bean工厂后置处理器的回调
finishBeanFactoryInitialization(beanFactory); 这个是实例化和初始化所有的bean

BeanFactory的创建，加载BeanDefinition

我们先来看refresh方法中第一个要分析的方法

			/**
			 * 创建DefaultListableBeanFactory，
			 * 扫描并注册BeanDefinition到BeanDefinitionMap中，
			 * 返回这个BeanFactory
			 * 注意：
			 * 	如果是注解的bean，不会在这里注册BeanDefinition到BeanDefinitionMap
			 * 	而是在下面的invokeBeanFactoryPostProcessors里，通过bean工厂后置处理器完成
			 */
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

这个方法里面会创建BeanFactory，具体类型是DefaultListableBeanFactory。并且在创建了DefaultListableBeanFactory之后，会进行配置文件的解析工作，加载BeanDefinition，注册到DefaultListableBeanFactory的beanDefinitionMap中

org.springframework.context.support.AbstractApplicationContext#obtainFreshBeanFactory

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		/* 销毁旧的BeanFactory，创建新的BeanFactory并扫描注册BeanDefinition */
		refreshBeanFactory();
		/* 获取并返回创建的BeanFactory */
		return getBeanFactory();
	}

上面方法分两步

刷新BeanFactory，也就是销毁旧的BeanFactory，创建新的BeanFactory。然后还会加载BeanDefinition
获取并返回BeanFactory

我们只要看第一步就可以，因为第一步走完以后，BeanFactory就已经保存在AbstractRefreshableApplicationContext的成员变量中了，也就是当前ApplicationContext实现类的父类的成员变量，所以只是返回成员变量而已。

org.springframework.context.support.AbstractRefreshableApplicationContext#refreshBeanFactory

	@Override
	protected final void refreshBeanFactory() throws BeansException {
		/**
		 * 检查当前ApplicationContext是否已经有启动的BeanFactory
		 * 如果有，则销毁Bean，关闭BeanFactory
		 */
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			/*创建DefaultListableBeanFactory*/
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			/*设置BeanFactory的两个属性：是否允许 Bean 覆盖、是否允许循环引用*/
			customizeBeanFactory(beanFactory);
			/*加载 BeanDefinition 到 BeanFactory 中*/
			loadBeanDefinitions(beanFactory);
			/*保存此BeanFactory到成员变量*/
			this.beanFactory = beanFactory;
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

先销毁所有的bean，关闭旧的工厂
创建DefaultListableBeanFactory
设置两个重要的属性到DefaultListableBeanFactory中：allowBeanDefinitionOverriding-是否允许Bean覆盖，allowCircularReferences-是否允许循环依赖
加载BeanDefinition

我们直接看的4步，BeanDefinition的加载

org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory)

	@Override
	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		/**
		 * Create a new XmlBeanDefinitionReader for the given BeanFactory.
		 * 创建XmlBeanDefinitionReader，他的功能是解析配置文件并加载BeanDefinition
		 */
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		// Configure the bean definition reader with this context's
		// resource loading environment.
		beanDefinitionReader.setEnvironment(this.getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

		// Allow a subclass to provide custom initialization of the reader,
		// then proceed with actually loading the bean definitions.
		initBeanDefinitionReader(beanDefinitionReader);

		/* 解析配置文件，加载并注册BeanDefinition */
		loadBeanDefinitions(beanDefinitionReader);
	}

创建一个XmlBeanDefinitionReader，很明显到时候xml配置文件就是通过他来解析
loadBeanDefinitions(beanDefinitionReader); 解析配置文件，加载并注册BeanDefinition

这里直接看最后一步
org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.xml.XmlBeanDefinitionReader)

	protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
		/**
		 * 当前如果已经有加载的Resource，则先进行前期BeanDefinition的加载
		 * 一般是扩展的子ApplicationContext预设的BeanDefinition
		 * 这里为空，所以先不走
		 */
		Resource[] configResources = getConfigResources();
		if (configResources != null) {
			reader.loadBeanDefinitions(configResources);
		}
		/**
		 * 这里是读取配置文件成Resource,并解析加载BeanDefinition的步骤，
		 * 会走到上面的loadBeanDefinitions(Resource...)方法
		 */
		String[] configLocations = getConfigLocations();
		if (configLocations != null) {
			reader.loadBeanDefinitions(configLocations);
		}
	}

这里有两个分支

如果当有加载了的Resource，则先走上面一个分支，进行预设的配置加载
如果没有预设的Resource，则走下面一步，读取配置文件成Resource对象

但是其实下面一步走后还是会走到上面的方法中。这里一进来，会先走下面一个分支，因为现在没有任何预先加载的Resource对象

org.springframework.beans.factory.support.AbstractBeanDefinitionReader#loadBeanDefinitions(java.lang.String…)

	@Override
	public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
		Assert.notNull(locations, "Location array must not be null");
		int count = 0;
		for (String location : locations) {
			/*遍历配置文件路径，并一个个加载解析*/
			count += loadBeanDefinitions(location);
		}
		return count;
	}

这里会遍历所有的配置文件路径，解析配置文件。但是我们只传入了一个，通常也只会传入一个，所以这里可以当成是一个配置文件的解析，循环只会走一遍。

org.springframework.beans.factory.support.AbstractBeanDefinitionReader#loadBeanDefinitions(java.lang.String, java.util.Set<org.springframework.core.io.Resource>)

	public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
		ResourceLoader resourceLoader = getResourceLoader();
		...
		if (resourceLoader instanceof ResourcePatternResolver) {
			try {
				/*读取当前的xml配置文件，成一个resources数组*/
				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
				/*走到之前的loadBeanDefinitions(Resource...)方法，解析Resource成BeanDefinition*/
				int count = loadBeanDefinitions(resources);
				...
				return count;
			}
			catch (IOException ex) {
				...
			}
		}
		else {
			...
		}
	}

读取当前的xml配置文件，成一个resources数组
解析Resource，加载BeanDefinition。这里会走到之前loadBeanDefinitions方法的上面一个分支里的方法

我们直接看第二步

org.springframework.beans.factory.support.AbstractBeanDefinitionReader#loadBeanDefinitions(org.springframework.core.io.Resource…)

	@Override
	public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
		Assert.notNull(resources, "Resource array must not be null");
		int count = 0;
		for (Resource resource : resources) {
			/*遍历解析Resource，加载BeanDefinition*/
			count += loadBeanDefinitions(resource);
		}
		return count;
	}

遍历Resource，并调用loadBeanDefinitions的另外一个重载的方法，也就是刚刚进来跳过没走的那个分支。

org.springframework.beans.factory.xml.XmlBeanDefinitionReader#loadBeanDefinitions(org.springframework.core.io.Resource)

	@Override
	public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
		/*把resouce封装成EncodedResource*/
		return loadBeanDefinitions(new EncodedResource(resource));
	}

有调了loadBeanDefinitions的另外一个重载的方法，继续点进去

org.springframework.beans.factory.xml.XmlBeanDefinitionReader#loadBeanDefinitions(org.springframework.core.io.support.EncodedResource)

	public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
		...

		Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();

		...
		/**
		 * 获取当前配置文件的输入流，封装成InputSource
		 * 并执行BeanDefinitions的加载
		 */
		try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
			InputSource inputSource = new InputSource(inputStream);
			if (encodedResource.getEncoding() != null) {
				inputSource.setEncoding(encodedResource.getEncoding());
			}
			/*真正开始BeanDefinition的加载，在spring中，但凡是doxxx的方法，代表要真正开始，而前面都是铺垫*/
			return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
		}
		catch (IOException ex) {
			...
		}
		finally {
			currentResources.remove(encodedResource);
			if (currentResources.isEmpty()) {
				this.resourcesCurrentlyBeingLoaded.remove();
			}
		}
	}

这里要调用doLoadBeanDefinitions方法，开始真正的BeanDefinition加载工作

org.springframework.beans.factory.xml.XmlBeanDefinitionReader#doLoadBeanDefinitions

	protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {

		try {
			/*解析成Document对象*/
			Document doc = doLoadDocument(inputSource, resource);
			/*执行BeanDefinition的解析注册*/
			int count = registerBeanDefinitions(doc, resource);
			if (logger.isDebugEnabled()) {
				logger.debug("Loaded " + count + " bean definitions from " + resource);
			}
			return count;
		}
		catch ...
	}

解析配置文件，获取Document对象
根据Document对象，加载BeanDefinition

我们看第二步

org.springframework.beans.factory.xml.XmlBeanDefinitionReader#registerBeanDefinitions

	public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		/*创建BeanDefinitionDocumentReader对象*/
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		int countBefore = getRegistry().getBeanDefinitionCount();
		/*解析Document并注册BeanDefinition*/
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}

创建BeanDefinitionDocumentReader对象
解析Document并注册BeanDefinition

我们看第二步

org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#registerBeanDefinitions

	@Override
	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		/*获取Document中的Element节点(root)并解析*/
		doRegisterBeanDefinitions(doc.getDocumentElement());
	}

获取根节点，并从根节点开始解析

org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions

	protected void doRegisterBeanDefinitions(Element root) {
		// 我们看名字就知道，BeanDefinitionParserDelegate 必定是一个重要的类，它负责解析 Bean 定义，
		// 这里为什么要定义一个 parent? 看到后面就知道了，是递归问题，
		// 因为 <beans /> 内部是可以定义 <beans /> 的，所以这个方法的 root 其实不一定就是 xml 的根节点，也可以是嵌套在里面的 <beans /> 节点，
		// 从源码分析的角度，我们当做根节点就好了
		BeanDefinitionParserDelegate parent = this.delegate;
		this.delegate = createDelegate(getReaderContext(), root, parent);

		if (this.delegate.isDefaultNamespace(root)) {
			String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
			if (StringUtils.hasText(profileSpec)) {
				String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
						profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
				// We cannot use Profiles.of(...) since profile expressions are not supported
				// in XML config. See SPR-12458 for details.
				if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
					if (logger.isDebugEnabled()) {
						logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
								"] not matching: " + getReaderContext().getResource());
					}
					return;
				}
			}
		}

		preProcessXml(root);
		/*通过BeanDefinitionParserDelegate解析当前节点*/
		parseBeanDefinitions(root, this.delegate);
		postProcessXml(root);

		this.delegate = parent;
	}

我们直接看parseBeanDefinitions(root, this.delegate);，其他的忽略

org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseBeanDefinitions

	protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
		if (delegate.isDefaultNamespace(root)) {
			NodeList nl = root.getChildNodes();
			for (int i = 0; i < nl.getLength(); i++) {
				Node node = nl.item(i);
				if (node instanceof Element) {
					Element ele = (Element) node;
					if (delegate.isDefaultNamespace(ele)) {
						/*默认的标签*/
						parseDefaultElement(ele, delegate);
					}
					else {
						/*自定义的标签*/
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
			/*自定义的标签*/
			delegate.parseCustomElement(root);
		}
	}

这里有两种情况

默认标签的解析，就是spring原生的标签
自定义标签的解析，就是其他和spring做整合的框架提供的标签

我们看默认标签的解析

org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseDefaultElement

	private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			importBeanDefinitionResource(ele);
		}
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
			processAliasRegistration(ele);
		}
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
			/*<bean/>解析*/
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}

这里涉及四种标签的解析，我们只看最简单的bean标签的解析

	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		/*解析当前bean节点为为BeanDefinition，并用BeanDefinitionHolder进行包装*/
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				/**
				 * 里面会调用到DefaultListableBeanFactory的registerBeanDefinition重写方法
				 * 把该BeanDefinition注册到DefaultListableBeanFactory的成员变量beanDefinitionMap中
				 * this.beanDefinitionMap.put(beanName, beanDefinition);
				 */
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				...
			}
			...
		}
	}

processBeanDefinition方法中，当前的流程分两步

解析当前bean节点为为BeanDefinition，并用BeanDefinitionHolder进行包装
把BeanDefinition注册到DefaultListableBeanFactory的成员变量beanDefinitionMap中

我们先看第一步

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(org.w3c.dom.Element)

	@Nullable
	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
		return parseBeanDefinitionElement(ele, null);
	}

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(org.w3c.dom.Element, org.springframework.beans.factory.config.BeanDefinition)

	@Nullable
	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
		String id = ele.getAttribute(ID_ATTRIBUTE);
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

		List<String> aliases = new ArrayList<>();
		// 将 name 属性的定义按照 ”逗号、分号、空格“ 切分，形成一个别名列表数组，
		if (StringUtils.hasLength(nameAttr)) {
			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			aliases.addAll(Arrays.asList(nameArr));
		}

		String beanName = id;
		// 如果没有指定id, 那么用别名列表的第一个名字作为beanName
		if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
			beanName = aliases.remove(0);
			...
		}

		if (containingBean == null) {
			checkNameUniqueness(beanName, aliases, ele);
		}

		// 根据 <bean ...>...</bean> 中的配置创建 BeanDefinition，然后把配置中的信息都设置到实例中
		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		// 到这里，整个 <bean /> 标签就算解析结束了，一个 BeanDefinition 就形成了
		if (beanDefinition != null) {
			// 如果都没有设置 id 和 name，那么此时的 beanName 就会为 null，进入下面这块代码产生
			if (!StringUtils.hasText(beanName)) {
				try {
					if (containingBean != null) {
						beanName = BeanDefinitionReaderUtils.generateBeanName(
								beanDefinition, this.readerContext.getRegistry(), true);
					}
					else {
						beanName = this.readerContext.generateBeanName(beanDefinition);
						String beanClassName = beanDefinition.getBeanClassName();
						if (beanClassName != null &&
								beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
								!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
							aliases.add(beanClassName);
						}
					}
					...
				}
				catch (Exception ex) {
				...
				}
			}
			String[] aliasesArray = StringUtils.toStringArray(aliases);
			// 返回 BeanDefinitionHolder
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
		}

		return null;
	}

这里重点方法就是中间的 AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); 其他可以不用看。这里就是Bean标签的解析，BeanDefinition的加载，
然后返回的BeanDefinition在最后被包装成BeanDefinitionHolder返回

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(org.w3c.dom.Element, java.lang.String, org.springframework.beans.factory.config.BeanDefinition)

	@Nullable
	public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, @Nullable BeanDefinition containingBean) {

		...

		try {
			// 创建 BeanDefinition
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);

			// 设置 BeanDefinition 的一堆属性，这些属性定义在 AbstractBeanDefinition 中
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

			/**
			 * 下面的一堆是解析 <bean>......</bean> 内部的子元素，
			 * 解析出来以后的信息都放到 bd 的属性中
			 */

			// 解析 <meta />
			parseMetaElements(ele, bd);
			// 解析 <lookup-method />
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			// 解析 <replaced-method />
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
			// 解析 <constructor-arg />
			parseConstructorArgElements(ele, bd);
			// 解析 <property />
			parsePropertyElements(ele, bd);
			// 解析 <qualifier />
			parseQualifierElements(ele, bd);

			bd.setResource(this.readerContext.getResource());
			bd.setSource(extractSource(ele));

			return bd;
		}
		catch ...

		return null;
	}

可以看到这里要进行标签的解析了，包括bean标签本身的属性（id，name，class，scope，是否懒加载…），以及他嵌套的其他标签

细枝末节就不看了，bean标签的解析看到这里接续，这里就会返回BeanDefinition，然后再外面就被包装为BeanDefinitionHolder返回了

然后回到processBeanDefinition方法中，看第二步，就是把BeanDefinition注册到DefaultListableBeanFactory的成员变量beanDefinitionMap中

/**
 * 里面会调用到DefaultListableBeanFactory的registerBeanDefinition重写方法
 * 把该BeanDefinition注册到DefaultListableBeanFactory的成员变量beanDefinitionMap中
 * this.beanDefinitionMap.put(beanName, beanDefinition);
 */
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

org.springframework.beans.factory.support.BeanDefinitionReaderUtils#registerBeanDefinition

	public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// 获取该BeanDefinition的beanName
		String beanName = definitionHolder.getBeanName();
		// 注册这个 Bean
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// 如果还有别名的话，也要根据别名统统注册一遍
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
	}

这里会获取beanName作为key，BeanDefinition作为value，进行注册。下面是注册别名。

我们直接看Bean的注册

org.springframework.beans.factory.support.DefaultListableBeanFactory#registerBeanDefinition

	@Override
	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		...
		
		/*查看此beanName是否已有注册的BeanDefinition*/
		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
		if (existingDefinition != null) {
			/*如果“允许BeanDefinition覆盖”属性为false，则抛出异常*/
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
			}
			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
				...
			}
			else if (!beanDefinition.equals(existingDefinition)) {
				...
			}
			else {
				...
			}
			/* 注册BeanDefinition，其实就是放到一个map中 */
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
			if (hasBeanCreationStarted()) {
				...
			}
			else {
				// 最正常的应该是进到这里。
				// 将 BeanDefinition 放到这个 map 中
				this.beanDefinitionMap.put(beanName, beanDefinition);
				// 这是个 ArrayList，所以会按照 bean 配置的顺序保存每一个注册的 Bean 的名字
				this.beanDefinitionNames.add(beanName);
				removeManualSingletonName(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}
		...
	}

可以看到调用的是DefaultListableBeanFactory重写的方法，this.beanDefinitionMap.put(beanName, beanDefinition); 就是把BeanDefinition放到成员变量beanDefinitionMap，他就是一个Map。

然后依次类推加载完成所有的标签，然后就会返回创建好的DefaultListableBeanFactory，此时他已经报错了所有的BeanDefinition，除了注解方式声明的Bean。因为在AnnotationConfigApplicationContext是没有xml配置文件的，我们传递给他的构造函数的参数是一个配置类的class，他只会在refresh方法执行前先加载这个类，变成BeanDefinition，另外的Bean，要等到refresh方法中的下一步 invokeBeanFactoryPostProcessors(beanFactory); 当中完成。这个也是 AnnotationConfigApplicationContext 和 ClassPathXmlApplicationContext 的另外一个不同点。实际上他们俩的不同，仅限于在配置文件到BeanDefinition的阶段，由BeanDefinition到Bean（也就是Bean的实例化和初始化）这个阶段，他们的逻辑是一样的，因为都是调用父类的方法。

调用上下文中注册为bean的工厂处理器

BeanFactory的创建和BeanDefinition的加载完毕以后，回到refresh方法中，这是已经返回了beanFactory，以ConfigurableListableBeanFactory类型接收。后面会走以下两步方法

// 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
prepareBeanFactory(beanFactory);

// 这个是留给ApplicationContext子类的扩展点，允许在子类中对bean工厂进行后处理。
postProcessBeanFactory(beanFactory);

但是不是我们分析的重点，所以不看，直接进入下一步，触发所以已注册的Bean工厂后置处理器的回调，首先看看什么是Bean工厂后置处理器

@FunctionalInterface
public interface BeanFactoryPostProcessor {
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

这个就是Bean工厂后置处理器的接口，实现了这个接口的实现类就是Bean工厂的后置处理器，实现类实现的方法postProcessBeanFactory，会在BeanFactory创建完毕并且BeanDefinition加载后，的得到回调。运行我们去对BeanFactory做一些操作，例如继续往里面添加机构BeanDefinition，或者修改里面的信息

回到refresh方法中，现在refresh方法中走到这一步

// 调用上下文中注册为bean的工厂处理器。
invokeBeanFactoryPostProcessors(beanFactory);

org.springframework.context.support.AbstractApplicationContext#invokeBeanFactoryPostProcessors

	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		/**
		 * 这里主要工作是:
		 * 执行所有的注册到Spring中的BeanFactoryPostProcessor的实现类的postProcessBeanFactory方法
		 *
		 * 但是会在此之前先处理：
		 * 调用容器中所有实现了BeanDefinitionRegistryPostProcessor的实现类的postProcessBeanDefinitionRegistry方法
		 * 而BeanDefinitionRegistryPostProcessor又继承了BeanFactoryPostProcessor
		 * 其中Spring-Mybatis就是利用这个方法进行Mapper的扫描和注册成BeanDefinition
		 */
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		...
	}

org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory, java.util.List<org.springframework.beans.factory.config.BeanFactoryPostProcessor>)

	public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

		// 首先执行 BeanDefinitionRegistryPostProcessors , 如果有的话.
		Set<String> processedBeans = new HashSet<>();

		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
			/**
			 * 循环遍历所有的BeanFactoryPostProcessor，
			 * 发现是BeanDefinitionRegistryPostProcessor类型，
			 * 则调用他的postProcessBeanDefinitionRegistry.
			 * 把BeanDefinitionRegistry对象传入进去，
			 * 所以这里允许BeanDefinitionRegistryPostProcessor可以继续像容器注册一些额外的BeanDefinition
			 * 例如Spring-Mybatis中注册了所有扫描到的Mapper
			 */
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}

			// Do not initialize FactoryBeans here: We need to leave all regular beans
			// uninitialized to let the bean factory post-processors apply to them!
			// Separate between BeanDefinitionRegistryPostProcessors that implement
			// PriorityOrdered, Ordered, and the rest.
			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

			// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			/* 通过BeanFactoryPostProcesser完成注解版BeanDefinition的解析注册 */
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
			currentRegistryProcessors.clear();

			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
			currentRegistryProcessors.clear();

			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					if (!processedBeans.contains(ppName)) {
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						processedBeans.add(ppName);
						reiterate = true;
					}
				}
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
				currentRegistryProcessors.clear();
			}

			// 现在, 执行所有工厂后置处理器的 postProcessBeanFactory 回调方法
			/* 再次执行BeanFactoryPostProcesser完成cglib代理 */
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

		else {
			// Invoke factory processors registered with the context instance.
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}

		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let the bean factory post-processors apply to them!
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
			}
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// Finally, invoke all other BeanFactoryPostProcessors.
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		// Clear cached merged bean definitions since the post-processors might have
		// modified the original metadata, e.g. replacing placeholders in values...
		beanFactory.clearMetadataCache();
	}

这里方法很长步骤很多，首先是先触发BeanDefinitionRegistryPostProcessors的子类的回调，执行他的则调用他的postProcessBeanDefinitionRegistry方法，BeanDefinitionRegistryPostProcessors也实现了BeanFactoryPostProcessor 接口，所以也是特殊的Bean工厂后置处理器。

然后注解版的Bean这样在这里加载并注册

最后就会进行BeanFactoryPostProcesser的回调

实例化并初始化所有的Bean

现在Bean工厂的后置处理器回调已经完成，回到refresh方法中。

接下啦是注册 BeanPostProcessor 的实现类，也就是Bean后置处理，Bean工厂后置处理器是作用域BeanFactory的，而Bean后置处理器是作用于Bean的。

// 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
// 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
// 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化
registerBeanPostProcessors(beanFactory);

这里就不展开了

然后是国际化

// 初始化当前 ApplicationContext 的 MessageSource，国际化
initMessageSource();

也不展开，然后是

// 初始化当前 ApplicationContext 的事件广播器
initApplicationEventMulticaster();

也不展开，然后是

// 从方法名就可以知道，典型的模板方法(钩子方法)，
// 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
onRefresh();

onRrefresh方法时留给子类的一个扩展点，例如在SpringBoot中，就是通过这个方法，完成Tomcat的手动启动，这里不展开

注册事件监听器

// 注册事件监听器，监听器需要实现 ApplicationListener 接口
registerListeners();

下面进入重点方法，bean的实例化和初始化

// 实例化和初始化所有的bean
finishBeanFactoryInitialization(beanFactory);

org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization

	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// 首先，初始化名字为 conversionService 的 Bean
		// 初始化的动作包装在 beanFactory.getBean(...) 中
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		...

		// 先初始化 LoadTimeWeaverAware 类型的 Bean
		// 一般用于织入第三方模块，在 class 文件载入 JVM 的时候动态织入，
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}
		...

		// 开始初始化
		beanFactory.preInstantiateSingletons();
	}

我们直接看最后一步 beanFactory.preInstantiateSingletons();

org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons

	@Override
	public void preInstantiateSingletons() throws BeansException {
		...
		/* 获取先前扫描注册BeanDefinition是保存的beanNames */
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// 触发所有的非懒加载的 singleton beans 的初始化操作
		for (String beanName : beanNames) {
			// 合并父 Bean 中的配置，注意 <bean id="" class="" parent="" /> 中的 parent
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			// 非抽象、非懒加载的 singletons。如果配置了 'abstract = true'，那是不需要初始化的
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				// 处理 FactoryBean
				if (isFactoryBean(beanName)) {
					// FactoryBean 的话，在 beanName 前面加上 ‘&’ 符号。再调用 getBean，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(beanName) 这个方法就可以进行初始化了
					getBean(beanName);
				}
			}
		}

		...
	}

这里首先从DefaultListableBeanFactory的成员变量beanDefinitionNames中获取所有的beanName，这是之前加载BeanDefinition时注册进去的。然后遍历所有的beanName，调用getBean方法。

org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)

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

org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean

	protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {

		// 获取一个 “正统的” beanName，处理两种情况，一个是前面说的 FactoryBean(前面带 ‘&’)，
		// 一个是别名问题，因为这个方法是 getBean，获取 Bean 用的，你要是传一个别名进来，是完全可以的
		String beanName = transformedBeanName(name);

		// 注意跟着这个，这个是返回值
		Object bean;

		/**
		 * 尝试从BeanFactory的三个缓存池中获取该bean
		 * 获取得到则返回，不走下面的创建初始化方法。
		 * 此处作用：
		 * 1.给已经创建过的bean，再调getBean是获取该bean
		 * 2.处理循环依赖时返回该bean的半成品（已创建未初始化）
		 */
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isTraceEnabled()) {
				...
			}
			// 下面这个方法：如果是普通 Bean 的话，直接返回 sharedInstance，
			// 如果是 FactoryBean 的话，返回它创建的那个实例对象
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		/*第一次getBean，就会进入else分支*/
		else {
			// 当前线程已经创建过了此 beanName 的 prototype 类型的 bean，那么抛异常
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// 检查一下这个 BeanDefinition 在容器中是否存在
			BeanFactory parentBeanFactory = getParentBeanFactory();
			/* 父容器不为空，且当前容器不存在此BeanDefinition */
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// 如果当前容器不存在这个 Binition，试试父容器中有没有eanDef
				String nameToLookup = originalBeanName(name);
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly);
				}
				else if (args != null) {
					// Delegation to parent with explicit args.
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else if (requiredType != null) {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
				else {
					return (T) parentBeanFactory.getBean(nameToLookup);
				}
			}

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

			try {
				StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
						.tag("beanName", name);
				if (requiredType != null) {
					beanCreation.tag("beanType", requiredType::toString);
				}
				/* 准备创建bean，先获取BeanDefinition */
				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);
						try {
							// 先初始化被依赖项
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				// singleton 实例的创建分支
				if (mbd.isSingleton()) {
					/* getSingleton会在里面调用此匿名内部类ObjectFactory创建Bean */
					sharedInstance = getSingleton(beanName, () -> {
						try {
							/* 真正创建Bean的方法 */
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							destroySingleton(beanName);
							throw ex;
						}
					});
					/**
					 * 获取真正的返回值：
					 * 如果是putongbean，就是此sharedInstance对象
					 * 如果是FactoryBean：
					 * 	1.beanName前带&，则返回该FactoryBean
					 * 	2.否则返回给FactoryBean的getObject返回的Bean
					 */
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

				// prototype 实例的创建分支
				else if (mbd.isPrototype()) {
					// It's a prototype -> create a new instance.
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				// 如果不是 singleton 和 prototype 的话，需要委托给相应的实现类来处理
				else {
					String scopeName = mbd.getScope();
					if (!StringUtils.hasLength(scopeName)) {
						throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
					}
					Scope scope = this.scopes.get(scopeName);
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
					}
					try {
						Object scopedInstance = scope.get(beanName, () -> {
							beforePrototypeCreation(beanName);
							try {
								return createBean(beanName, mbd, args);
							}
							finally {
								afterPrototypeCreation(beanName);
							}
						});
						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
					catch (IllegalStateException ex) {
						throw new ScopeNotActiveException(beanName, scopeName, ex);
					}
				}
				beanCreation.end();
			}
			catch (BeansException ex) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}

		// 最后，检查一下类型对不对，不对的话就抛异常，对的话就返回了
		if (requiredType != null && !requiredType.isInstance(bean)) {
			try {
				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
				if (convertedBean == null) {
					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
				}
				return convertedBean;
			}
			catch (TypeMismatchException ex) {
				if (logger.isTraceEnabled()) {
					...
				}
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		return (T) bean;
	}

这里方法很长，但是我们只要看一下几步就可以了

Object sharedInstance = getSingleton(beanName); 先尝试从单例缓存池中获取
sharedInstance = getSingleton(beanName, () -> {}）singleton 实例的创建，getSingleton会在里面调用此匿名内部类ObjectFactory创建Bean
createBean(beanName, mbd, args); 匿名内部类ObjectFactory的方法，真正创建Bean的方法

尝试从单例缓存池中获取

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String)

	@Override
	@Nullable
	public Object getSingleton(String beanName) {
		/* allowEarlyReference为true表示允许循环引用 */
		return getSingleton(beanName, true);
	}

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean)

	@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		/*如果从一级缓存取到则直接返回，一般出现在获取已经完成的bean，或者单向引用 */
		Object singletonObject = this.singletonObjects.get(beanName);
		/*获取不到且当前beanName对应的Bean正在创建中（实例化后初始化前）*/
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				/*先从二级缓存中取*/
				singletonObject = this.earlySingletonObjects.get(beanName);
				/*二级完成取不到 && 允许循环引用*/
				if (singletonObject == null && allowEarlyReference) {
					/*从三级缓存中获取当前Bean对应的ObjectFactory */
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						/*获取到了，则调用getObject，获取当前正在创建中的对象*/
						singletonObject = singletonFactory.getObject();
						/*添加到二级缓存*/
						this.earlySingletonObjects.put(beanName, singletonObject);
						/*从三级缓存中删除，下次就直接从二级缓存中取了*/
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
	}

这里第一次进来，肯定啥都取不到的，所以返回null

从缓存池取不到，则创建bean

创建bean前后的工作，进行标记

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, org.springframework.beans.factory.ObjectFactory<?>)

	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "Bean name must not be null");
		synchronized (this.singletonObjects) {
			// 尝试从一级缓存中获取，但是第一次进来还是null
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) {
				// 判断当前实例化的bean是否正在销毁的集合里面
				if (this.singletonsCurrentlyInDestruction) {
					throw new BeanCreationNotAllowedException(beanName,
							"Singleton bean creation not allowed while singletons of this factory are in destruction " +
							"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
				}
				if (logger.isDebugEnabled()) {
					...
				}
				/**
				 * 当spring觉得可以着手来创建bean的时候首先便是调用beforeSingletonCreation(beanName)
				 * 判断当前正在实例化的bean是否存在正在创建的集合当中
				 * 当他需要正式创建bean的时候他会记录一下这个bean正在创建(add到一个set集合当中)
				 * 其实这个集合主要是为了循环依赖服务的
				 */
				beforeSingletonCreation(beanName);
				boolean newSingleton = false;
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<>();
				}
				try {
					/**
					 * 调用ObjectFactory对象的getObject方法创建并初始化bean
					 * 就是外面那个lamda表达式
					 * 这一步走完，一个bean的创建和初始就完成了
					 */
					singletonObject = singletonFactory.getObject();
					newSingleton = true;
				}
				catch (IllegalStateException ex) {
					...
				}
				catch (BeanCreationException ex) {
					...
				}
				finally {
					if (recordSuppressedExceptions) {
						this.suppressedExceptions = null;
					}
					/*创建完成以后，把beanName从正在创建中的集合中remove掉 */
					afterSingletonCreation(beanName);
				}
				if (newSingleton) {
					// 添加到一级缓存
					addSingleton(beanName, singletonObject);
				}
			}
			return singletonObject;
		}
	}

这里可以看到，spring在创建bean前后，会进行标记的添加和删除工作，表示当前bean正在创建，而创建完毕了，就删除此标签

标签的添加
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#beforeSingletonCreation

	protected void beforeSingletonCreation(String beanName) {
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
	}

当前bean的beanName添加到singletonsCurrentlyInCreation，代表要正在创建这个bean了

创建完毕，删除标签
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#afterSingletonCreation

	protected void afterSingletonCreation(String beanName) {
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
			throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
		}
	}

从singletonsCurrentlyInCreation中把beanName删除

而singletonsCurrentlyInCreation其实是一个set集合

然后真正bean的创建工作在中间这一行

/**
 * 调用ObjectFactory对象的getObject方法创建并初始化bean
 * 就是外面那个lamda表达式
 * 这一步走完，一个bean的创建和初始就完成了
 */
singletonObject = singletonFactory.getObject();

这里的singletonFactory对象是一个ObjectFactory类型，就是外边的那个lambda表达式，里面会调用
createBean(beanName, mbd, args);方法进行bean的创建

bean的生命周期

下面开始分析Bean的实例化和初始化，也就是bean的生命周期，当然BeanDefinition的加载也可以纳入到bean的生命周期

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])

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

		...
		RootBeanDefinition mbdToUse = mbd;

		/* 通过BeanDefinition获取该bean的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 />
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			...
		}

		try {
			// 让 BeanPostProcessor 在这一步有机会返回代理，而不是 bean 实例，InstantiationAwareBeanPostProcessor
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) { // 如果返回了代理，则不会走下面的创建流程
				return bean;
			}
		}
		catch (Throwable ex) {
			...
		}

		try { 
			/* 上面的Class对象已经保存到mbdToUse, 创建 bean */
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			...
			return beanInstance;
		}
		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
			...
		}
		catch (Throwable ex) {
			...
		}
	}

我们直接看doCreateBean方法

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean

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

		// 实例化bean
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			// 实例化 Bean，这里非常关键
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// 涉及接口：MergedBeanDefinitionPostProcessor, 允许 post-processors 修改合并后的bean definition
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					...
				}
				mbd.postProcessed = true;
			}
		}

		/**
		 * createBeanInstance(beanName, mbd, args)实例化后，初始化前
		 * 判断是否支持循环引用，是否单例 && 支持循环引用 && 正在创建中（beanName在singletonsCurrentlyInCreation中）
		 * this.allowCircularReferences默认为true
		 * 这里为了解决循环引用，先缓存一个工厂，存放实例化后初始化前的单例
		 * org.springframework.beans.factory.ObjectFactory<T>
		 *     T getObject()
		 */
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			...
			/*在二级缓存中，存放当前bean对应的工厂*/
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// 初始化bean实例.
		Object exposedObject = bean;
		try {
			// 这一步也是非常关键的，这一步负责属性装配，因为前面的实例只是实例化了，并没有设值，这里就是设值
			// 并且标注了@PostConstruct的方法，也会在此调用，属于初始化回调
			populateBean(beanName, mbd, instanceWrapper);
			/**
			 * 执行各种初始化回调，标签中有init-method属性的，执行init-method指向的方法
			 * 实现了InitializingBean 接口接口的执行重写的afterPropertiesSet()方法
			 * 执行各种BeanPostProcessor实现类的两个回调方法（Before & After）
			 */
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		catch (Throwable ex) {
			...
		}

		/**
		 * 这里也涉及循环引用的问题：
		 * 此时该bean已经实例化完成，执行了BeanPostProcesser的两个回调方法，
		 * 有可能该Bean的类型已经改变，也就是说和他实例化时的类型不一致，
		 * 因为循环引用是在该bean在实例化后初始化前提前暴露，让别的bean引用而完成的
		 * 此时已经是该bean初始化完成，如果类型不一致，又检测到有其他已经创建完成的bean依赖了这个bean，就会报错
		 */
		if (earlySingletonExposure) {
			// 尝试从缓存中获取单例，注意后面的参数为false，表示不从第三级缓存singletonFactories中获取，为什么呢？因为这里不允许循环依赖
			Object earlySingletonReference = getSingleton(beanName, false);
			//如果不为null，就会进入if条件中，因为earlySingletonReference不为null，说明存在循环引用，
			//为什么呢？因为第一个处理的时候，会将引用放到singletonFactories缓存中，当循环依赖注入的时候，
			//会通过singletonFactories中拿到提前暴露的引用，然后放到第二级缓存earlySingletonObjects中。
			//所以，在这里拿到了earlySingletonReference，表明存在循环引用。
			if (earlySingletonReference != null) {
				//如果相等，那么就什么也不做，将earlySingletonReference返回回去即可
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				/**
				 * 下面就是类型不相等的处理
				 * 类型不相等 && 已经有创建完成的bean依赖此Bean
				 * 满足这两个条件，就报错
				 */
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					for (String dependentBean : dependentBeans) {
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
					if (!actualDependentBeans.isEmpty()) {
						throw new BeanCurrentlyInCreationException(beanName,
								"Bean with name '" + beanName + "' has been injected into other beans [" +
								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
								"] in its raw version as part of a circular reference, but has eventually been " +
								"wrapped. This means that said other beans do not use the final version of the " +
								"bean. This is often the result of over-eager type matching - consider using " +
								"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		// Register bean as disposable.
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

这里有涉及到循环依赖的处理，我们先忽略，我们只关心Bean的生命周期的过程。重要步骤不多，只是注释比较多

instanceWrapper = createBeanInstance(beanName, mbd, args); 实例化bean
populateBean(beanName, mbd, instanceWrapper); 属性注入，也就是所谓的DI
exposedObject = initializeBean(beanName, exposedObject, mbd); bean的初始化回调

bean的实例化

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#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) {
			/**
			 * 采用静态工厂方法实例化，注意，不是 FactoryBean
			 * <bean id="clientService" ="examples.ClientService" factory-method="createInstance"/>
			 */
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// 如果已经解析过则使用功能解析好的构造函数方法，不需要再次锁定。
		// 这里的是通过 mbd.resolvedConstructorOrFactoryMethod 属性来缓存解析过的构造函数。
		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);
			}
		}

		// 利用 SmartInstantiationAwareBeanPostProcessor 进行构造函数的解析
		// SmartInstantiationAwareBeanPostProcessor 是一个接口
		// 具体实现类是 AutowiredAnnotationBeanPostProcessor
		// 根据参数解析构造函数，并将解析出来的构造函数缓存到mdb 的  resolvedConstructorOrFactoryMethod  属性中
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// Preferred constructors for default construction?
		ctors = mbd.getPreferredConstructors();
		if (ctors != null) {
			// 构造函数自动注入
			return autowireConstructor(beanName, mbd, ctors, null);
		}

		// No special handling: simply use no-arg constructor.
		// 使用默认构造函数构造
		return instantiateBean(beanName, mbd);
	}

我们看一下默认构造函数的处理

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#instantiateBean

	protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
		try {
			Object beanInstance;
			if (System.getSecurityManager() != null) {
				...
			}
			else {
				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this); // 实例化
			}
			BeanWrapper bw = new BeanWrapperImpl(beanInstance); // 包装成BeanWrapper
			initBeanWrapper(bw);
			return bw;
		}
		catch (Throwable ex) {
			...
		}
	}

org.springframework.beans.factory.support.SimpleInstantiationStrategy#instantiate(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.String, org.springframework.beans.factory.BeanFactory)

	@Override
	public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
		// 如果不存在方法覆写，那就使用 java 反射进行实例化，否则使用 CGLIB,
		// lookup-method 和 replaced-method
		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 {
			// 存在方法覆写，利用 CGLIB 来完成实例化，需要依赖于 CGLIB 生成子类
			return instantiateWithMethodInjection(bd, beanName, owner);
		}
	}

BeanUtils.instantiateClass(constructorToUse);里面就是通过构造函数反射实例，然后返回实例化对象的过程，然后外面有把他包装为BeanWrapper对象返回

属性注入

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean

	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		if (bw == null) {
			if (mbd.hasPropertyValues()) {
				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 进行状态修改
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
				// 调用InstantiationAwareBeanPostProcessor实现类的postProcessAfterInstantiation方法
				if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					// 如果返回 false，代表不需要进行后续的属性设值，也不需要再经过其他的 BeanPostProcessor 的处理
					return;
				}
			}
		}

		// bean 实例的所有属性都在这里了
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		// 如果自动装配类型为1-byName 或 2-byType 则进入此分支 但这里是标签形式的，不是注解@Autowire
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			// 1-AUTOWIRE_BY_NAME 通过名字找到所有属性值，如果是 bean 依赖，先初始化依赖的 bean。记录依赖关系
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// 2-AUTOWIRE_BY_TYPE 通过类型装配。复杂一些
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}

		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

		/* 通过BeanPostProcessor完成注解版的自动装配  */
		PropertyDescriptor[] filteredPds = null;
		if (hasInstAwareBpps) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
				PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
				if (pvsToUse == null) {
					if (filteredPds == null) {
						filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
					}
					// 这里有个非常有用的 BeanPostProcessor 进到这里: AutowiredAnnotationBeanPostProcessor
					// 对采用 @Autowired、@Value 注解的依赖进行设值，这里的内容也是非常丰富的
					pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
					if (pvsToUse == null) {
						return;
					}
				}
				pvs = pvsToUse;
			}
		}
		if (needsDepCheck) {
			if (filteredPds == null) {
				filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			}
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}

		if (pvs != null) {
			// 设置 bean 实例的属性值
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

这里是分为标签版的bean的属性注入处理，和注解版的属性注入的处理
这里涉及自动装配类型，可以先看一下都有哪些类型

org.springframework.beans.factory.config.AutowireCapableBeanFactory

	/**
	 * 手动装配
	 */
	int AUTOWIRE_NO = 0;

	/**
	 * 通过名称自动装配
	 */
	int AUTOWIRE_BY_NAME = 1;

	/**
	 * 通过类型自动状态
	 */
	int AUTOWIRE_BY_TYPE = 2;

	/**
	 * 通过构造器自动装配
	 */
	int AUTOWIRE_CONSTRUCTOR = 3;

	/**
	 * @autowired 的自动装配类型
	 */
	@Deprecated
	int AUTOWIRE_AUTODETECT = 4;

我们看看一下autowireByName方法的处理，也就是通过beanName自动装配

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

		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		for (String propertyName : propertyNames) {
			if (containsBean(propertyName)) {
				/**
				 * 属性注入，getBean获取依赖的Bean，有可能没有，需要创建
				 * 有可能已经创建完成，直接从一级缓存singleObjects中获取，
				 * 或者涉及到循环引用，从三级缓存SingletonFactoryes中获取
				 */
				Object bean = getBean(propertyName);
				pvs.add(propertyName, bean);
				registerDependentBean(propertyName, beanName);
				if (logger.isTraceEnabled()) {
					...
				}
			}
			else {
				if (logger.isTraceEnabled()) {
					...
				}
			}
		}
	}

可以看到如果属性中引用了另外一个bean，会在此调用getBean方法进行该bean的创建，涉及到循环依赖的东西，这里先不看了

初始化回调

属性注入完毕以后，就要进入该bean的初始化回调工作

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)

	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 {
			// 如果 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 回调
			 * Aop就在此处完成
			 */
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

可以清晰的看到回调流程

如果 bean 实现了 BeanNameAware、BeanClassLoaderAware 或 BeanFactoryAware 接口，回调
如果该bean实现了BeanNameAware接口，则回调setBeanName(String name)方法；如果实现了BeanClassLoaderAware接口，则回调setBeanClassLoader(ClassLoader classLoader)方法；如果实现了BeanFactoryAware接口，则回调setBeanFactory(BeanFactory beanFactory)方法
BeanPostProcessor的实现类（也就是Bean后置处理器）的 postProcessBeforeInitialization 回调
处理 bean 中定义的 init-method，或者如果 bean 实现了 InitializingBean 接口，调用 afterPropertiesSet() 方法
BeanPostProcessor的实现类 postProcessAfterInitialization 回调

但是有一点要注意，@PostConstruct标注的方法不在此处回调，而是在属性注入这一步

至此一个bean的实例化和初始化就完成了，该bean进入可以使用的状态

bean的销毁

每一个bean最后都会有一步销毁的工作，这是他生命周期的最后阶段

// 销毁所有的bean，实现了DisposableBean接口的bean，则回调重写方法destroy()
// 还有xml中配置了destroy-mothod实现的bean，执行指定的销毁回调
// 以及bean中 @PreDestroy标注的方法
destroyBeans();

黄俊懿

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
Spring源码分析——SpringIOC

Spring源码分析——SpringIOCSpring源码分析——SpringIOC开始ApplicationContext子类的构造参数Spring源码分析——SpringIOC开始在Spring中，有两种配置方式，一种是xml版本的，另外一种是注解版本的。他们分别对应不同的ApplicationContext。xml版本的是ClassPathXmlApplicationContext，而注解版本的是AnnotationConfigApplicationContext。// 用我们的配置文件来启动
复制链接

扫一扫