1.再谈IOC与 DI

IOC(lnversion of Control)控制反转：所谓控制反转，就是把原先我们代码里面需要实现的对象创 建、依赖的代码，反转给容器来帮忙实现。那么必然的我们需要创建一个容器，同时需要一种描述来让
容器知道需要创建的对象与对象的关系。这个描述最具体表现就是我们所看到的配置文件。

DI(Dependency Injection)依赖注入:就是指对象是被动接受依赖类而不是自己主动去找,换句话说就 是指对象不是从容器中查找它依赖的类，而是在容器实例化对象的时候主动将它依赖的类注入给它。

1、对象和对象的关系怎么表示？
可以用xml , properties文件等语义化配置文件表示。

2、 描述对象关系的文件存放在哪里？
可能是 classpath , filesystem , 或者是 URL 网络资源，servletContext 等。
回到正题，有了配置文件，还需要对配置文件解析。

3、 不同的配置文件对对象的描述不一样,如标准的,自定义声明式的，如何统一？
在内部需要有一个统一的关于对象的定义，所有外部的描述都必须转化成统一的描述定义。

4、 如何对不同的配置文件进行解析？
需要对不同的配置文件语法，采用不同的解析器。

2.Spring核心容器类

1.Bean Factory

Spring Bean的创建是典型的工厂模式,这一系列的Bean工厂，也即IOC容器为开发者管理对象 间的依赖关系提供了很多便利和基础服务，在 Spring中有许多的IOC容器的实现供用户选择和使用,
其相互关系如下:

其中BeanFactory作为最顶层的一个接口类，它定义了 IOC容器的基本功能规范，BeanFactory有三
个重要的子类：ListableBeanFactory、HierarchicalBeanFactory 和 AutowireCapableBeanFactory。
但是从类图中我们可以发现最终的默认实现类是DefaultListableBeanFactory , 它实现了所有的接口。

那为何要定义这么多层次的接口呢？查阅这些接口的源码和说明发现，每个接口都有它使用的场合，它
主要是为了区分在Spring内部在操作过程中对象的传递和转化过程时’对对象的数据访问所做的限制。
例如ListableBeanFactory接口表示这些Bean是可列表化的，而 HierarchicaIBeanFactory表示的是 这 些 Bean是有继承关系的，也就是每个Bean有可能有父Bean。AutowireCapableBeanFactory接
口定义Bean的自动装配规则。这三个接口共同定义了 Bean的集合、Bean之间的关系、以及Bean行 为。最基本的IOC容器接口 Bean Factory , 来看一下它的源码：

public interface BeanFactory {//对FactoryBean的转义定义，因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象，//如果需要得到工厂本身，需要转义String FACTORY_BEAN_PREFIX = "&";//根据bean的名字，获取在IOC容器中得到bean实例Object getBean(String name) throws BeansException;//根据bean的名字和Class类型来得到bean实例，增加了类型安全验证机制。<T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException;Object getBean(String name, Object... args) throws BeansException;<T> T getBean(Class<T> requiredType) throws BeansException;<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;//提供对bean的检索，看看是否在IOC容器有这个名字的beanboolean containsBean(String name);//根据bean名字得到bean实例，并同时判断这个bean是不是单例boolean isSingleton(String name) throws NoSuchBeanDefinitionException;boolean isPrototype(String name) throws NoSuchBeanDefinitionException;boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException;//得到bean实例的Class类型@NullableClass<?> getType(String name) throws NoSuchBeanDefinitionException;//得到bean的别名，如果根据别名检索，那么其原名也会被检索出来String[] getAliases(String name);}

在 BeanFactory里只对IOC容器的基本行为作了定义，根本不关心你的Bean是如何定义怎样加载的。 正如我们只关心工厂里得到什么的产品对象，至于工厂是怎么生产这些对象的，这个基本的接口不关心。

而要知道工厂是如何产生对象的，我们需要看具体的IOC容器实现,Spring提供了许多IOC容器
的 实 现 。 比 如 GenericApplicationContext , ClasspathXmlApplicationContext 等。

Applicationcontext是 Spring提供的一个高级的IOC容 器 ，它除了能够提供IOC容器的基本功能
夕卜,还为用户提供了以下的附加服务。从 Applicationcontext接口的实现,我们看出其特点:

1、 支持信息源，可以实现国际化。 （实现MessageSource接口 ）

2、 访问资源。（实现ResourcePatternResolver接 口 ，后面章节会讲到）

3、 支持应用事件。（实现 ApplicationEventPublisher 接口）

2.BeanDefinition

SpnnglOC容器管理了我们定义的各种Bean对象及其相互的关系,Bean对象在Spring实现中是 以 BeanDefinition来描述的，其继承体系如下：

3.BeanDefinitionReader

Bean的解析过程非常复杂，功能被分的很细，因为这里需要被扩展的地方很多，必须保证有足够的灵 活性，以应对可能的变化。Bean的解析主要就是对Spring配置文件的解析。这个解析过程主要通过
BeanDefintionReader 来完成,最后看看 Spring 中 BeanDefintionReader 的类结构图：

通过本章内容的分析，我们对Spring框架体系有了一个基本的宏观了解，希望小伙伴们好好理解,最 好在脑海中形成画面，为以后的学习打下良好的铺垫。

3.Web IOC容器初体验

我们还是从大家最孰悉的DispatcherServlet开 始 ，我们最先想到的还是DispatcherServlet的 init()
方法。我们发现在DispatherServlet中并没有找到init。方法。但是经过探索，往上追索在其父类
HttpServletBean中找到了我们想要的init()方 法 ，如 下 ：

@Override
public final void init() throws ServletException {if (logger.isDebugEnabled()) {logger.debug("Initializing servlet '" + getServletName() + "'");}// Set bean properties from init parameters.PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);if (!pvs.isEmpty()) {try {//定位资源BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);//加载配置信息ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));initBeanWrapper(bw);bw.setPropertyValues(pvs, true);}catch (BeansException ex) {if (logger.isErrorEnabled()) {logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);}throw ex;}}// Let subclasses do whatever initialization they like.initServletBean();if (logger.isDebugEnabled()) {logger.debug("Servlet '" + getServletName() + "' configured successfully");}
}

在 init()方法中，真正完成初始化容器动作的逻辑其实在initServletBean()方法中，我们继续跟进
initServletBean中的代码在 FrameworkServlet 类中:

@Override
protected final void initServletBean() throws ServletException {getServletContext().log("Initializing Spring FrameworkServlet '" + getServletName() + "'");if (this.logger.isInfoEnabled()) {this.logger.info("FrameworkServlet '" + getServletName() + "': initialization started");}long startTime = System.currentTimeMillis();try {this.webApplicationContext = initWebApplicationContext();initFrameworkServlet();}catch (ServletException ex) {this.logger.error("Context initialization failed", ex);throw ex;}catch (RuntimeException ex) {this.logger.error("Context initialization failed", ex);throw ex;}if (this.logger.isInfoEnabled()) {long elapsedTime = System.currentTimeMillis() - startTime;this.logger.info("FrameworkServlet '" + getServletName() + "': initialization completed in " +elapsedTime + " ms");}
}

在上面的代码中终于看到了我们似曾相识的代码initWebAppplicationContext，继续跟进:

protected WebApplicationContext initWebApplicationContext() {//先从ServletContext中获得父容器WebAppliationContextWebApplicationContext rootContext =WebApplicationContextUtils.getWebApplicationContext(getServletContext());//声明子容器WebApplicationContext wac = null;//建立父、子容器之间的关联关系if (this.webApplicationContext != null) {// A context instance was injected at construction time -> use itwac = this.webApplicationContext;if (wac instanceof ConfigurableWebApplicationContext) {ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;if (!cwac.isActive()) {// The context has not yet been refreshed -> provide services such as// setting the parent context, setting the application context id, etcif (cwac.getParent() == null) {// The context instance was injected without an explicit parent -> set// the root application context (if any; may be null) as the parentcwac.setParent(rootContext);}//这个方法里面调用了AbatractApplication的refresh()方法//模板方法，规定IOC初始化基本流程configureAndRefreshWebApplicationContext(cwac);}}}//先去ServletContext中查找Web容器的引用是否存在，并创建好默认的空IOC容器if (wac == null) {// No context instance was injected at construction time -> see if one// has been registered in the servlet context. If one exists, it is assumed// that the parent context (if any) has already been set and that the// user has performed any initialization such as setting the context idwac = findWebApplicationContext();}//给上一步创建好的IOC容器赋值if (wac == null) {// No context instance is defined for this servlet -> create a local onewac = createWebApplicationContext(rootContext);}//触发onRefresh方法if (!this.refreshEventReceived) {// Either the context is not a ConfigurableApplicationContext with refresh// support or the context injected at construction time had already been// refreshed -> trigger initial onRefresh manually here.onRefresh(wac);}if (this.publishContext) {// Publish the context as a servlet context attribute.String attrName = getServletContextAttributeName();getServletContext().setAttribute(attrName, wac);if (this.logger.isDebugEnabled()) {this.logger.debug("Published WebApplicationContext of servlet '" + getServletName() +"' as ServletContext attribute with name [" + attrName + "]");}}return wac;
}@Nullable
protected WebApplicationContext findWebApplicationContext() {String attrName = getContextAttribute();if (attrName == null) {return null;}WebApplicationContext wac =WebApplicationContextUtils.getWebApplicationContext(getServletContext(), attrName);if (wac == null) {throw new IllegalStateException("No WebApplicationContext found: initializer not registered?");}return wac;
}protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {Class<?> contextClass = getContextClass();if (this.logger.isDebugEnabled()) {this.logger.debug("Servlet with name '" + getServletName() +"' will try to create custom WebApplicationContext context of class '" +contextClass.getName() + "'" + ", using parent context [" + parent + "]");}if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {throw new ApplicationContextException("Fatal initialization error in servlet with name '" + getServletName() +"': custom WebApplicationContext class [" + contextClass.getName() +"] is not of type ConfigurableWebApplicationContext");}ConfigurableWebApplicationContext wac =(ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);wac.setEnvironment(getEnvironment());wac.setParent(parent);String configLocation = getContextConfigLocation();if (configLocation != null) {wac.setConfigLocation(configLocation);}configureAndRefreshWebApplicationContext(wac);return wac;
}protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {if (ObjectUtils.identityToString(wac).equals(wac.getId())) {// The application context id is still set to its original default value// -> assign a more useful id based on available informationif (this.contextId != null) {wac.setId(this.contextId);}else {// Generate default id...wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +ObjectUtils.getDisplayString(getServletContext().getContextPath()) + '/' + getServletName());}}wac.setServletContext(getServletContext());wac.setServletConfig(getServletConfig());wac.setNamespace(getNamespace());wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));// The wac environment's #initPropertySources will be called in any case when the context// is refreshed; do it eagerly here to ensure servlet property sources are in place for// use in any post-processing or initialization that occurs below prior to #refreshConfigurableEnvironment env = wac.getEnvironment();if (env instanceof ConfigurableWebEnvironment) {((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());}postProcessWebApplicationContext(wac);applyInitializers(wac);wac.refresh();
}

从上面的代码中可以看出，在 configAndRefreshWebApplicationContext()方法中,调用refresh()方
法 ，这个是真正启动IOC容器的入口，后面会详细介绍0 IOC容器初始化以后，最后调用了
DispatcherServlet 的 onRefresh。方 法 ，在 onRefresh()方法中又是直接调用 initStrategies。方法初始
化 SpringMVC的九大组件:

//初始化策略
protected void initStrategies(ApplicationContext context) {//多文件上传的组件initMultipartResolver(context);//初始化本地语言环境initLocaleResolver(context);//初始化模板处理器initThemeResolver(context);//handlerMappinginitHandlerMappings(context);//初始化参数适配器initHandlerAdapters(context);//初始化异常拦截器initHandlerExceptionResolvers(context);//初始化视图预处理器initRequestToViewNameTranslator(context);//初始化视图转换器initViewResolvers(context);//initFlashMapManager(context);
}

4.基于Xml的 IOC容器的初始化

IOC容器的初始化包括BeanDefinition的 Resource定位、加载和注册这三个基本的过程。我们以
Applicationcontext为例讲解，Applicationcontext系列容器也许是我们最熟悉的,因为Web项目 中使用的 XmlWebApplicationContext就属于这个继承体系 还有ClasspathXmlApplicationContext
等 ,其继承体系如下图所示：

Applicationcontext允许上下文嵌套，通过保持父上下文可以维持一个上下文体系。对于Bean的查找 可以在这个上下文体系中发生,首先检查当前上下文，其次是父上下文，逐级向上,这样为不同的Spring 应用提供了一个共享的Bean定义环境。

1.寻找入口

还有一个我们用的比较多的ClassPathXmlApplicationContext, 通过main()方法启动：

Applicationcontext app = new ClassPathXmlApplicationContext("application.xml");

先看其构造函数的调用：

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

其实际调用的构造函数为：

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)throws BeansException {super(parent);setConfigLocations(configLocations);if (refresh) {refresh();}
}

还 有彳象 AnnotationConfigApplicationContext 、 FileSystemXmlApplicationContext 、 XmlWebApplicationContext等都继承自父容器AbstractApplicationContext主要用到了装饰器模式
和策略模式，最终都是调用refresh方法。

2.获得配置路径

通 过 分 析 ClassPathXmlApplicationContext的 源 代 码 可 以 知 道 , 在 创 建 ClassPathXmlApplicationContext容器时,构造方法做以下两项重要工作：
首先，调用父类容器的构造方法(super(parent)方法)为容器设置好Bean资源加载器。
setConfigLocations(configLocations)方法设置Bean酉己置信息的定位路径。 然 后 ， 再 调 用 父 类 AbstractRefreshableConfigApplicationContext 的
通 过 追 踪 ClassPathXmlApplicationContext的 继 承 体 系 ，发 现 其 父 类 的 父 类 AbstractApplicationContext中初始化IOC容器所做的主要源码如下：

public abstract class AbstractApplicationContext extends DefaultResourceLoaderimplements ConfigurableApplicationContext {public static final String MESSAGE_SOURCE_BEAN_NAME = "messageSource";public static final String LIFECYCLE_PROCESSOR_BEAN_NAME = "lifecycleProcessor";public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";//静态初始化块，在整个容器创建过程中只执行一次static {// Eagerly load the ContextClosedEvent class to avoid weird classloader issues// on application shutdown in WebLogic 8.1. (Reported by Dustin Woods.)//为了避免应用程序在Weblogic8.1关闭时出现类加载异常加载问题，加载IoC容//器关闭事件(ContextClosedEvent)类ContextClosedEvent.class.getName();}//获取一个Spring Source的加载器用于读入Spring Bean定义资源文件protected ResourcePatternResolver getResourcePatternResolver() {//AbstractApplicationContext继承DefaultResourceLoader，因此也是一个资源加载器//Spring资源加载器，其getResource(String location)方法用于载入资源return new PathMatchingResourcePatternResolver(this);}
}

AbstractApplicationContext 的默认构造方法中有调用 PathMatchingResourcePatternResolver 的
构造方法创建Spring资源加载器:

public PathMatchingResourcePatternResolver(ResourceLoader resourceLoader) {Assert.notNull(resourceLoader, "ResourceLoader must not be null");//设置Spring的资源加载器this.resourceLoader = resourceLoader;
}

在设置容器的资源加载器之后，接下来ClassPathXmlApplicationContext执行setConfigLocations方法通过调用其父类AbstractRefreshableConfigApplicationContext的方法进行对Bean配置信息的
定位，该方法的源码如下:

//处理单个资源文件路径为一个字符串的情况
public void setConfigLocation(String location) {//String CONFIG_LOCATION_DELIMITERS = ",; /t/n";//即多个资源文件路径之间用” ,; \t\n”分隔，解析成数组形式setConfigLocations(StringUtils.tokenizeToStringArray(location, CONFIG_LOCATION_DELIMITERS));
}/*** Set the config locations for this application context.* <p>If not set, the implementation may use a default as appropriate.*/
//解析Bean定义资源文件的路径，处理多个资源文件字符串数组
public void setConfigLocations(@Nullable String... locations) {if (locations != null) {Assert.noNullElements(locations, "Config locations must not be null");this.configLocations = new String[locations.length];for (int i = 0; i < locations.length; i++) {// resolvePath为同一个类中将字符串解析为路径的方法this.configLocations[i] = resolvePath(locations[i]).trim();}}else {this.configLocations = null;}
}

通过这两个方法的源码我们可以看出，我们既可以使用一个字符串来配置多个Spring Bean配置信息, 也可以使用字符串数组，即下面两种方式都是可以的：

ClassPathResource res = new ClassPathResourceC("a.xml,b.xml");

多个资源文件路径之间可以是用"，；\t\n"等分隔。

ClassPathResource res =new ClassPathResource(new String[]{"a.xml","b.xml"});

至此，SpringlOC容器在初始化时将配置的Bean配置信息定位为Spring封装的Resource。

3.开始启动

SpringlOC容器对Bean配置资源的载入是从refresh函数开始的，refresh是一个模板方法，规定了
IOC容 器 的 启 动 流 程 ，有些逻辑要交给其子类去实现。它 对 Bean配置资源进行载入
ClassPathXmlApplicationContext 通过调用其父类 AbstractApplicationContext 的 refresh函数启
动整个IOC容器对Bean定义的载入过程，现在我们来详细看看refresh中的逻辑处理:

@Override
public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {// Prepare this context for refreshing.//1、调用容器准备刷新的方法，获取容器的当时时间，同时给容器设置同步标识prepareRefresh();// Tell the subclass to refresh the internal bean factory.//2、告诉子类启动refreshBeanFactory()方法，Bean定义资源文件的载入从//子类的refreshBeanFactory()方法启动ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();// Prepare the bean factory for use in this context.//3、为BeanFactory配置容器特性，例如类加载器、事件处理器等prepareBeanFactory(beanFactory);try {// Allows post-processing of the bean factory in context subclasses.//4、为容器的某些子类指定特殊的BeanPost事件处理器postProcessBeanFactory(beanFactory);// Invoke factory processors registered as beans in the context.//5、调用所有注册的BeanFactoryPostProcessor的BeaninvokeBeanFactoryPostProcessors(beanFactory);// Register bean processors that intercept bean creation.//6、为BeanFactory注册BeanPost事件处理器.//BeanPostProcessor是Bean后置处理器，用于监听容器触发的事件registerBeanPostProcessors(beanFactory);// Initialize message source for this context.//7、初始化信息源，和国际化相关.initMessageSource();// Initialize event multicaster for this context.//8、初始化容器事件传播器.initApplicationEventMulticaster();// Initialize other special beans in specific context subclasses.//9、调用子类的某些特殊Bean初始化方法onRefresh();// Check for listener beans and register them.//10、为事件传播器注册事件监听器.registerListeners();// Instantiate all remaining (non-lazy-init) singletons.//11、初始化所有剩余的单例BeanfinishBeanFactoryInitialization(beanFactory);// Last step: publish corresponding event.//12、初始化容器的生命周期事件处理器，并发布容器的生命周期事件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.//13、销毁已创建的BeandestroyBeans();// Reset 'active' flag.//14、取消refresh操作，重置容器的同步标识。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...//15、重设公共缓存resetCommonCaches();}}
}

refresh方法主要为IOC容器Bean的生命周期管理提供条件，Spring IOC容器载入Bean配置信息 从 其 子 类 容 器 的 refreshBeanFactory方 法 启 动 , 所 以 整 个 refresh中"ConfigurableListableBeanFactory bean Factory = o btainFreshBeanFactory()；" 这句以后代码的
都是注册容器的信息源和生命周期事件，我们前面说的载入就是从这句代码开始启动。
refresh。方法的主要作用是：在创建IOC容器前，如果已经有容器存在，则需要把已有的容器销毁和 关闭,以保证在refresh之后使用的是新建立起来的IOC容器。它类似于对IOC容器的重启,在新建立 好的容器中对容器进行初始化，对 Bean配置资源进行载入。

4.创建容器

obtainFreshBeanFactoryO方法调用子类容器的ref res h B ea n Fa ct o ry ()方 法 ，启动容器载入Bean酉己置
信息的过程,代码如下：

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {//这里使用了委派设计模式，父类定义了抽象的refreshBeanFactory()方法，具体实现调用子类容器的refreshBeanFactory()方法refreshBeanFactory();ConfigurableListableBeanFactory beanFactory = getBeanFactory();if (logger.isDebugEnabled()) {logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);}return beanFactory;
}

AbstractApplicationContext类中只抽象定义refreshBeanFactory()方法，容器真正调用的是 其子类 AbstractRef reshableApplicationContext 实现的 refreshBeanFactory 方 法 ,方法的源
码如下：

@Override
protected final void refreshBeanFactory() throws BeansException {//如果已经有容器，销毁容器中的bean，关闭容器if (hasBeanFactory()) {destroyBeans();closeBeanFactory();}try {//创建IOC容器DefaultListableBeanFactory beanFactory = createBeanFactory();beanFactory.setSerializationId(getId());//对IOC容器进行定制化，如设置启动参数，开启注解的自动装配等customizeBeanFactory(beanFactory);//调用载入Bean定义的方法，主要这里又使用了一个委派模式，在当前类中只定义了抽象的loadBeanDefinitions方法，具体的实现调用子类容器loadBeanDefinitions(beanFactory);synchronized (this.beanFactoryMonitor) {this.beanFactory = beanFactory;}}catch (IOException ex) {throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);}
}

在这个方法中,先判断BeanFactory是否存在，如果存在则先销毁beans并关闭beanFactory , 接看 创建 DefaultListableBeanFactory , 并调用 loadBeanDefinitions(beanFactory)装载 bean 定义。

5.载入配置路径

AbstractRefreshableApplicationContext 中只定义了抽象的 loadBeanDefinitions 方 法 ，容器真正调 用的是其子类 AbstractXmlApplicationContext 对该方法的实现，AbstractXmlApplicationContext
的主要源码如下：

loadBeanDefinitionsQ方 法 同 样 是 抽 象 方 法 , 是 由 其 子 类 实 现 的 ，也即在AbstractXmlApplicationContext 中。

public abstract class AbstractXmlApplicationContext extends AbstractRefreshableConfigApplicationContext {//实现父类抽象的载入Bean定义方法@Overrideprotected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {// Create a new XmlBeanDefinitionReader for the given BeanFactory.//创建XmlBeanDefinitionReader，即创建Bean读取器，并通过回调设置到容器中去，容  器使用该读取器读取Bean定义资源XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);// Configure the bean definition reader with this context's// resource loading environment.//为Bean读取器设置Spring资源加载器，AbstractXmlApplicationContext的//祖先父类AbstractApplicationContext继承DefaultResourceLoader，因此，容器本身也是一个资源加载器beanDefinitionReader.setEnvironment(this.getEnvironment());beanDefinitionReader.setResourceLoader(this);//为Bean读取器设置SAX xml解析器beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));// Allow a subclass to provide custom initialization of the reader,// then proceed with actually loading the bean definitions.//当Bean读取器读取Bean定义的Xml资源文件时，启用Xml的校验机制initBeanDefinitionReader(beanDefinitionReader);//Bean读取器真正实现加载的方法loadBeanDefinitions(beanDefinitionReader);}protected void initBeanDefinitionReader(XmlBeanDefinitionReader reader) {reader.setValidating(this.validating);}//Xml Bean读取器加载Bean定义资源protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {//获取Bean定义资源的定位Resource[] configResources = getConfigResources();if (configResources != null) {//Xml Bean读取器调用其父类AbstractBeanDefinitionReader读取定位//的Bean定义资源reader.loadBeanDefinitions(configResources);}//如果子类中获取的Bean定义资源定位为空，则获取FileSystemXmlApplicationContext构造方法中setConfigLocations方法设置的资源String[] configLocations = getConfigLocations();if (configLocations != null) {//Xml Bean读取器调用其父类AbstractBeanDefinitionReader读取定位//的Bean定义资源reader.loadBeanDefinitions(configLocations);}}//这里又使用了一个委托模式，调用子类的获取Bean定义资源定位的方法//该方法在ClassPathXmlApplicationContext中进行实现，对于我们//举例分析源码的FileSystemXmlApplicationContext没有使用该方法@Nullableprotected Resource[] getConfigResources() {return null;}
}

以 XmlBean 读取器的其中一种策略 XmlBeanDefinitionReader 为例。XmlBeanDefinitionReader 调 用其父类AbstractBeanDefinitionReader的 reader.loadBeanDefinitionsQ方法读取Bean配置资源。 由于我们使用ClassPathXmlApplicationContext作为例子分析，因此getConfigResources的返回值 为 null , 因此程序执行 reader.loadBeanDefinitions(configLocations)分支。

6.分配路径处理策略

在 XmlBeanDefinitionReader 的抽象父类 AbstractBeanDefinitionReader 中定义了载入过程。 AbstractBeanDefinitionReader 的 loadBeanDefinitionsO方法源码如下:

//重载方法，调用下面的loadBeanDefinitions(String, Set<Resource>);方法
@Override
public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {return loadBeanDefinitions(location, null);
}public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {//获取在IoC容器初始化过程中设置的资源加载器ResourceLoader resourceLoader = getResourceLoader();if (resourceLoader == null) {throw new BeanDefinitionStoreException("Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");}if (resourceLoader instanceof ResourcePatternResolver) {// Resource pattern matching available.try {//将指定位置的Bean定义资源文件解析为Spring IOC容器封装的资源//加载多个指定位置的Bean定义资源文件Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);//委派调用其子类XmlBeanDefinitionReader的方法，实现加载功能int loadCount = loadBeanDefinitions(resources);if (actualResources != null) {for (Resource resource : resources) {actualResources.add(resource);}}if (logger.isDebugEnabled()) {logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");}return loadCount;}catch (IOException ex) {throw new BeanDefinitionStoreException("Could not resolve bean definition resource pattern [" + location + "]", ex);}}else {// Can only load single resources by absolute URL.//将指定位置的Bean定义资源文件解析为Spring IOC容器封装的资源//加载单个指定位置的Bean定义资源文件Resource resource = resourceLoader.getResource(location);//委派调用其子类XmlBeanDefinitionReader的方法，实现加载功能int loadCount = loadBeanDefinitions(resource);if (actualResources != null) {actualResources.add(resource);}if (logger.isDebugEnabled()) {logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");}return loadCount;}
}//重载方法，调用loadBeanDefinitions(String);
@Override
public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {Assert.notNull(locations, "Location array must not be null");int counter = 0;for (String location : locations) {counter += loadBeanDefinitions(location);}return counter;
}

AbstractRefreshableConfigApplicationContext 的 loadBeanDefinitions(Resource…resources)方 法实际上是调用 AbstractBeanDefinitionReader 的 loadBeanDefinitions()方法。 从对AbstractBeanDefinitionReader的 loadBeanDefinitions。方法源码分析可以看出该方法就做了
两件事：

首先，调用资源加载器的获取资源方法resourceLoader.getResource(location)，获取到要加载的资源。 其 次 ，真正执行加载功能是其子类XmlBeanDefinitionReader的 loadBeanDefinitions。方法。在 loadBeanDefinitionsQ方法中调用了 AbstractApplicationContext 的 getResources。方 法 ，跟进去之 后发现getResources()方法其实定义在ResourcePatternResolver中 ，此 时 ,我们有必要来看一下 ResourcePatternResolver 的全类图：

从上面可以看到ResourceLoader与 ApphcationContext的继承关系,可以看出其实际调用的是 DefaultResourceLoader 中 的 getSource() 方 法 定 位 Resource , 因 为 ClassPathXmlApplicationContext 本身就是 DefaultResourceLoader 的实现类,所以此时又回到了 ClassPathXmlApplicationContext 中来。

7.解析配置文件踣径

XmlBeanDefinitionReader 通 过 调 用 ClassPathXmlApplicationContext 的 父 类 DefaultResourceLoader的 getResource。方法获取要加载的资源，其源码如下

//获取Resource的具体实现方法
@Override
public Resource getResource(String location) {Assert.notNull(location, "Location must not be null");for (ProtocolResolver protocolResolver : this.protocolResolvers) {Resource resource = protocolResolver.resolve(location, this);if (resource != null) {return resource;}}//如果是类路径的方式，那需要使用ClassPathResource 来得到bean 文件的资源对象if (location.startsWith("/")) {return getResourceByPath(location);}else if (location.startsWith(CLASSPATH_URL_PREFIX)) {return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());}else {try {// Try to parse the location as a URL...// 如果是URL 方式，使用UrlResource 作为bean 文件的资源对象URL url = new URL(location);return (ResourceUtils.isFileURL(url) ? new FileUrlResource(url) : new UrlResource(url));}catch (MalformedURLException ex) {// No URL -> resolve as resource path.//如果既不是classpath标识，又不是URL标识的Resource定位，则调用//容器本身的getResourceByPath方法获取Resourcereturn getResourceByPath(location);}}
}

DefaultResourceLoader 提供了 getResourceByPathO方法的实现,就是为了处理既不是 classpath
标 识 ,又不是URL标识的Resource定位这种情况。

protected Resource getResourceByPath(String path) { return new ClassPathContextResource(path<, getC lassLoader());
}

在 ClassPathResource中完成了对整个路径的解析。这 样 ，就可以从类路径上对IOC配置文件进行加 载 ,当然我们可以按照这个逻辑从任何地方加载，在 Spring中我们看到它提供的各种资源抽象,比如
ClassPathResource. URLResource、FileSystemResource等来供我彳门使用。上面我们看到的是定位 Resource的一个过程，而这只是加载过程的一部分。例如FileSystemXmlApplication容器就重写了
getResourceByPath方法:

@Override
protected Resource getResourceByPath(String path) {if (path.startsWith("/")) {path = path.substring(1);}//这里使用文件系统资源对象来定义bean 文件return new FileSystemResource(path);
}

通过子类的覆盖，巧妙地完成了将类路径变为文件路径的转换。

8.开始读取配置内容

继续回到 XmlBeanDefinitionReader 的 loadBeanDefinitions(Resource …)方法看到代表 bean 文件
的资源定义以后的载入过程。

//这里是载入XML形式Bean定义资源文件方法
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {Assert.notNull(encodedResource, "EncodedResource must not be null");if (logger.isInfoEnabled()) {logger.info("Loading XML bean definitions from " + encodedResource.getResource());}Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();if (currentResources == null) {currentResources = new HashSet<>(4);this.resourcesCurrentlyBeingLoaded.set(currentResources);}if (!currentResources.add(encodedResource)) {throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");}try {//将资源文件转为InputStream的IO流InputStream inputStream = encodedResource.getResource().getInputStream();try {//从InputStream中得到XML的解析源InputSource inputSource = new InputSource(inputStream);if (encodedResource.getEncoding() != null) {inputSource.setEncoding(encodedResource.getEncoding());}//这里是具体的读取过程return doLoadBeanDefinitions(inputSource, encodedResource.getResource());}finally {//关闭从Resource中得到的IO流inputStream.close();}}catch (IOException ex) {throw new BeanDefinitionStoreException("IOException parsing XML document from " + encodedResource.getResource(), ex);}finally {currentResources.remove(encodedResource);if (currentResources.isEmpty()) {this.resourcesCurrentlyBeingLoaded.remove();}}
}

通过源码分析，载入Bean配置信息的最后一步是将Bean配置信息转换为Document对象，该过程由
documentLoader。方法实现

9.准备文档对象

DocumentLoader将 Bean配置资源转换成Document对象的源码如下：

//使用标准的JAXP将载入的Bean定义资源转换成document对象
@Override
public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {//创建文件解析器工厂DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);if (logger.isDebugEnabled()) {logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]");}//创建文档解析器DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);//解析Spring的Bean定义资源return builder.parse(inputSource);
}

上面的解析过程足调用JavaEE标准的JAXP标准进行处理。至此Spring IOC容器根据定位的Bean配 置信息，将其加裁读入并转换成为Document对象过程完成。接下来我们要继续分析Spring IOC容器 将载入的Bean配置信息转换为Document对象之后，足如何将其解析为Spring IOC管理的Bean对象 并将其注册到容器中的。

10.分配解析策略

XmlBeanDefinitionReader类中的doLoadBeanDefinition() 方法是从特定XML文件中实际载入
Bean配置资源的方法，该方法在载入Bean配置资源之后将其转换为Document对象，接下来调用
registerBeanDefinitions( ) 启 动 Spring IOC 容 器 对 Bean 定 义 的 解 析 过 程 ， registerBeanDefinitions()方法源码如下：

//按照Spring的Bean语义要求将Bean定义资源解析并转换为容器内部数据结构
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {//得到BeanDefinitionDocumentReader来对xml格式的BeanDefinition解析BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();//获得容器中注册的Bean数量int countBefore = getRegistry().getBeanDefinitionCount();//解析过程入口，这里使用了委派模式，BeanDefinitionDocumentReader只是个接口,//具体的解析实现过程有实现类DefaultBeanDefinitionDocumentReader完成documentReader.registerBeanDefinitions(doc, createReaderContext(resource));//统计解析的Bean数量return getRegistry().getBeanDefinitionCount() - countBefore;
}

Bean配置资源的载入解析分为以下两个过程: 首先,通过调用XML解析器将Bean配置信息转换得到Document对象,但是这些Document对象 并没有按照Spring的 Bean规则进行解析。这一步是载入的过程 其次,在完成通用的XML解析之后，按照Spring Bean的定义规则对Document对象进行解析,其
解 析 过 程 是 在 接 口 BeanDefinitionDocumentReader 的 实 现 类 DefaultBeanDefinitionDocumentReader 中实现。

11.将配置载入内存

BeanDefinitionDocumentReader 接 口 通 过 registerBeanDefinitions()方 法 调 用 其 实 现 类 DefaultBeanDefinitionDocumentReader 对 Document 对象进行解析，解析的代码如下：

protected void doRegisterBeanDefinitions(Element root) {// Any nested <beans> elements will cause recursion in this method. In// order to propagate and preserve <beans> default-* attributes correctly,// keep track of the current (parent) delegate, which may be null. Create// the new (child) delegate with a reference to the parent for fallback purposes,// then ultimately reset this.delegate back to its original (parent) reference.// this behavior emulates a stack of delegates without actually necessitating one.//具体的解析过程由BeanDefinitionParserDelegate实现，//BeanDefinitionParserDelegate中定义了Spring Bean定义XML文件的各种元素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);if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {if (logger.isInfoEnabled()) {logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +"] not matching: " + getReaderContext().getResource());}return;}}}//在解析Bean定义之前，进行自定义的解析，增强解析过程的可扩展性preProcessXml(root);//从Document的根元素开始进行Bean定义的Document对象parseBeanDefinitions(root, this.delegate);//在解析Bean定义之后，进行自定义的解析，增加解析过程的可扩展性postProcessXml(root);this.delegate = parent;
}//创建BeanDefinitionParserDelegate，用于完成真正的解析过程
protected BeanDefinitionParserDelegate createDelegate(XmlReaderContext readerContext, Element root, @Nullable BeanDefinitionParserDelegate parentDelegate) {BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);//BeanDefinitionParserDelegate初始化Document根元素delegate.initDefaults(root, parentDelegate);return delegate;
}/*** Parse the elements at the root level in the document:* "import", "alias", "bean".* @param root the DOM root element of the document*/
//使用Spring的Bean规则从Document的根元素开始进行Bean定义的Document对象
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {//Bean定义的Document对象使用了Spring默认的XML命名空间if (delegate.isDefaultNamespace(root)) {//获取Bean定义的Document对象根元素的所有子节点NodeList nl = root.getChildNodes();for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);//获得Document节点是XML元素节点if (node instanceof Element) {Element ele = (Element) node;//Bean定义的Document的元素节点使用的是Spring默认的XML命名空间if (delegate.isDefaultNamespace(ele)) {//使用Spring的Bean规则解析元素节点parseDefaultElement(ele, delegate);}else {//没有使用Spring默认的XML命名空间，则使用用户自定义的解//析规则解析元素节点delegate.parseCustomElement(ele);}}}}else {//Document的根节点没有使用Spring默认的命名空间，则使用用户自定义的//解析规则解析Document根节点delegate.parseCustomElement(root);}
}//使用Spring的Bean规则解析Document元素节点
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {//如果元素节点是<Import>导入元素，进行导入解析if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {importBeanDefinitionResource(ele);}//如果元素节点是<Alias>别名元素，进行别名解析else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {processAliasRegistration(ele);}//元素节点既不是导入元素，也不是别名元素，即普通的<Bean>元素，//按照Spring的Bean规则解析元素else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {processBeanDefinition(ele, delegate);}else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {// recursedoRegisterBeanDefinitions(ele);}
}/*** Parse an "import" element and load the bean definitions* from the given resource into the bean factory.*/
//解析<Import>导入元素，从给定的导入路径加载Bean定义资源到Spring IoC容器中
protected void importBeanDefinitionResource(Element ele) {//获取给定的导入元素的location属性String location = ele.getAttribute(RESOURCE_ATTRIBUTE);//如果导入元素的location属性值为空，则没有导入任何资源，直接返回if (!StringUtils.hasText(location)) {getReaderContext().error("Resource location must not be empty", ele);return;}// Resolve system properties: e.g. "${user.dir}"//使用系统变量值解析location属性值location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);Set<Resource> actualResources = new LinkedHashSet<>(4);// Discover whether the location is an absolute or relative URI//标识给定的导入元素的location是否是绝对路径boolean absoluteLocation = false;try {absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();}catch (URISyntaxException ex) {// cannot convert to an URI, considering the location relative// unless it is the well-known Spring prefix "classpath*:"//给定的导入元素的location不是绝对路径}// Absolute or relative?//给定的导入元素的location是绝对路径if (absoluteLocation) {try {//使用资源读入器加载给定路径的Bean定义资源int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);if (logger.isDebugEnabled()) {logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]");}}catch (BeanDefinitionStoreException ex) {getReaderContext().error("Failed to import bean definitions from URL location [" + location + "]", ele, ex);}}else {// No URL -> considering resource location as relative to the current file.//给定的导入元素的location是相对路径try {int importCount;//将给定导入元素的location封装为相对路径资源Resource relativeResource = getReaderContext().getResource().createRelative(location);//封装的相对路径资源存在if (relativeResource.exists()) {//使用资源读入器加载Bean定义资源importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);actualResources.add(relativeResource);}//封装的相对路径资源不存在else {//获取Spring IOC容器资源读入器的基本路径String baseLocation = getReaderContext().getResource().getURL().toString();//根据Spring IOC容器资源读入器的基本路径加载给定导入路径的资源importCount = getReaderContext().getReader().loadBeanDefinitions(StringUtils.applyRelativePath(baseLocation, location), actualResources);}if (logger.isDebugEnabled()) {logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]");}}catch (IOException ex) {getReaderContext().error("Failed to resolve current resource location", ele, ex);}catch (BeanDefinitionStoreException ex) {getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]",ele, ex);}}Resource[] actResArray = actualResources.toArray(new Resource[actualResources.size()]);//在解析完<Import>元素之后，发送容器导入其他资源处理完成事件getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}/*** Process the given alias element, registering the alias with the registry.*/
//解析<Alias>别名元素，为Bean向Spring IoC容器注册别名
protected void processAliasRegistration(Element ele) {//获取<Alias>别名元素中name的属性值String name = ele.getAttribute(NAME_ATTRIBUTE);//获取<Alias>别名元素中alias的属性值String alias = ele.getAttribute(ALIAS_ATTRIBUTE);boolean valid = true;//<alias>别名元素的name属性值为空if (!StringUtils.hasText(name)) {getReaderContext().error("Name must not be empty", ele);valid = false;}//<alias>别名元素的alias属性值为空if (!StringUtils.hasText(alias)) {getReaderContext().error("Alias must not be empty", ele);valid = false;}if (valid) {try {//向容器的资源读入器注册别名getReaderContext().getRegistry().registerAlias(name, alias);}catch (Exception ex) {getReaderContext().error("Failed to register alias '" + alias +"' for bean with name '" + name + "'", ele, ex);}//在解析完<Alias>元素之后，发送容器别名处理完成事件getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));}
}/*** Process the given bean element, parsing the bean definition* and registering it with the registry.*/
//解析Bean定义资源Document对象的普通元素
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);// BeanDefinitionHolder是对BeanDefinition的封装，即Bean定义的封装类//对Document对象中<Bean>元素的解析由BeanDefinitionParserDelegate实现// BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);if (bdHolder != null) {bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);try {// Register the final decorated instance.//向Spring IOC容器注册解析得到的Bean定义，这是Bean定义向IOC容器注册的入口BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());}catch (BeanDefinitionStoreException ex) {getReaderContext().error("Failed to register bean definition with name '" +bdHolder.getBeanName() + "'", ele, ex);}// Send registration event.//在完成向Spring IOC容器注册解析得到的Bean定义之后，发送注册事件getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));}
}

通过上述Spring IOC容器对载入的Bean定义Document解析可以看出,我们使用Spring时 ，在
Spring配置文件中可以使用＜import＞元素来导入IOC容器所需要的其他资源，Spring IOC容器在解 析时会首先将指定导入的资源加载进容器中。使用＜ailas＞别名时，Spring IOC容器首先将别名元素所
定义的别名注册到容器中。

对于既不是＜import＞元素,又不是＜alias＞元素的元素,即Spring配置文件中普通的＜bean＞元素的
解析由 BeanDefinitionParserDelegate 类的 parseBeanDefinitionElement。方法来实现。这个解析的
过程非常复杂，我们在mini版本的时候，就用properties文件代替了。

12.载入<bean>元素

Bean 配置信息中的 ＜import＞和＜alias＞元素解析在 DefaultBeanDefinitionDocumentReader 中已 经完成，对 Bean配置信息中使用最多的＜bean＞元素交由BeanDefinitionParserDelegate来解析,
其解析实现的源码如下：

//解析<Bean>元素的入口
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {return parseBeanDefinitionElement(ele, null);
}/*** Parses the supplied {@code <bean>} element. May return {@code null}* if there were errors during parse. Errors are reported to the* {@link org.springframework.beans.factory.parsing.ProblemReporter}.*/
//解析Bean定义资源文件中的<Bean>元素，这个方法中主要处理<Bean>元素的id，name和别名属性
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {//获取<Bean>元素中的id属性值String id = ele.getAttribute(ID_ATTRIBUTE);//获取<Bean>元素中的name属性值String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);//获取<Bean>元素中的alias属性值List<String> aliases = new ArrayList<>();//将<Bean>元素中的所有name属性值存放到别名中if (StringUtils.hasLength(nameAttr)) {String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);aliases.addAll(Arrays.asList(nameArr));}String beanName = id;//如果<Bean>元素中没有配置id属性时，将别名中的第一个值赋值给beanNameif (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {beanName = aliases.remove(0);if (logger.isDebugEnabled()) {logger.debug("No XML 'id' specified - using '" + beanName +"' as bean name and " + aliases + " as aliases");}}//检查<Bean>元素所配置的id或者name的唯一性，containingBean标识<Bean>//元素中是否包含子<Bean>元素if (containingBean == null) {//检查<Bean>元素所配置的id、name或者别名是否重复checkNameUniqueness(beanName, aliases, ele);}//详细对<Bean>元素中配置的Bean定义进行解析的地方AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);if (beanDefinition != null) {if (!StringUtils.hasText(beanName)) {try {if (containingBean != null) {//如果<Bean>元素中没有配置id、别名或者name，且没有包含子元素//<Bean>元素，为解析的Bean生成一个唯一beanName并注册beanName = BeanDefinitionReaderUtils.generateBeanName(beanDefinition, this.readerContext.getRegistry(), true);}else {//如果<Bean>元素中没有配置id、别名或者name，且包含了子元素//<Bean>元素，为解析的Bean使用别名向IOC容器注册beanName = this.readerContext.generateBeanName(beanDefinition);// Register an alias for the plain bean class name, if still possible,// if the generator returned the class name plus a suffix.// This is expected for Spring 1.2/2.0 backwards compatibility.//为解析的Bean使用别名注册时，为了向后兼容//Spring1.2/2.0，给别名添加类名后缀String beanClassName = beanDefinition.getBeanClassName();if (beanClassName != null &&beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {aliases.add(beanClassName);}}if (logger.isDebugEnabled()) {logger.debug("Neither XML 'id' nor 'name' specified - " +"using generated bean name [" + beanName + "]");}}catch (Exception ex) {error(ex.getMessage(), ele);return null;}}String[] aliasesArray = StringUtils.toStringArray(aliases);return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);}//当解析出错时，返回nullreturn null;
}

只要使用过Spring对 Spring配置文件比较熟悉的人通过对上述源码的分析就会明白我们在Spring 配置文件中＜Bean＞元素的中配置的属性就是通过该方法解析和设置到Bean中去的。 注 意 ：在解析＜Bean＞元素过程中没有创建和实例化Bean对象,只是创建了 Bean对象的定义类
BeanDefinition , 将＜Bean＞元素中的配置信息设置到BeanDefinition中作为记录，当依赖注入时刃
使用这些记录信息创建和实例化具体的Bean对氨 上面方法中一些对一些配置如元信息(meta)、qualifier等的解析,我们在Spring中配置时使用的也不 多 ,我们在使用Spring的＜Bean＞元素时,配置最多的是〈property〉属性,因此我们下面继续分析源 码 ，了解Bean的属性在解析时是如何设置的。

13.载入<property>元素

BeanDefinitionParserDelegate 在解析＜Bean＞调用 parsePropertyElements()方法解析＜Bean＞元
素中的〈property〉属性子元素，解析源码如下:

//解析<Bean>元素中的<property>子元素
public void parsePropertyElements(Element beanEle, BeanDefinition bd) {//获取<Bean>元素中所有的子元素NodeList nl = beanEle.getChildNodes();for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);//如果子元素是<property>子元素，则调用解析<property>子元素方法解析if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {parsePropertyElement((Element) node, bd);}}
}//解析<property>元素
public void parsePropertyElement(Element ele, BeanDefinition bd) {//获取<property>元素的名字String propertyName = ele.getAttribute(NAME_ATTRIBUTE);if (!StringUtils.hasLength(propertyName)) {error("Tag 'property' must have a 'name' attribute", ele);return;}this.parseState.push(new PropertyEntry(propertyName));try {//如果一个Bean中已经有同名的property存在，则不进行解析，直接返回。//即如果在同一个Bean中配置同名的property，则只有第一个起作用if (bd.getPropertyValues().contains(propertyName)) {error("Multiple 'property' definitions for property '" + propertyName + "'", ele);return;}//解析获取property的值Object val = parsePropertyValue(ele, bd, propertyName);//根据property的名字和值创建property实例PropertyValue pv = new PropertyValue(propertyName, val);//解析<property>元素中的属性parseMetaElements(ele, pv);pv.setSource(extractSource(ele));bd.getPropertyValues().addPropertyValue(pv);}finally {this.parseState.pop();}
}//解析获取property值
@Nullable
public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {String elementName = (propertyName != null) ?"<property> element for property '" + propertyName + "'" :"<constructor-arg> element";// Should only have one child element: ref, value, list, etc.//获取<property>的所有子元素，只能是其中一种类型:ref,value,list,etc等NodeList nl = ele.getChildNodes();Element subElement = null;for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);//子元素不是description和meta属性if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&!nodeNameEquals(node, META_ELEMENT)) {// Child element is what we're looking for.if (subElement != null) {error(elementName + " must not contain more than one sub-element", ele);}else {//当前<property>元素包含有子元素subElement = (Element) node;}}}//判断property的属性值是ref还是value，不允许既是ref又是valueboolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);if ((hasRefAttribute && hasValueAttribute) ||((hasRefAttribute || hasValueAttribute) && subElement != null)) {error(elementName +" is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);}//如果属性是ref，创建一个ref的数据对象RuntimeBeanReference//这个对象封装了ref信息if (hasRefAttribute) {String refName = ele.getAttribute(REF_ATTRIBUTE);if (!StringUtils.hasText(refName)) {error(elementName + " contains empty 'ref' attribute", ele);}//一个指向运行时所依赖对象的引用RuntimeBeanReference ref = new RuntimeBeanReference(refName);//设置这个ref的数据对象是被当前的property对象所引用ref.setSource(extractSource(ele));return ref;}//如果属性是value，创建一个value的数据对象TypedStringValue//这个对象封装了value信息else if (hasValueAttribute) {//一个持有String类型值的对象TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));//设置这个value数据对象是被当前的property对象所引用valueHolder.setSource(extractSource(ele));return valueHolder;}//如果当前<property>元素还有子元素else if (subElement != null) {//解析<property>的子元素return parsePropertySubElement(subElement, bd);}else {// Neither child element nor "ref" or "value" attribute found.//propery属性中既不是ref，也不是value属性，解析出错返回nullerror(elementName + " must specify a ref or value", ele);return null;}
}

通过对上述源码的分析，我们可以了解在Spring配!1! 置文件中 ＜Bean＞元素中＜property＞元素的相关
配置是如何处理的:

1、ref被封装为指向依赖对象一个引用。

2、value配置都会封装成一个字符串类型的对象。

3、 ref和 value都 通 过 ’解析的数据类型属性值.setSource(extractSource(ele));〃方法将属性值/引用
与所引用的属性关联起来。

在方法的最后对于＜property＞元素的子元素通过parsePropertySubElement ()方法解析，我们继续分
析该方法的源码，了解其解析过程。

14.载入＜property＞的子元素

在 BeanDefinitionParserDelegate 类中的 parsePropertySubElementO方法对＜property＞ 中的子元
素解析，源码如下：

//解析<property>元素中ref,value或者集合等子元素
@Nullable
public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {//如果<property>没有使用Spring默认的命名空间，则使用用户自定义的规则解析内嵌元素if (!isDefaultNamespace(ele)) {return parseNestedCustomElement(ele, bd);}//如果子元素是bean，则使用解析<Bean>元素的方法解析else if (nodeNameEquals(ele, BEAN_ELEMENT)) {BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);if (nestedBd != null) {nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);}return nestedBd;}//如果子元素是ref，ref中只能有以下3个属性：bean、local、parentelse if (nodeNameEquals(ele, REF_ELEMENT)) {// A generic reference to any name of any bean.//可以不再同一个Spring配置文件中，具体请参考Spring对ref的配置规则String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);boolean toParent = false;if (!StringUtils.hasLength(refName)) {// A reference to the id of another bean in a parent context.//获取<property>元素中parent属性值，引用父级容器中的BeanrefName = ele.getAttribute(PARENT_REF_ATTRIBUTE);toParent = true;if (!StringUtils.hasLength(refName)) {error("'bean' or 'parent' is required for <ref> element", ele);return null;}}if (!StringUtils.hasText(refName)) {error("<ref> element contains empty target attribute", ele);return null;}//创建ref类型数据，指向被引用的对象RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);//设置引用类型值是被当前子元素所引用ref.setSource(extractSource(ele));return ref;}//如果子元素是<idref>，使用解析ref元素的方法解析else if (nodeNameEquals(ele, IDREF_ELEMENT)) {return parseIdRefElement(ele);}//如果子元素是<value>，使用解析value元素的方法解析else if (nodeNameEquals(ele, VALUE_ELEMENT)) {return parseValueElement(ele, defaultValueType);}//如果子元素是null，为<property>设置一个封装null值的字符串数据else if (nodeNameEquals(ele, NULL_ELEMENT)) {// It's a distinguished null value. Let's wrap it in a TypedStringValue// object in order to preserve the source location.TypedStringValue nullHolder = new TypedStringValue(null);nullHolder.setSource(extractSource(ele));return nullHolder;}//如果子元素是<array>，使用解析array集合子元素的方法解析else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {return parseArrayElement(ele, bd);}//如果子元素是<list>，使用解析list集合子元素的方法解析else if (nodeNameEquals(ele, LIST_ELEMENT)) {return parseListElement(ele, bd);}//如果子元素是<set>，使用解析set集合子元素的方法解析else if (nodeNameEquals(ele, SET_ELEMENT)) {return parseSetElement(ele, bd);}//如果子元素是<map>，使用解析map集合子元素的方法解析else if (nodeNameEquals(ele, MAP_ELEMENT)) {return parseMapElement(ele, bd);}//如果子元素是<props>，使用解析props集合子元素的方法解析else if (nodeNameEquals(ele, PROPS_ELEMENT)) {return parsePropsElement(ele);}//既不是ref，又不是value，也不是集合，则子元素配置错误，返回nullelse {error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);return null;}
}

通过上述源码分析,我们明白了在Spring配置文件中,对＜property＞元素中K配! 置的array, list、set、 map、prop等各种集合子元素的都通过上述方法解析，生成对应的数据对象，比如ManagedList、
ManagedArray、ManagedSet 等 ，这些 Managed 类是 Spring 对象 BeanDefiniton 的数据封装，对
集合数据类型的具体解析有各自的解析方法实现,解析方法的命名非常规范，—目了然，我们对＜list＞ 集合元素的解析方法进行源码分析，了解其实现过程。

15.载入<list>的子元素

在 BeanDefinitionParserDelegate 类中的 parseListElement()方法就是具体实现解析＜property＞元
素中的＜list＞集合子元素,源码如下:

//解析<list>集合子元素
public List<Object> parseListElement(Element collectionEle, @Nullable BeanDefinition bd) {//获取<list>元素中的value-type属性，即获取集合元素的数据类型String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE);//获取<list>集合元素中的所有子节点NodeList nl = collectionEle.getChildNodes();//Spring中将List封装为ManagedListManagedList<Object> target = new ManagedList<>(nl.getLength());target.setSource(extractSource(collectionEle));//设置集合目标数据类型target.setElementTypeName(defaultElementType);target.setMergeEnabled(parseMergeAttribute(collectionEle));//具体的<list>元素解析parseCollectionElements(nl, target, bd, defaultElementType);return target;
}//具体解析<list>集合元素，<array>、<list>和<set>都使用该方法解析
protected void parseCollectionElements(NodeList elementNodes, Collection<Object> target, @Nullable BeanDefinition bd, String defaultElementType) {//遍历集合所有节点for (int i = 0; i < elementNodes.getLength(); i++) {Node node = elementNodes.item(i);//节点不是description节点if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT)) {//将解析的元素加入集合中，递归调用下一个子元素target.add(parsePropertySubElement((Element) node, bd, defaultElementType));}}
}

经过对Spring Bean配置信息转换的Document对象中的元素层层解析Spring IOC现在已经将XML 形式定义的Bean配置信息转换为Spring IOC所识别的数据结构 BeanDefinition , 它是 Bean 配 置信息中配置的POJO对象在Spring IOC容器中的映射，我们可以通过AbstractBeanDefinition为
入口，看到了 IOC容器进行索引、查询和操作。

通过Spring IOC容器对Bean配置资源的解析后,IOC容器大致完成了管理Bean对象的准备工作, 即初始化过程，但是最为重要的依赖注入还没有发生,现在在IOC容器中BeanDefinition存储的只是 一些静态信息，接下来需要向容器注册Bean定义信息才能全部完成IOC容器的初始化过程

16.分配注册策略

让我们继续跟踪程序的执行顺序，接下来我们来分析DefaultBeanDefinitionDocumentReader对 Bean定 义 转 换 的 Document对象解析的流程中, 在 其 parseDefaultElementQ方法中完成对 Document对 象 的 解 析 后 得 到 封 装 BeanDefinition的 BeanDefinitionHold对 象 ，然后调用 BeanDefinitionReaderUtils 的 registerBeanDefinitionO方法向 IOC 容 器 注 册 解 析 的 Bean , BeanDefinitionReaderUtils 的注册的源码如下：

//将解析的BeanDefinitionHold注册到容器中
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)throws BeanDefinitionStoreException {// Register bean definition under primary name.//获取解析的BeanDefinition的名称String beanName = definitionHolder.getBeanName();//向IOC容器注册BeanDefinitionregistry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());// Register aliases for bean name, if any.//如果解析的BeanDefinition有别名，向容器为其注册别名String[] aliases = definitionHolder.getAliases();if (aliases != null) {for (String alias : aliases) {registry.registerAlias(beanName, alias);}}
}

当调用BeanDefinitionReaderUtils向 IOC容器注册解析的BeanDefinition时 ，真正完成注册功能的
是 DefaultListableBeanFactory

17.向容器注册

DefaultListableBeanFactory中 使 用 一 个 HashMap的 集 合 对 象 存 放 IO C容器中注册解析的 BeanDefinition , 向 IOC容器注册的主要源码如下：

//存储注册信息的BeanDefinition
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);//向IOC容器注册解析的BeanDefiniton
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException {Assert.hasText(beanName, "Bean name must not be empty");Assert.notNull(beanDefinition, "BeanDefinition must not be null");//校验解析的BeanDefinitonif (beanDefinition instanceof AbstractBeanDefinition) {try {((AbstractBeanDefinition) beanDefinition).validate();}catch (BeanDefinitionValidationException ex) {throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,"Validation of bean definition failed", ex);}}BeanDefinition oldBeanDefinition;oldBeanDefinition = this.beanDefinitionMap.get(beanName);if (oldBeanDefinition != null) {if (!isAllowBeanDefinitionOverriding()) {throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +"': There is already [" + oldBeanDefinition + "] bound.");}else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTUREif (this.logger.isWarnEnabled()) {this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +"' with a framework-generated bean definition: replacing [" +oldBeanDefinition + "] with [" + beanDefinition + "]");}}else if (!beanDefinition.equals(oldBeanDefinition)) {if (this.logger.isInfoEnabled()) {this.logger.info("Overriding bean definition for bean '" + beanName +"' with a different definition: replacing [" + oldBeanDefinition +"] with [" + beanDefinition + "]");}}else {if (this.logger.isDebugEnabled()) {this.logger.debug("Overriding bean definition for bean '" + beanName +"' with an equivalent definition: replacing [" + oldBeanDefinition +"] with [" + beanDefinition + "]");}}this.beanDefinitionMap.put(beanName, beanDefinition);}else {if (hasBeanCreationStarted()) {// Cannot modify startup-time collection elements anymore (for stable iteration)//注册的过程中需要线程同步，以保证数据的一致性synchronized (this.beanDefinitionMap) {this.beanDefinitionMap.put(beanName, beanDefinition);List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);updatedDefinitions.addAll(this.beanDefinitionNames);updatedDefinitions.add(beanName);this.beanDefinitionNames = updatedDefinitions;if (this.manualSingletonNames.contains(beanName)) {Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);updatedSingletons.remove(beanName);this.manualSingletonNames = updatedSingletons;}}}else {// Still in startup registration phasethis.beanDefinitionMap.put(beanName, beanDefinition);this.beanDefinitionNames.add(beanName);this.manualSingletonNames.remove(beanName);}this.frozenBeanDefinitionNames = null;}//检查是否有同名的BeanDefinition已经在IOC容器中注册if (oldBeanDefinition != null || containsSingleton(beanName)) {//重置所有已经注册过的BeanDefinition的缓存resetBeanDefinition(beanName);}
}

至此，Bean配置信息中配置的Bean被解析过后，已经注册到IOC容器中，被容器管理起来，真正完 成了 IOC容器初始化所做的全部工作。现在IOC容器中已经建立了整个Bean的配置信息，这些 BeanDefinition信息已经可以使用，并且可以被检索，IOC容器的作用就是对这些注册的Bean定义信 息进行处理和维护。这些的注册的Bean定义信息是IOC容器控制反转的基础，正是有了这些注册的数
据 ，容器才可以进行依赖注入。

5.基于Annotation的 IOC初始化

1.Annotation的前世今生

从 Spring2.0以后的版本中,Spring也引入了基于注解(Annotation)方式的配置,注解(Annotation)
是JDK1.5中引入的一个新特性，用于简化Bean的配置，可以取代XML配置文件。开发人员对注解 (Annotation)的态度也是萝卜青菜各有所爱，个人认为注解可以大大简化配置，提高开发速度，但也给 后期御户增加了雄度。目前来说XML方式发展的相对成熟，方便于统一管理。Spring Boot的兴 起 ,基于注解的开发甚至实现了零配置。但作为个人的习惯而言，还是倾向于XML配置文件和注解
(Annotation)相互配合使用。Spring IOC容器对于类级别的注解和类内部的注解分以下两种处理策略:

1)、类级别的注解：如 @Component、 @Repository 、@Controller、 @Service 以及 JavaEE6 的
@ManagedBean和@Named注解，都是添加在美上面的类级别注解Spring容器根据注解的过滤规 则扫描读取注解Bean定义类，并将其注册到Spring IOC容器中。

2)、类内部的注解:如@Autowire. @Value. @Resource以及EJB和 WebService相关的注解等,
都是添加在类内部的字段或者方法上的类内部注解,SpringlOC容器通过Bean后置注解处理器解析 Bean内部的注解。下面将根据这两种处理策略，分别分析Spring处理注解相关的源码。

2.定位Bean扫描路径

在 Spring中 管 理 注 解 Bean定 义 的 容 器 有 两 个 :AnnotationConfigApplicationContext和 AnnotationConfigWebApplicationContexo 这两个类是专门处理Spring注解方式配置的容器，直接 依赖于注解作为容器配置信息来源的IOC容器。AnnotationConfigWebApplicationContext是 AnnotationConfigApplicationContext的 Web版本,两者的用法以及对注解的处理方式几乎没有差 别。现在我们以AnnotationConfigApplicationContext为例看看它的源码：

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {//保存一个读取注解的Bean定义读取器，并将其设置到容器中private final AnnotatedBeanDefinitionReader reader;//保存一个扫描指定类路径中注解Bean定义的扫描器，并将其设置到容器中private final ClassPathBeanDefinitionScanner scanner;//默认构造函数，初始化一个空容器，容器不包含任何 Bean 信息，需要在稍后通过调用其register()//方法注册配置类，并调用refresh()方法刷新容器，触发容器对注解Bean的载入、解析和注册过程public AnnotationConfigApplicationContext() {this.reader = new AnnotatedBeanDefinitionReader(this);this.scanner = new ClassPathBeanDefinitionScanner(this);}public AnnotationConfigApplicationContext(DefaultListableBeanFactory beanFactory) {super(beanFactory);this.reader = new AnnotatedBeanDefinitionReader(this);this.scanner = new ClassPathBeanDefinitionScanner(this);}//最常用的构造函数，通过将涉及到的配置类传递给该构造函数，以实现将相应配置类中的Bean自动注册到容器中public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {this();register(annotatedClasses);refresh();}//该构造函数会自动扫描以给定的包及其子包下的所有类，并自动识别所有的Spring Bean，将其注册到容器中public AnnotationConfigApplicationContext(String... basePackages) {this();scan(basePackages);refresh();}@Overridepublic void setEnvironment(ConfigurableEnvironment environment) {super.setEnvironment(environment);this.reader.setEnvironment(environment);this.scanner.setEnvironment(environment);}//为容器的注解Bean读取器和注解Bean扫描器设置Bean名称产生器public void setBeanNameGenerator(BeanNameGenerator beanNameGenerator) {this.reader.setBeanNameGenerator(beanNameGenerator);this.scanner.setBeanNameGenerator(beanNameGenerator);getBeanFactory().registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);}/*** Set the {@link ScopeMetadataResolver} to use for detected bean classes.* <p>The default is an {@link AnnotationScopeMetadataResolver}.* <p>Any call to this method must occur prior to calls to {@link #register(Class...)}* and/or {@link #scan(String...)}.*///为容器的注解Bean读取器和注解Bean扫描器设置作用范围元信息解析器public void setScopeMetadataResolver(ScopeMetadataResolver scopeMetadataResolver) {this.reader.setScopeMetadataResolver(scopeMetadataResolver);this.scanner.setScopeMetadataResolver(scopeMetadataResolver);}//---------------------------------------------------------------------// Implementation of AnnotationConfigRegistry//---------------------------------------------------------------------//为容器注册一个要被处理的注解Bean，新注册的Bean，必须手动调用容器的//refresh()方法刷新容器，触发容器对新注册的Bean的处理public void register(Class<?>... annotatedClasses) {Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");this.reader.register(annotatedClasses);}//扫描指定包路径及其子包下的注解类，为了使新添加的类被处理，必须手动调用//refresh()方法刷新容器public void scan(String... basePackages) {Assert.notEmpty(basePackages, "At least one base package must be specified");this.scanner.scan(basePackages);}//---------------------------------------------------------------------// Convenient methods for registering individual beans//---------------------------------------------------------------------public <T> void registerBean(Class<T> annotatedClass, Object... constructorArguments) {registerBean(null, annotatedClass, constructorArguments);}public <T> void registerBean(@Nullable String beanName, Class<T> annotatedClass, Object... constructorArguments) {this.reader.doRegisterBean(annotatedClass, null, beanName, null,bd -> {for (Object arg : constructorArguments) {bd.getConstructorArgumentValues().addGenericArgumentValue(arg);}});}@Overridepublic <T> void registerBean(@Nullable String beanName, Class<T> beanClass, @Nullable Supplier<T> supplier,BeanDefinitionCustomizer... customizers) {this.reader.doRegisterBean(beanClass, supplier, beanName, null, customizers);}}

通过上面的源码分析，我们可以看啊到Spring对注解的处理分为两种方式:

1. 、直接将注解Bean注册到容器中
   可以在初始化容器时注册;也可以在容器创建之后手动调用注册方法向容器注册，然后通过手动刷新容
   器 ，使得容器对注册的注解Bean进行处理。

2. 、通过扫描指定的包及其子包下的所有类
   在初始化注解容器时指定要自动扫描的路径，如果容器创建以后向给定路径动态添加了注解Bean，则 需要手动调用容器扫描的方法，然后手动刷新容器，使得容器对所注册的Bean进行处理。 接下来，将会对两种处理方式详细分析其实现过程。

3.读取Annotation元数据

当创建注解处理容器时，如果传入的初始参数是具体的注解Bean定义类时,注解容器读取并注册。

1 ). AnnotationConfigApplicationContext 通过调用注解 Bean 定义读取器 AnnotatedBeanDefinitionReader的 register。方法向容器注册指定的注解Bean，注解Bean定义读
取器向容器注册注解Bean的源码如下:

//注册多个注解Bean定义类
public void register(Class<?>... annotatedClasses) {for (Class<?> annotatedClass : annotatedClasses) {registerBean(annotatedClass);}
}//注册一个注解Bean定义类
public void registerBean(Class<?> annotatedClass) {doRegisterBean(annotatedClass, null, null, null);
}public <T> void registerBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier) {doRegisterBean(annotatedClass, instanceSupplier, null, null);
}public <T> void registerBean(Class<T> annotatedClass, String name, @Nullable Supplier<T> instanceSupplier) {doRegisterBean(annotatedClass, instanceSupplier, name, null);
}//Bean定义读取器注册注解Bean定义的入口方法
@SuppressWarnings("unchecked")
public void registerBean(Class<?> annotatedClass, Class<? extends Annotation>... qualifiers) {doRegisterBean(annotatedClass, null, null, qualifiers);
}//Bean定义读取器向容器注册注解Bean定义类
@SuppressWarnings("unchecked")
public void registerBean(Class<?> annotatedClass, String name, Class<? extends Annotation>... qualifiers) {doRegisterBean(annotatedClass, null, name, qualifiers);
}//Bean定义读取器向容器注册注解Bean定义类
<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {//根据指定的注解Bean定义类，创建Spring容器中对注解Bean的封装的数据结构AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {return;}abd.setInstanceSupplier(instanceSupplier);//解析注解Bean定义的作用域，若@Scope("prototype")，则Bean为原型类型；//若@Scope("singleton")，则Bean为单态类型ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);//为注解Bean定义设置作用域abd.setScope(scopeMetadata.getScopeName());//为注解Bean定义生成Bean名称String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));//处理注解Bean定义中的通用注解AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);//如果在向容器注册注解Bean定义时，使用了额外的限定符注解，则解析限定符注解。//主要是配置的关于autowiring自动依赖注入装配的限定条件，即@Qualifier注解//Spring自动依赖注入装配默认是按类型装配，如果使用@Qualifier则按名称if (qualifiers != null) {for (Class<? extends Annotation> qualifier : qualifiers) {//如果配置了@Primary注解，设置该Bean为autowiring自动依赖注入装//配时的首选if (Primary.class == qualifier) {abd.setPrimary(true);}//如果配置了@Lazy注解，则设置该Bean为非延迟初始化，如果没有配置，//则该Bean为预实例化else if (Lazy.class == qualifier) {abd.setLazyInit(true);}//如果使用了除@Primary和@Lazy以外的其他注解，则为该Bean添加一//个autowiring自动依赖注入装配限定符，该Bean在进autowiring//自动依赖注入装配时，根据名称装配限定符指定的Beanelse {abd.addQualifier(new AutowireCandidateQualifier(qualifier));}}}for (BeanDefinitionCustomizer customizer : definitionCustomizers) {customizer.customize(abd);}//创建一个指定Bean名称的Bean定义对象，封装注解Bean定义类数据BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);//根据注解Bean定义类中配置的作用域，创建相应的代理对象definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);//向IOC容器注册注解Bean类定义对象BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {Assert.notNull(registry, "BeanDefinitionRegistry must not be null");if (registry instanceof EnvironmentCapable) {return ((EnvironmentCapable) registry).getEnvironment();}return new StandardEnvironment();
}

从上面的源码我们可以看出，注册注解Bean定义类的基本步骤:

a、需要使用注解元数据解析器解析注解Bean中关于作用域的配置。

b、使用 AnnotationConfiglltils 的 processCommonDefinitionAnnotationsQ方法处理注解 Bean 定
义类中通用的注解。

c、使用AnnotationConfigUtils的 applyScopedProxyMode。方法创建对于作用域的代理对象。

d、通过 BeanDefinitionReaderlltils 向容器注册 Bean.

下面我们继续分析这4步的具体实现过程

2). AnnotationScopeMetadataResolver 解析作用域元数据

AnnotationScopeMetadataResolver通过 resolveScopeMetadata()方法解析注解 Bean 定义类的作
用域元信息,即判断注册的Bean是原生类型(prototype)是单态(singleton)类 型 ,其源码如下:

//解析注解Bean定义类中的作用域元信息
@Override
public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {ScopeMetadata metadata = new ScopeMetadata();if (definition instanceof AnnotatedBeanDefinition) {AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition;//从注解Bean定义类的属性中查找属性为”Scope”的值，即@Scope注解的值//annDef.getMetadata().getAnnotationAttributes()方法将Bean//中所有的注解和注解的值存放在一个map集合中AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(annDef.getMetadata(), this.scopeAnnotationType);//将获取到的@Scope注解的值设置到要返回的对象中if (attributes != null) {metadata.setScopeName(attributes.getString("value"));//获取@Scope注解中的proxyMode属性值，在创建代理对象时会用到ScopedProxyMode proxyMode = attributes.getEnum("proxyMode");//如果@Scope的proxyMode属性为DEFAULT或者NOif (proxyMode == ScopedProxyMode.DEFAULT) {//设置proxyMode为NOproxyMode = this.defaultProxyMode;}//为返回的元数据设置proxyModemetadata.setScopedProxyMode(proxyMode);}}//返回解析的作用域元信息对象return metadata;
}

上述代码中的annDef.getMetadata().getAnnotationAttributes()方法就是获取对象中指定类型的注
解的值。

3).AnnotationConfigUtils处理注解Bean定义类中的通用注解

AnnotationConfiglltils 类的 processCommonDefinitionAnnotations()在向容器注册 Bean 之 前 ，首
先对注解Bean定义类中的通用Spring注解进行处理,源码如下：

//处理Bean定义中通用注解
static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);//如果Bean定义中有@Lazy注解，则将该Bean预实例化属性设置为@lazy注解的值if (lazy != null) {abd.setLazyInit(lazy.getBoolean("value"));}else if (abd.getMetadata() != metadata) {lazy = attributesFor(abd.getMetadata(), Lazy.class);if (lazy != null) {abd.setLazyInit(lazy.getBoolean("value"));}}//如果Bean定义中有@Primary注解，则为该Bean设置为autowiring自动依赖注入装配的首选对象if (metadata.isAnnotated(Primary.class.getName())) {abd.setPrimary(true);}//如果Bean定义中有@ DependsOn注解，则为该Bean设置所依赖的Bean名称，//容器将确保在实例化该Bean之前首先实例化所依赖的BeanAnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);if (dependsOn != null) {abd.setDependsOn(dependsOn.getStringArray("value"));}if (abd instanceof AbstractBeanDefinition) {AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;AnnotationAttributes role = attributesFor(metadata, Role.class);if (role != null) {absBd.setRole(role.getNumber("value").intValue());}AnnotationAttributes description = attributesFor(metadata, Description.class);if (description != null) {absBd.setDescription(description.getString("value"));}}
}

4). AnnotationConfigUtils根据注解Bean定义类中配置的作用域为其应用相应的代理策略

AnnotationConfiglltils类的applyScopedProxyMode()方法根据注解Bean定义类中配置的作用域
@Scope注解的值,为 Bean定义应用相应的代理模式,主要是在Spring面向切面编程(AOP)中使用。
源码如下:

//根据作用域为Bean应用引用的代码模式
static BeanDefinitionHolder applyScopedProxyMode(ScopeMetadata metadata, BeanDefinitionHolder definition, BeanDefinitionRegistry registry) {//获取注解Bean定义类中@Scope注解的proxyMode属性值ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode();//如果配置的@Scope注解的proxyMode属性值为NO，则不应用代理模式if (scopedProxyMode.equals(ScopedProxyMode.NO)) {return definition;}//获取配置的@Scope注解的proxyMode属性值，如果为TARGET_CLASS//则返回true，如果为INTERFACES，则返回falseboolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS);//为注册的Bean创建相应模式的代理对象return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
}

这段为Bean引用创建相应模式的代理,这里不做深入的分析。

5). BeanDefinitionReaderUtils

向容器注册 Bean BeanDefinitionReaderUtils主要是校验BeanDefinition信 息 ，然后将Bean添加到容器中一个管理
BeanDefinition 的 HashMap 中。

4.扫描指定包并解析为BeanDefinition

当创建注解处理容器时，如果传入的初始参数是注解Bean定义类所在的包时，注解容器将扫描给定的 包及其子包，将扫描到的注解Bean定义载入并注册。

1). ClassPathBeanDefinitionScanner 扫描给定的包及其子包

AnnotationConfigApplicationContext 通 过 调 用 类 路 径 Bean 定 义 扫 描 ClassPathBeanDefinitionScanner扫描给定包及其子包下的所有类,主要源码如下：

public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {//创建一个类路径Bean定义扫描器public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {this(registry, true);}//为容器创建一个类路径Bean定义扫描器，并指定是否使用默认的扫描过滤规则。//即Spring默认扫描配置：@Component、@Repository、@Service、@Controller//注解的Bean，同时也支持JavaEE6的@ManagedBean和JSR-330的@Named注解public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {this(registry, useDefaultFilters, getOrCreateEnvironment(registry));}public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,Environment environment) {this(registry, useDefaultFilters, environment,(registry instanceof ResourceLoader ? (ResourceLoader) registry : null));}public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,Environment environment, @Nullable ResourceLoader resourceLoader) {Assert.notNull(registry, "BeanDefinitionRegistry must not be null");//为容器设置加载Bean定义的注册器this.registry = registry;if (useDefaultFilters) {registerDefaultFilters();}setEnvironment(environment);//为容器设置资源加载器setResourceLoader(resourceLoader);}@Overridepublic final BeanDefinitionRegistry getRegistry() {return this.registry;}public void setBeanDefinitionDefaults(@Nullable BeanDefinitionDefaults beanDefinitionDefaults) {this.beanDefinitionDefaults =(beanDefinitionDefaults != null ? beanDefinitionDefaults : new BeanDefinitionDefaults());}public BeanDefinitionDefaults getBeanDefinitionDefaults() {return this.beanDefinitionDefaults;}public void setAutowireCandidatePatterns(@Nullable String... autowireCandidatePatterns) {this.autowireCandidatePatterns = autowireCandidatePatterns;}public void setBeanNameGenerator(@Nullable BeanNameGenerator beanNameGenerator) {this.beanNameGenerator = (beanNameGenerator != null ? beanNameGenerator : new AnnotationBeanNameGenerator());}public void setScopeMetadataResolver(@Nullable ScopeMetadataResolver scopeMetadataResolver) {this.scopeMetadataResolver =(scopeMetadataResolver != null ? scopeMetadataResolver : new AnnotationScopeMetadataResolver());}public void setScopedProxyMode(ScopedProxyMode scopedProxyMode) {this.scopeMetadataResolver = new AnnotationScopeMetadataResolver(scopedProxyMode);}public void setIncludeAnnotationConfig(boolean includeAnnotationConfig) {this.includeAnnotationConfig = includeAnnotationConfig;}//调用类路径Bean定义扫描器入口方法public int scan(String... basePackages) {//获取容器中已经注册的Bean个数int beanCountAtScanStart = this.registry.getBeanDefinitionCount();//启动扫描器扫描给定包doScan(basePackages);// Register annotation config processors, if necessary.//注册注解配置(Annotation config)处理器if (this.includeAnnotationConfig) {AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);}//返回注册的Bean个数return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);}//类路径Bean定义扫描器扫描给定包及其子包protected Set<BeanDefinitionHolder> doScan(String... basePackages) {Assert.notEmpty(basePackages, "At least one base package must be specified");//创建一个集合，存放扫描到Bean定义的封装类Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();//遍历扫描所有给定的包for (String basePackage : basePackages) {//调用父类ClassPathScanningCandidateComponentProvider的方法//扫描给定类路径，获取符合条件的Bean定义Set<BeanDefinition> candidates = findCandidateComponents(basePackage);//遍历扫描到的Beanfor (BeanDefinition candidate : candidates) {//获取Bean定义类中@Scope注解的值，即获取Bean的作用域ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);//为Bean设置注解配置的作用域candidate.setScope(scopeMetadata.getScopeName());//为Bean生成名称String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);//如果扫描到的Bean不是Spring的注解Bean，则为Bean设置默认值，//设置Bean的自动依赖注入装配属性等if (candidate instanceof AbstractBeanDefinition) {postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);}//如果扫描到的Bean是Spring的注解Bean，则处理其通用的Spring注解if (candidate instanceof AnnotatedBeanDefinition) {//处理注解Bean中通用的注解，在分析注解Bean定义类读取器时已经分析过AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);}//根据Bean名称检查指定的Bean是否需要在容器中注册，或者在容器中冲突if (checkCandidate(beanName, candidate)) {BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);//根据注解中配置的作用域，为Bean应用相应的代理模式definitionHolder =AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);beanDefinitions.add(definitionHolder);//向容器注册扫描到的BeanregisterBeanDefinition(definitionHolder, this.registry);}}}return beanDefinitions;}protected void postProcessBeanDefinition(AbstractBeanDefinition beanDefinition, String beanName) {beanDefinition.applyDefaults(this.beanDefinitionDefaults);if (this.autowireCandidatePatterns != null) {beanDefinition.setAutowireCandidate(PatternMatchUtils.simpleMatch(this.autowireCandidatePatterns, beanName));}}protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);}protected boolean checkCandidate(String beanName, BeanDefinition beanDefinition) throws IllegalStateException {if (!this.registry.containsBeanDefinition(beanName)) {return true;}BeanDefinition existingDef = this.registry.getBeanDefinition(beanName);BeanDefinition originatingDef = existingDef.getOriginatingBeanDefinition();if (originatingDef != null) {existingDef = originatingDef;}if (isCompatible(beanDefinition, existingDef)) {return false;}throw new ConflictingBeanDefinitionException("Annotation-specified bean name '" + beanName +"' for bean class [" + beanDefinition.getBeanClassName() + "] conflicts with existing, " +"non-compatible bean definition of same name and class [" + existingDef.getBeanClassName() + "]");}protected boolean isCompatible(BeanDefinition newDefinition, BeanDefinition existingDefinition) {return (!(existingDefinition instanceof ScannedGenericBeanDefinition) ||  // explicitly registered overriding bean(newDefinition.getSource() != null && newDefinition.getSource().equals(existingDefinition.getSource())) ||  // scanned same file twicenewDefinition.equals(existingDefinition));  // scanned equivalent class twice}private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {Assert.notNull(registry, "BeanDefinitionRegistry must not be null");if (registry instanceof EnvironmentCapable) {return ((EnvironmentCapable) registry).getEnvironment();}return new StandardEnvironment();}}

类路径 Bean 定义扫描器 ClassPathBeanDefinitionScanner 主要通过 findCandidateComponents() 方法调用其父类ClassPathScanningCandidateComponentProvider类来扫描获取给定包及其子包下
的类。

2). ClassPathScanningCandidateComponentProvider 扫描给定包及其子包的类

ClassPathScanningCandidateComponentProvider 类的 findCandidateComponents()方法具体实
现扫描给定类路径包的功能，主要源码如下:

public class ClassPathScanningCandidateComponentProvider implements EnvironmentCapable, ResourceLoaderAware {static final String DEFAULT_RESOURCE_PATTERN = "**/*.class";protected final Log logger = LogFactory.getLog(getClass());private String resourcePattern = DEFAULT_RESOURCE_PATTERN;//保存过滤规则要包含的注解，即Spring默认的@Component、@Repository、@Service、//@Controller注解的Bean，以及JavaEE6的@ManagedBean和JSR-330的@Named注解private final List<TypeFilter> includeFilters = new LinkedList<>();//保存过滤规则要排除的注解private final List<TypeFilter> excludeFilters = new LinkedList<>();@Nullableprivate Environment environment;@Nullableprivate ConditionEvaluator conditionEvaluator;@Nullableprivate ResourcePatternResolver resourcePatternResolver;@Nullableprivate MetadataReaderFactory metadataReaderFactory;@Nullableprivate CandidateComponentsIndex componentsIndex;protected ClassPathScanningCandidateComponentProvider() {}//构造方法，该方法在子类ClassPathBeanDefinitionScanner的构造方法中被调用public ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters) {this(useDefaultFilters, new StandardEnvironment());}public ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters, Environment environment) {//如果使用Spring默认的过滤规则，则向容器注册过滤规则if (useDefaultFilters) {registerDefaultFilters();}setEnvironment(environment);setResourceLoader(null);}public void setResourcePattern(String resourcePattern) {Assert.notNull(resourcePattern, "'resourcePattern' must not be null");this.resourcePattern = resourcePattern;}public void addIncludeFilter(TypeFilter includeFilter) {this.includeFilters.add(includeFilter);}public void addExcludeFilter(TypeFilter excludeFilter) {this.excludeFilters.add(0, excludeFilter);}public void resetFilters(boolean useDefaultFilters) {this.includeFilters.clear();this.excludeFilters.clear();if (useDefaultFilters) {registerDefaultFilters();}}//向容器注册过滤规则@SuppressWarnings("unchecked")protected void registerDefaultFilters() {//向要包含的过滤规则中添加@Component注解类，注意Spring中@Repository//@Service和@Controller都是Component，因为这些注解都添加了@Component注解this.includeFilters.add(new AnnotationTypeFilter(Component.class));//获取当前类的类加载器ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();try {//向要包含的过滤规则添加JavaEE6的@ManagedBean注解this.includeFilters.add(new AnnotationTypeFilter(((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");}catch (ClassNotFoundException ex) {// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.}try {//向要包含的过滤规则添加@Named注解this.includeFilters.add(new AnnotationTypeFilter(((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");}catch (ClassNotFoundException ex) {// JSR-330 API not available - simply skip.}}public void setEnvironment(Environment environment) {Assert.notNull(environment, "Environment must not be null");this.environment = environment;this.conditionEvaluator = null;}@Overridepublic final Environment getEnvironment() {if (this.environment == null) {this.environment = new StandardEnvironment();}return this.environment;}@Nullableprotected BeanDefinitionRegistry getRegistry() {return null;}@Overridepublic void setResourceLoader(@Nullable ResourceLoader resourceLoader) {this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);this.metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader);this.componentsIndex = CandidateComponentsIndexLoader.loadIndex(this.resourcePatternResolver.getClassLoader());}public final ResourceLoader getResourceLoader() {return getResourcePatternResolver();}private ResourcePatternResolver getResourcePatternResolver() {if (this.resourcePatternResolver == null) {this.resourcePatternResolver = new PathMatchingResourcePatternResolver();}return this.resourcePatternResolver;}public void setMetadataReaderFactory(MetadataReaderFactory metadataReaderFactory) {this.metadataReaderFactory = metadataReaderFactory;}public final MetadataReaderFactory getMetadataReaderFactory() {if (this.metadataReaderFactory == null) {this.metadataReaderFactory = new CachingMetadataReaderFactory();}return this.metadataReaderFactory;}//扫描给定类路径的包public Set<BeanDefinition> findCandidateComponents(String basePackage) {if (this.componentsIndex != null && indexSupportsIncludeFilters()) {return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);}else {return scanCandidateComponents(basePackage);}}private boolean indexSupportsIncludeFilters() {for (TypeFilter includeFilter : this.includeFilters) {if (!indexSupportsIncludeFilter(includeFilter)) {return false;}}return true;}private boolean indexSupportsIncludeFilter(TypeFilter filter) {if (filter instanceof AnnotationTypeFilter) {Class<? extends Annotation> annotation = ((AnnotationTypeFilter) filter).getAnnotationType();return (AnnotationUtils.isAnnotationDeclaredLocally(Indexed.class, annotation) ||annotation.getName().startsWith("javax."));}if (filter instanceof AssignableTypeFilter) {Class<?> target = ((AssignableTypeFilter) filter).getTargetType();return AnnotationUtils.isAnnotationDeclaredLocally(Indexed.class, target);}return false;}@Nullableprivate String extractStereotype(TypeFilter filter) {if (filter instanceof AnnotationTypeFilter) {return ((AnnotationTypeFilter) filter).getAnnotationType().getName();}if (filter instanceof AssignableTypeFilter) {return ((AssignableTypeFilter) filter).getTargetType().getName();}return null;}private Set<BeanDefinition> addCandidateComponentsFromIndex(CandidateComponentsIndex index, String basePackage) {//创建存储扫描到的类的集合Set<BeanDefinition> candidates = new LinkedHashSet<>();try {Set<String> types = new HashSet<>();for (TypeFilter filter : this.includeFilters) {String stereotype = extractStereotype(filter);if (stereotype == null) {throw new IllegalArgumentException("Failed to extract stereotype from "+ filter);}types.addAll(index.getCandidateTypes(basePackage, stereotype));}boolean traceEnabled = logger.isTraceEnabled();boolean debugEnabled = logger.isDebugEnabled();for (String type : types) {//为指定资源获取元数据读取器，元信息读取器通过汇编(ASM)读//取资源元信息MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(type);//如果扫描到的类符合容器配置的过滤规则if (isCandidateComponent(metadataReader)) {//通过汇编(ASM)读取资源字节码中的Bean定义元信息AnnotatedGenericBeanDefinition sbd = new AnnotatedGenericBeanDefinition(metadataReader.getAnnotationMetadata());if (isCandidateComponent(sbd)) {if (debugEnabled) {logger.debug("Using candidate component class from index: " + type);}candidates.add(sbd);}else {if (debugEnabled) {logger.debug("Ignored because not a concrete top-level class: " + type);}}}else {if (traceEnabled) {logger.trace("Ignored because matching an exclude filter: " + type);}}}}catch (IOException ex) {throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);}return candidates;}private Set<BeanDefinition> scanCandidateComponents(String basePackage) {Set<BeanDefinition> candidates = new LinkedHashSet<>();try {String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +resolveBasePackage(basePackage) + '/' + this.resourcePattern;Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);boolean traceEnabled = logger.isTraceEnabled();boolean debugEnabled = logger.isDebugEnabled();for (Resource resource : resources) {if (traceEnabled) {logger.trace("Scanning " + resource);}if (resource.isReadable()) {try {MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);if (isCandidateComponent(metadataReader)) {ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);sbd.setResource(resource);sbd.setSource(resource);if (isCandidateComponent(sbd)) {if (debugEnabled) {logger.debug("Identified candidate component class: " + resource);}candidates.add(sbd);}else {if (debugEnabled) {logger.debug("Ignored because not a concrete top-level class: " + resource);}}}else {if (traceEnabled) {logger.trace("Ignored because not matching any filter: " + resource);}}}catch (Throwable ex) {throw new BeanDefinitionStoreException("Failed to read candidate component class: " + resource, ex);}}else {if (traceEnabled) {logger.trace("Ignored because not readable: " + resource);}}}}catch (IOException ex) {throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);}return candidates;}protected String resolveBasePackage(String basePackage) {return ClassUtils.convertClassNameToResourcePath(getEnvironment().resolveRequiredPlaceholders(basePackage));//判断元信息读取器读取的类是否符合容器定义的注解过滤规则protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {//如果读取的类的注解在排除注解过滤规则中，返回falsefor (TypeFilter tf : this.excludeFilters) {if (tf.match(metadataReader, getMetadataReaderFactory())) {return false;}}//如果读取的类的注解在包含的注解的过滤规则中，则返回turefor (TypeFilter tf : this.includeFilters) {if (tf.match(metadataReader, getMetadataReaderFactory())) {return isConditionMatch(metadataReader);}}//如果读取的类的注解既不在排除规则，也不在包含规则中，则返回falsereturn false;}/*** Determine whether the given class is a candidate component based on any* {@code @Conditional} annotations.* @param metadataReader the ASM ClassReader for the class* @return whether the class qualifies as a candidate component*/private boolean isConditionMatch(MetadataReader metadataReader) {if (this.conditionEvaluator == null) {this.conditionEvaluator =new ConditionEvaluator(getRegistry(), this.environment, this.resourcePatternResolver);}return !this.conditionEvaluator.shouldSkip(metadataReader.getAnnotationMetadata());}protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {AnnotationMetadata metadata = beanDefinition.getMetadata();return (metadata.isIndependent() && (metadata.isConcrete() ||(metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName()))));}public void clearCache() {if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {// Clear cache in externally provided MetadataReaderFactory; this is a no-op// for a shared cache since it'll be cleared by the ApplicationContext.((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();}}}

5.注册注解 BeanDefinition

AnnotationConfigWebApplicationContext 是 AnnotationConfigApplicationContext 的 Web 版 , 它们对于注解Bean的注册和扫描是基本相同的,但是AnnotationConfigWebApplicationContext 对注解Bean定义的载入稍有不同, AnnotationConfigWebApplicationContext注入注解Bean定义
源码如下：

//载入注解Bean定义资源
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {//为容器设置注解Bean定义读取器AnnotatedBeanDefinitionReader reader = getAnnotatedBeanDefinitionReader(beanFactory);//为容器设置类路径Bean定义扫描器ClassPathBeanDefinitionScanner scanner = getClassPathBeanDefinitionScanner(beanFactory);//获取容器的Bean名称生成器BeanNameGenerator beanNameGenerator = getBeanNameGenerator();//为注解Bean定义读取器和类路径扫描器设置Bean名称生成器if (beanNameGenerator != null) {reader.setBeanNameGenerator(beanNameGenerator);scanner.setBeanNameGenerator(beanNameGenerator);beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);}//获取容器的作用域元信息解析器ScopeMetadataResolver scopeMetadataResolver = getScopeMetadataResolver();//为注解Bean定义读取器和类路径扫描器设置作用域元信息解析器if (scopeMetadataResolver != null) {reader.setScopeMetadataResolver(scopeMetadataResolver);scanner.setScopeMetadataResolver(scopeMetadataResolver);}if (!this.annotatedClasses.isEmpty()) {if (logger.isInfoEnabled()) {logger.info("Registering annotated classes: [" +StringUtils.collectionToCommaDelimitedString(this.annotatedClasses) + "]");}reader.register(this.annotatedClasses.toArray(new Class<?>[this.annotatedClasses.size()]));}if (!this.basePackages.isEmpty()) {if (logger.isInfoEnabled()) {logger.info("Scanning base packages: [" +StringUtils.collectionToCommaDelimitedString(this.basePackages) + "]");}scanner.scan(this.basePackages.toArray(new String[this.basePackages.size()]));}//获取容器定义的Bean定义资源路径String[] configLocations = getConfigLocations();//如果定位的Bean定义资源路径不为空if (configLocations != null) {for (String configLocation : configLocations) {try {//使用当前容器的类加载器加载定位路径的字节码类文件Class<?> clazz = ClassUtils.forName(configLocation, getClassLoader());if (logger.isInfoEnabled()) {logger.info("Successfully resolved class for [" + configLocation + "]");}reader.register(clazz);}catch (ClassNotFoundException ex) {if (logger.isDebugEnabled()) {logger.debug("Could not load class for config location [" + configLocation +"] - trying package scan. " + ex);}//如果容器类加载器加载定义路径的Bean定义资源失败//则启用容器类路径扫描器扫描给定路径包及其子包中的类int count = scanner.scan(configLocation);if (logger.isInfoEnabled()) {if (count == 0) {logger.info("No annotated classes found for specified class/package [" + configLocation + "]");}else {logger.info("Found " + count + " annotated classes in package [" + configLocation + "]");}}}}}
}

以上就是解析和注入注解配置资源的全过程分析。

6.IOC容器初始化小结

现在通过上面的代码，总结一下IOC容器初始化的基本步骤:

1、初始化的入口在容器实现中的refresh调用来完成。

2、对 Bean定义载入IOC容器使用的方法是loadBeanDefinition

其中的大致过程如下：通过ResourceLoader来完成资源文件位置的定位，DefaultResourceLoader
是默认的实现，同时上下文本身就给出了 ResourceLoader的实现,可以从类路径,文件系统,URL等 方式来定为资源位置。如果是XmlBeanFactory作为IOC容器，那么需要为它指定Bean定义的资源, 也 就 是 说 Bean定 义 文 件 时 通 过 抽 象 成 Resource来 被 IO C容 器 处 理 的 ，容器通过 BeanDefinitionReader来 完 成 定 义 信 息 的 解 析 和 Bean信 息的 注 册 ，往 往 使 用 的 是
XmlBeanDefinitionReader来 解 析 Bean的 XM L定 义 文 件 -实 际 的 处 理 过 程 是 委托给 BeanDefinitionParserDelegate来完成的，从而得到bean的定义信息，这些信息在Spring中使用

BeanDefinition 对象来表示-这个名字可以让我们想到 loadBeanDefinition(),registerBeanDefinition。这些相关方法。它们都是为处理BeanDefinitin服务的，容器解析得到BeanDefinition以后,需要把
它在IOC容器中注册，这由IOC实现BeanDefinitionRegistry接口来实现。注册过程就是在IOC容器 内部维护的一个HashMap来保存得到的BeanDefinition的过程。这 个 HashMap是 IOC容器持有
Bean信息的场所，以后对Bean的操作都是围绕这个HashMap来实现的。
然后我们就可以通过BeanFactory和 Applicationcontext来享受到Spring IOC的服务了,在使用IOC
容器的时候，我们注意到除了少量粘合代码，绝大多数以正确IOC风格编写的应用程序代码完全不用关
心如何到达工厂,因为容器将把这些对象与容器管理的其他对象钩在一起。基本的策略是把工厂放到已
知的地方，最好是放在对预期使用的上下文有意义的地方，以及代码将实际需要访问工厂的地方。Spring 本身提供了对声明式载入web应用程序用法的应用程序上下文，并将其存储在ServletContext中的框架
实现。

参考资料：

1.《spring 5核心原理与30个类手写实战》谭勇德著

21.手绘Spring IOC运行时序图相关推荐

1. 一步一步手绘Spring IOC运行时序图一（Spring 核心容器 IOC初始化过程）

   相关内容: 架构师系列内容:架构师学习笔记(持续更新) 一步一步手绘Spring IOC运行时序图一(Spring 核心容器 IOC初始化过程) 一步一步手绘Spring IOC运行时序图二(基于XM ...

2. 一步一步手绘Spring IOC运行时序图三（基于Annotation的IOC容器初始化）

   相关内容: 架构师系列内容:架构师学习笔记(持续更新) 一步一步手绘Spring IOC运行时序图一(Spring 核心容器 IOC初始化过程) 一步一步手绘Spring IOC运行时序图二(基于XM ...

3. 一步一步手绘Spring IOC运行时序图二（基于XML的IOC容器初始化）

   相关内容: 架构师系列内容:架构师学习笔记(持续更新) 一步一步手绘Spring IOC运行时序图一(Spring 核心容器 IOC初始化过程) 一步一步手绘Spring IOC运行时序图二(基于XM ...

4. 一步一步手绘Spring MVC运行时序图（Spring MVC原理）

   相关内容: 架构师系列内容:架构师学习笔记(持续更新) 一步一步手绘Spring IOC运行时序图一(Spring 核心容器 IOC初始化过程) 一步一步手绘Spring IOC运行时序图二(基于XM ...

5. 一步一步手绘Spring AOP运行时序图（Spring AOP 源码分析）

   相关内容: 架构师系列内容:架构师学习笔记(持续更新) 一步一步手绘Spring IOC运行时序图一(Spring 核心容器 IOC初始化过程) 一步一步手绘Spring IOC运行时序图二(基于XM ...

6. 一步一步手绘Spring DI运行时序图（Spring 自动装配之依赖注入）

   相关内容: 架构师系列内容:架构师学习笔记(持续更新) 一步一步手绘Spring IOC运行时序图一(Spring 核心容器 IOC初始化过程) 一步一步手绘Spring IOC运行时序图二(基于XM ...

7. 一步一步手绘Spring MVC运行时序图

   Spring MVC 初体验 初探Spring MVC 请求处理流程 Spring MVC 相对于前面的章节算是比较简单的,我们首先引用<Spring in Action>上 的一张图来了 ...

8. 30张设计师的手绘网页草图（原型图/框架图）

   原型图",大家可以看看国外的设计师们是怎样画的,或者参考他们用什么笔.本本什么的 ^_^ 个人网站的手绘框架图 网页设计框架图 彩色手绘Web草图 Initial Wireframe Ske ...

9. spring根据名称获取bean_带你从零开始手写 spring ioc 框架，深入学习 spring 源码

   IoC Ioc 是一款 spring ioc 核心功能简化实现版本,便于学习和理解原理. 创作目的 使用 spring 很长时间,对于 spring 使用非常频繁,实际上对于源码一直没有静下心来学习过 ...

最新文章

1. CakePHP中出现persistent is not writable等Warning的解决方法
2. ITK:灰度图像中的聚类像素
3. Linux基础入门学习笔记之二
4. 为什么dos下的com文件都要org 0100h呢？为什么系统启动时要org 07c00h呢
5. idea 分享代码位置
6. TCP/IP的基本概念
7. ConcurrentHashMap与HashTable的区别
8. 数据治理中哪3点最重要
9. MySQL 8 新特性之持久化全局变量的修改
10. 单元刚度矩阵 C++
11. 地球上最厉害的字体：Helvetica
12. 《王家视频教程图书馆》
13. C#编写IE插件的一些经验
14. python 使用numpy计算混淆矩阵
15. 学习之学习--混沌大学商学院--第一课--HHR计划
16. 资深技术 Leader 曹乐：如何成为技术大牛
17. LVGL 获取光标坐标位置
18. 用CSS画小猪佩奇，你就是下一个社会人！
19. cf四大战区合区列表？
20. BufferedImage是什么意思？

热门文章

1. 软件工程复习知识点汇总（2）
2. MBP远程控制Windows NUC
3. 11.判断一个人出生了多少天
4. 多态的概念简单明了，易掌握，易理解！
5. 6个不亚于公务员的职业选择
6. 电脑如何恢复数据？电脑文件清空了如何恢复数据？
7. 如何理性的调整「rwnd」和「cwnd」的大小
8. 农业科研：大田作物智慧种植
9. 解决Ubuntu18.04无法安装旧版本gfortran4.6
10. 弘辽科技：拼多多类目选错了有什么影响？怎么办？