简介
Spring最重要的概念是IOD和AOP，本篇文章带大家来分析下Spring的IOC容器。源码采用4.3.11，通过基于xml的配置的方式来解析（实际很少人这么做了，至少不是纯xml配置，不过从理解源码的角度来看这种方式比较容易理解）。下面我们开始吧！
Spring源码分析图，这个看起来更清晰一点。
https://blog.csdn.net/qq_37113604/article/details/97931101
引言
首先导入maven依赖：spring-context会自动将spring-core、spring-beans、spring-aop等
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.11.RELEASE</version>
</dependency>基本的启动Spring容器的例子：
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationfile.xml");
}上面启动的例子就是在classpath中寻找xml配置文件，感觉xml文件内容来构建applicationcontext。当然除了ClassPathXmlApplicationContext以外，我们也还有其他构建applicationContext的方案可供选择，大体继承结构为：
可以看到，classPathXmlApplicationContext经过好多层才到ApplicationContext接口，同样的，我们也可以使用绿颜色的FileSystemXmlApplicationContext和AnnotationConfigApplicationContext这两个类。
FileSystemXmlApplicationContext的构造函数需要一个xml配置文件在系统中的路径，其他的和ClassPathXmlApplicationContext基本一样。
AnnotationConfigApplicationContext是基于注解使用的，它不需要配置文件，采用java配置类和各种注解来配置，是比较简单的方式，也是大势所趋。
本文旨在帮助大家理解构建流程，所以决定使用classPathXmlApplicationContext进行分析。
我们先定义一个接口：
public interface MessageService{
String getMessage();
}定义接口实现了类：
public class MessageServiceImpl implements MessageService {
public String getMessage() {
return "hello world";
}
}接下来，我们在resource目录中新建一个配置文件applicaiton.xml:
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd" default-autowire="byName">
<bean id="messageService" class="com.javadoop.example.MessageServiceImpl"/>
</beans>运行程序：
public class App {
public static void main(String[] args) {
// 用我们的配置文件来启动一个 ApplicationContext
ApplicationContext context = new ClassPathXmlApplicationContext("classpath:application.xml");
System.out.println("context 启动成功");
// 从 context 中取出我们的 Bean，而不是用 new MessageServiceImpl() 这种方式
MessageService messageService = context.getBean(MessageService.class);
// 这句将输出: hello world
System.out.println(messageService.getMessage());
}
}以上是一个简单例子，通过它来引出主题，Spring是怎么通过配置文件来启动Spring的ApplicationContext？这也就是我们要分析的IOC的核心了。ApplicationContext启动过程中，会负责创建实例bean，往各个bean中注入依赖等。
BeanFactory简介
beanFactory，从名字上很好理解，生产bean的工厂，它负责生产和管理各个bean实例。
前面的ApplicationContext其实就是一个BeanFactory。
beanFactory主要继承结构：
这张图中有几个重点需要说明一下：
1.ApplicationContext继承了ListbleBeanFactory，这个listable的意思是，通过这个接口，我们可以获取多个bean，大家看源码会发现，最顶层的BeanFactory接口的方法都是获取单个bean。
2.ApplicationContext继承了HierarchicalBeanFactory，Hierarchical单词本身已经能说明问题了，也就是说我们可以在应用中起多个BeanFactory，然后将各个BeanFactory设置为父子关系。
3.AutowirteCapableBeanFactory这个名字中的autowirte，他就是用来自动装配bean用的，但是上图中，ApplicationContext并没有继承它，不过不用担心，不适用继承，不代表不可以组合使用，ApplicationContext接口定义中最后一个方法getAutoCapableBeanFactory就知道了。
4.ConfigurableListableBeanFactory也是一个特殊的接口，特殊之处在于它继承了第二层所有的三个接口，而ApplicaitonContext没有。这里稍后再说。
5.请不要花别的时间在其他接口和类上，先理解这几点即可。
然后打开idea，看一下beanFactory、listableBeanFactory、hierarchicalBeanFactory、AutowireCapableBeanFactory、ApplicaitonContext这几个接口代码，做到心里有数。
启动过程分析
下面将是漫长的代码分析，一定要自己对照着源码看。
第一步，我们肯定要从classPathXmlApplicationContext的构造方法说起。
//如果已经有ApplicationContext并需要配置成父子关系，那么调用这个构造方法
public ClassPathXmlApplicationContext(ApplicationContext parent) {
super(parent);
}
//其余所有的构造方法，最终都会调用这个
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
throws BeansException {
super(parent);
//根据提供的路径，处理成位置文件数组
setConfigLocations(configLocations);
if (refresh) {
//核心方法
refresh();
}
}接下来，我们探讨下refresh()，他为什么叫refersh而不是init之类的名字呢？ 因为ApplicationContext建立起来以后，其实我们是可以通过refresh这个方法重建的，refresh会将原来的ApplicationContext销毁，然后再重新执行一次初始化操作。
refresh方法中调用了很多方法，如下：
public void refresh() throws BeansException, IllegalStateException {
//加锁，不然refresh还没结束，又来个启动或销毁容器的操作，那不乱套了
synchronized (this.startupShutdownMonitor) {
//准备工作，记录容器启动时间，标记已启动状态，处理配置文件中占位符
prepareRefresh();
//这步比较关键，这步完成后，配置文件就会解析成一个个bean定义，注册到beanFactory
//中，这里的bean还没有初始化，只是配置文件都提取出来了，注册也只是将这些信息都保存到了注册中心
//说到底核心是一个beanName -》 beanDefinition的map
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 设置beanFactory的类加载器，添加几个beanPostProcessor，手动注册几个特殊的bean
prepareBeanFactory(beanFactory);
try {
//这里需要知道beanFactoryPostProcessor这个知识点，Bean如果实现了此接口，
//那么在容器初始化后，Spring会负责调用里面的postProcessBeanFactory方法
//这里是提供给子类的扩展点，到这的时候，所有的bean都加载、注册完了，但是都还没有初始化，
//具体子类可以在这步的时候添加一些特殊的beanFactoryPostProcessor的实现类或做点什么事
postProcessBeanFactory(beanFactory);
//调用beanFactoryPostProcessor的实现类的postProcessBeanFactory方法
invokeBeanFactoryPostProcessors(beanFactory);
//注册BeanPortProcessor的实现类，这里和BeanFactoryPostProcessor有区别的。
//此接口两个方法：postProcessBeforeInitialization和postProcessAfterInitialization
//两个方法分别在Bean初始化之前和初始化之后得到执行。注意：到这里Bean还没初始化
registerBeanPostProcessors(beanFactory);
//初始化当前Application的MessageSource，国际化这里不展开说，不然没完没了
initMessageSource();
//初始化当前ApplicaitonContext的事件广播器，这里也不展开
initApplicationEventMulticaster();
//从方法名可以知道，典型的模板方法（钩子方法）
//具体的子类可以在这初始化一些特殊的bean（在初始化singleton beans之前）
onRefresh();
//注册事件监听器，监听器需要实现ApplicaitonListener接口
registerListeners();
//初始化所有的singleton beans lazy-init除外
finishBeanFactoryInitialization(beanFactory);
//最后广播事件，ApplicaitonCOntext初始化完成
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
//销毁已经初始化的singleton的beans，以免有些bena会一直占用资源
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();
}
}
}下面，我们开始一步步肢解这个refresh方法。
创建Bean容器的准备工作
这个比较简单，直接看代码中的几个注释即可。
protected void prepareRefresh() {
// 记录启动时间，
// 将 active 属性设置为 true，closed 属性设置为 false，它们都是 AtomicBoolean 类型
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
if (logger.isInfoEnabled()) {
logger.info("Refreshing " + this);
}
// Initialize any placeholder property sources in the context environment
initPropertySources();
// 校验 xml 配置文件
getEnvironment().validateRequiredProperties();
this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}创建bean容器，加载并注册Bean
我们继续refresh方法的下一行，obtainFreshBeanFactory
注意，这个方法是全文最重要的部分之一，这里将会初始化BeanFactory、加载Bean、注册Bean等。
当然，这步结束后，Bean并没有完成初始化。这里指的是Bean实例并未在这一步生成。
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//关闭旧的BeanFactory（如果有的话），创建新的BeanFactory，加载Bean定义、注册bean等等
refreshBeanFactory();
//返回刚刚创建的BeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}我们看下，refreshBeanFactory方法，这个方法在ApplicaitonContext的子类AbstractRefreshableApplicaitonContext的120行
protected final void refreshBeanFactory() throws BeansException {
//如果ApplicationContext中已经加载过BeanFactory，则销毁所有的Bean，关闭BeanFactory
//注意，应用中BeanFactory本来就可以是多个的，这里可不是说应用全局是否有BeanFactory，而是当前
//ApplicationContext是否有BeanFactory
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
//初始化一个DefaultListableBeanFactory，一会说为什么用这个
DefaultListableBeanFactory beanFactory = createBeanFactory();
//用于BeanFactory的序列化
beanFactory.setSerializationId(getId());
//下面，两个方法很重要，具体细节后面说，用来设置BeanFactory的两个配置属性：
//是否允许bean覆盖、是否允许循环引用
customizeBeanFactory(beanFactory);
//加载Bean到beanFactory中
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}看到这里，我觉着读者就应该站在高处看ApplicaitonContext了，虽然ApplicaitonContext继承自BeanFactory，但是它不应该被理解为BeanFactory的实现类，而是其内部持有了一个实例化的BeanFactory（DefaultListableBeanFactory）。以后所有的BeanFactory相关的操作其实是委托给这个实例来处理的。
我们再说说为什么选择DefaultListableBeanFactory？前面我们说个有个很重要的接口ConfigurableListableBeanFactory，它实现了BeanFactory下面一层的所有的三个接口，把前面的继承图再拿来看看：
我们可以看到ConfigurableListableBeanFactory只有一个实现类DefaultListableBeanFactory，而且实现类DefaultListableBeanFactory还通过实现右边的AbstractAutowireCapableBeanFactory通吃了右路。所以，最底下这个DefualtListableBeanFactory基本上是最牛的BeanFactory了，这也是为什么这边会使用这个类来实例化的原因。
如果你想在程序运行时动态往Spring IOC容器中注册新的bean，就会使用到这个类。那我们怎么在运行时获得这个实例呢？
之前我们说过applicaitonContext接口能获取到autowireCapableBeanFactory（通过applicaitonContext中最后一个方法），就是最右上角那个，然后它向下转型就能得到DefaultListableFactory了。
再继续往下，我们了解下BeanDefinition。BeanFactory是Bean容器，那么Bean又是什么呢？
这里的BeanDefinition就是我们所说的Spring的Bean，我们自己定义的各个Bean其实会转换成一个个beanDefinition存在于Spring的BeanFactory中。
所以，如果有人问Bean是什么是，要知道bean在代码层面上可以认为是beanDefinition的实例。
beanDefinition中保存了我们的bean信息，比如这个bean指向的是哪个类、是否是单例的、是否懒加载、这个bean依赖了哪些bean等等。
BeanDefinition接口定义
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
//默认只提供singleton和prototype两种
//可能大家还知道requst、session、application、globalSession、websocket这几种
//不过这几种都是基于web的扩展
String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
//跳过
int ROLE_APPLICATION = 0;
int ROLE_SUPPORT = 1;
int ROLE_INFRASTRUCTURE = 2;
//设置父bean，这里涉及到bean继承，不是java继承
//一句话就是：继承父bean的配置信息而已
void setParentName(String parentName);
//获取父bean
String getParentName();
//设置bean的类名称，将来是要通过反射来生成实例的
void setBeanClassName(String beanClassName);
//获取bean的类名称
String getBeanClassName();
//设置bean的范围
void setScope(String scope);
String getScope();
void setLazyInit(boolean lazyInit);
// 设置是否懒加载
boolean isLazyInit();
// 设置bean依赖的所有bean，注意，这里的依赖不是指属性依赖（如：@autowire标记的），
//是depends-on=”“属性设置的值。
void setDependsOn(String... dependsOn);
// 返回该bean的所有依赖
String[] getDependsOn();
// 设置该bena是否可以注入到其他bean中，只对根据类型注入有效
//如果根据名称注入，即使这边设置了false，也是可以的
void setAutowireCandidate(boolean autowireCandidate);
// 该bean是否可以注入到其他bean
boolean isAutowireCandidate();
// 设置主要的。 同一接口的多个实现，如果不指定名字的话，Spring会优先选择设置primary为
//true的bean
void setPrimary(boolean primary);
// 是否是primary
boolean isPrimary();
// 如果该bean采用工厂方法生产，指定工厂名称。
//一句话就是：有些实例不是用反射生成的，而是用工厂模式生成的。
void setFactoryBeanName(String factoryBeanName);
// 获取工厂名称
String getFactoryBeanName();
// 指定工厂类中的 工厂方法名称
void setFactoryMethodName(String factoryMethodName);
// 获取工厂类中的 工厂方法名称
String getFactoryMethodName();
// 构造器参数
ConstructorArgumentValues getConstructorArgumentValues();
// Bean 中的属性值，后面给 bean 注入属性值的时候会说到
MutablePropertyValues getPropertyValues();
// 是否 singleton
boolean isSingleton();
// 是否 prototype
boolean isPrototype();
// 如果这个 Bean 是被设置为 abstract，那么不能实例化，
// 常用于作为 父bean 用于继承，其实也很少用......
boolean isAbstract();
int getRole();
String getDescription();
String getResourceDescription();
BeanDefinition getOriginatingBeanDefinition();
}这个beanDefinition其实已经包含了很多信息了，暂时不清楚所有的方法对应什么东西没关系，下面会详细说下。
有了beanDefinition概念后，我们看下refreshBeanFactory方法中剩余部分：
customizeBeanFactory（beanFactory）； 定做beanFactory
loadBeanDefinitions（beanFactory）；加载bean
耐心点！路还很长。。。。
customizeBeanFactory
customizeBeanFactory比较简单，就是配置是否允许beanDefinition覆盖、是否允许循环引用。
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) { if (this.allowBeanDefinitionOverriding != null) { //是否允许bean定义覆盖 beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding); } if (this.allowCircularReferences != null) { //是否允许bean间的循环依赖 beanFactory.setAllowCircularReferences(this.allowCircularReferences); } }
BeanDefinition的覆盖问题，可能会有开发者碰到过这个坑，就是在配置文件中定义bean时使用了相同的id或name，默认情况下，allowBeanDefinitionOverriding属性为null，如果在同一配置文件中重复了，会抛错，但是如果不是同一配置文件中，会发生覆盖。
循环引用也很好理解：A依赖B，而B依赖A。或A依赖B，B依赖C，而C依赖A。
默认情况下，Spring允许循环依赖，当然如果你在A的构造方法中依赖B，在B的构造方法中依赖A是不行的。
至于这两个属性怎么配置？我在附录中进行了介绍，尤其对于覆盖问题，很多人都希望禁止出现bean覆盖，可是Spring默认是不同文件的时候可以覆盖的。
加载Bean：loadBeanDefinitions
接下来最重要的是loadBeanDefinitions方法了，这个方法将根据配置，加载各个bean，然后放到beanFactory中。
读取配置的操作在XmlBeanDefinitionReader中，其负责加载配置、解析。
代码在AbstractXmlApplicationContext 80行
//我们可以看到，此方法将通过一个xmlBeanDefinitionReader实例来加载各个bean
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
//给这个BeanFactory实例化一个xmlBeanDefinitionReader
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));
//初始化beanDefinitionReader
initBeanDefinitionReader(beanDefinitionReader);
//重点
loadBeanDefinitions(beanDefinitionReader);
}接下来用初始化的reader开始加载xml配置，这块代码可以选择性跳过，不是很重要。
// AbstractXmlApplicationContext.java 120
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
Resource[] configResources = getConfigResources();
if (configResources != null) {
// 往下看
reader.loadBeanDefinitions(configResources);
}
String[] configLocations = getConfigLocations();
if (configLocations != null) {
// 2
reader.loadBeanDefinitions(configLocations);
}
}
// 上面虽然有两个分支，不过第二个分支很快通过解析路径转换为 Resource 以后也会进到这里
@Override
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
Assert.notNull(resources, "Resource array must not be null");
int counter = 0;
// 注意这里是个 for 循环，也就是每个文件是一个 resource
for (Resource resource : resources) {
// 继续往下看
counter += loadBeanDefinitions(resource);
}
// 最后返回 counter，表示总共加载了多少的 BeanDefinition
return counter;
}
// XmlBeanDefinitionReader 303
@Override
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
return loadBeanDefinitions(new EncodedResource(resource));
}
// XmlBeanDefinitionReader 314
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());
}
// 用一个 ThreadLocal 来存放配置文件资源
Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
if (currentResources == null) {
currentResources = new HashSet<EncodedResource>(4);
this.resourcesCurrentlyBeingLoaded.set(currentResources);
}
if (!currentResources.add(encodedResource)) {
throw new BeanDefinitionStoreException(
"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
}
try {
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
// 核心部分是这里，往下面看
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
finally {
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();
}
}
}
// 还在这个文件中，第 388 行
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
try {
// 这里就不看了，将 xml 文件转换为 Document 对象
Document doc = doLoadDocument(inputSource, resource);
// 继续
return registerBeanDefinitions(doc, resource);
}
catch (...
}
// 还在这个文件中，第 505 行
// 返回值：返回从当前配置文件加载了多少数量的 Bean
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
int countBefore = getRegistry().getBeanDefinitionCount();
// 这里
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
return getRegistry().getBeanDefinitionCount() - countBefore;
}
// DefaultBeanDefinitionDocumentReader 90
@Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
logger.debug("Loading bean definitions");
Element root = doc.getDocumentElement();
// 从 xml 根节点开始解析文件
doRegisterBeanDefinitions(root);
} 经过漫长的链路，一个配置文件终于转化为了一颗DOM树了，注意，这里指的是其中一个配置文件，不是所有的，读者可以看到上面有个for循环。下面从根节点开始解析：
doRegisterBeanDefinitions：
//DefaultBeanDefinitionDocument 116行
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)) {
//这块说的是根节点，<beans ... profile="dev">中的profile是否是当前环境需要的
//如果当前环境配置的profile不包含此profile，那就直接return了，不对此<beans/>进行解析
//不熟悉profile为何物，不熟悉怎么配置profile的请看附录
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;
}
}
}
//钩子
preProcessXml(root);
parseBeanDefinitions(root, this.delegate);
//钩子
postProcessXml(root);
this.delegate = parent;
}这里涉及到了profile，不了解的可以参考附录。
接下来，看核心解析方法parseBeanDefinitions：
//default namespace涉及到的就四个标签<import> <alias> <bean> <beans>
//其他的属于custom
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)) {
//解析default namespace 下面的几个元素
parseDefaultElement(ele, delegate);
}
else {
//解析其他namespace元素
delegate.parseCustomElement(ele);
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}从上面的代码，我们可以看到，对于每个配置来说，分别进入到parseDefaultElement和parseCustomElement这两个分支。
parseDefaultElement代表解析的节点是<import/> <alias/> <bean/> <beans/> <definitions/>这几个。
这5个标签之所以是default，是因为他们是处于这个namespace下定义的(即定义在beans标签包含中)：
http://www.springframework.org/schema/beans而对于其他的标签，将进入到parseCustomElement这个分支，如经常使用到的mvc、task、aop等等
这些标签属于扩展，如果需要使用上面这些”非default“标签，那么上面的xml头部的地方也要引入相应的namespace和.xsd文件的路径。
回过神来，看看处理default标签的方法：
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 标签定义
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// 如果碰到的是嵌套的beans标签 需要递归
doRegisterBeanDefinitions(ele);
}
}如果每个标签都说，就要吐血了。我们挑重点<bean>标签来说。
processBeanDefinition解析bean标签
DefaultBeanDefinitionDocumentReader 298行
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//将<bean>节点中的信息提取出来，然后封装到一个beanDefinitionHolder中
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
//下面几行先不要看，跳过
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}继续往下看怎么解析之前，我们先看下<bean/>标签中可以定义哪些属性：
| Property | |
|---|---|
| class | 类的全限定名 |
| name | 可指定 id、name(用逗号、分号、空格分隔) |
| scope | 作用域 |
| constructor arguments | 指定构造参数 |
| properties | 设置属性的值 |
| autowiring mode | no(默认值)、byName、byType、 constructor |
| lazy-initialization mode | 是否懒加载(如果被非懒加载的bean依赖了那么其实也就不能懒加载了) |
| initialization method | bean 属性设置完成后，会调用这个方法 |
| destruction method | bean 销毁后的回调方法 |
简单说就像下面这样子：
<bean id="exampleBean" name="name1, name2, name3" class="com.javadoop.ExampleBean"
scope="singleton" lazy-init="true" init-method="init" destroy-method="cleanup">
<!-- 可以用下面三种形式指定构造参数 -->
<constructor-arg type="int" value="7500000"/>
<constructor-arg name="years" value="7500000"/>
<constructor-arg index="0" value="7500000"/>
<!-- property 的几种情况 -->
<property name="beanOne">
<ref bean="anotherExampleBean"/>
</property>
<property name="beanTwo" ref="yetAnotherBean"/>
<property name="integerProperty" value="1"/>
</bean>我们继续看怎么解析bean元素，是怎么转换到BeanDefinitionHolder的。
BeanDefitionParserDelegate 428行
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
return parseBeanDefinitionElement(ele, null);
}
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
String id = ele.getAttribute(ID_ATTRIBUTE);
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
List<String> aliases = new ArrayList<String>();
// 将 name 属性的定义按照 “逗号、分号、空格” 切分，形成一个 别名列表数组，
// 当然，如果你不定义 name 属性的话，就是空的了
// 我在附录中简单介绍了一下 id 和 name 的配置，大家可以看一眼，有个20秒就可以了
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 (logger.isDebugEnabled()) {
logger.debug("No XML 'id' specified - using '" + beanName +
"' as bean name and " + aliases + " as aliases");
}
}
if (containingBean == null) {
checkNameUniqueness(beanName, aliases, ele);
}
// 根据 <bean ...>...</bean> 中的配置创建 BeanDefinition，然后把配置中的信息都设置到实例中,
// 细节后面细说，先知道下面这行结束后，一个 BeanDefinition 实例就出来了。
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
// 到这里，整个 <bean /> 标签就算解析结束了，一个 BeanDefinition 就形成了。
if (beanDefinition != null) {
// 如果都没有设置 id 和 name，那么此时的 beanName 就会为 null，进入下面这块代码产生
// 如果读者不感兴趣的话，我觉得不需要关心这块代码，对本文源码分析来说，这些东西不重要
if (!StringUtils.hasText(beanName)) {
try {
if (containingBean != null) {// 按照我们的思路，这里 containingBean 是 null 的
beanName = BeanDefinitionReaderUtils.generateBeanName(
beanDefinition, this.readerContext.getRegistry(), true);
}
else {
// 如果我们不定义 id 和 name，那么我们引言里的那个例子：
// 1. beanName 为：com.javadoop.example.MessageServiceImpl#0
// 2. beanClassName 为：com.javadoop.example.MessageServiceImpl
beanName = this.readerContext.generateBeanName(beanDefinition);
String beanClassName = beanDefinition.getBeanClassName();
if (beanClassName != null &&
beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
// 把 beanClassName 设置为 Bean 的别名
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);
// 返回 BeanDefinitionHolder
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}
return null;
}然后，我们再看看怎么根据配置创建beanDefinition实例的：
public AbstractBeanDefinition parseBeanDefinitionElement(
Element ele, String beanName, BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
try {
String parent = null;
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
// 创建 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 (ClassNotFoundException ex) {
error("Bean class [" + className + "] not found", ele, ex);
}
catch (NoClassDefFoundError err) {
error("Class that bean class [" + className + "] depends on not found", ele, err);
}
catch (Throwable ex) {
error("Unexpected failure during bean definition parsing", ele, ex);
}
finally {
this.parseState.pop();
}
return null;
}到这里，我们已经完成了根据<bean/>配置创建了一个BeanDefinitionHolder实例。注意，是一个。
我们回到解析<bean/>的入口方法：
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// 将 <bean /> 节点转换为 BeanDefinitionHolder，就是上面说的一堆
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
// 如果有自定义属性的话，进行相应的解析，先忽略
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// 我们把这步叫做 注册Bean 吧
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// 注册完成后，发送事件，本文不展开说这个
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}仔细看下这块，后面就不说了。这里已经根据一个<bean/>标签产生了一个BeanDefinitionHolder实例了，这个实例里面也就是一个BeanDefinition实例和它的beanName、aliases这三个信息，然后我们准备注册这个BeanDefinition，最后，把这个注册事件发送出去。 加油！冲鸭！
注册Bean
BeanDefinitionReaderUtils 143
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
String beanName = definitionHolder.getBeanName();
// 注册这个 Bean
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// 如果还有别名的话，也要根据别名全部注册一遍，不然根据别名就会找不到 Bean 了
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
// alias -> beanName 保存它们的别名信息，这个很简单，用一个 map 保存一下就可以了，
// 获取的时候，会先将 alias 转换为 beanName，然后再查找
registry.registerAlias(beanName, alias);
}
}
}别名注册放一边，毕竟它很简单，我们看看怎么注册bean
//DefaultListableBeanFactory 793
@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");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(...);
}
}
// old? 还记得 “允许 bean 覆盖” 这个配置吗？allowBeanDefinitionOverriding
BeanDefinition oldBeanDefinition;
// 之后会看到，所有的 Bean 注册后会放入这个 beanDefinitionMap 中
oldBeanDefinition = this.beanDefinitionMap.get(beanName);
// 处理重复名称的 Bean 定义的情况
if (oldBeanDefinition != null) {
if (!isAllowBeanDefinitionOverriding()) {
// 如果不允许覆盖的话，抛异常
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription()...
}
else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
// log...用框架定义的 Bean 覆盖用户自定义的 Bean
}
else if (!beanDefinition.equals(oldBeanDefinition)) {
// log...用新的 Bean 覆盖旧的 Bean
}
else {
// log...用同等的 Bean 覆盖旧的 Bean，这里指的是 equals 方法返回 true 的 Bean
}
// 覆盖
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
// 判断是否已经有其他的 Bean 开始初始化了.
// 注意，"注册Bean" 这个动作结束，Bean 依然还没有初始化，我们后面会有大篇幅说初始化过程，
// 在 Spring 容器启动的最后，会 预初始化 所有的 singleton beans
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<String>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
if (this.manualSingletonNames.contains(beanName)) {
Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
}
else {
// 最正常的应该是进到这个分支。
// 将 BeanDefinition 放到这个 map 中，这个 map 保存了所有的 BeanDefinition
this.beanDefinitionMap.put(beanName, beanDefinition);
// 这是个 ArrayList，所以会按照 bean 配置的顺序保存每一个注册的 Bean 的名字
this.beanDefinitionNames.add(beanName);
// 这是个 LinkedHashSet，代表的是手动注册的 singleton bean，
// 注意这里是 remove 方法，到这里的 Bean 当然不是手动注册的
// 手动指的是通过调用以下方法注册的 bean ：
// registerSingleton(String beanName, Object singletonObject)
// 这不是重点，解释只是为了不让大家疑惑。Spring 会在后面"手动"注册一些 Bean，
// 如 "environment"、"systemProperties" 等 bean，我们自己也可以在运行时注册 Bean 到容器中的
this.manualSingletonNames.remove(beanName);
}
// 这个不重要，在预初始化的时候会用到，不必管它。
this.frozenBeanDefinitionNames = null;
}
if (oldBeanDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}总结下，到这里已经初始化bean容器，<bean/>配置也相应的装换为了一个个BeanDefintion，然后注册了各个BeanDefinition到注册中心，并且发送了注册邮件。
未完待续。。。
第二篇：
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
