SpringIOC容器源码分析（二）启动过程分析——准备工作

参考自：https://javadoop.com/post/spring-ioc

接下来就步入正题，正式进入源码

跟着代码调试走食用效果更佳

第一步，也就是从ClassPathXmlApplicationContext说起：

public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
    private Resource[] configResources;
	
	//调式时我们首先会进入这个构造方法，他会将我们传入的xml classpath根据提供的路径处理成配置文件数组
	//默认设置了refresh调用为true
	//如果已经有 ApplicationContext 并需要配置成父子关系，那么添加相应的参数
	public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
        this(new String[]{configLocation}, true, (ApplicationContext)null);
    }
    
    //也就是上个方法里的配置父子Context
	public ClassPathXmlApplicationContext(ApplicationContext parent) {
		//若追本朔源会发现，该super的底层就是AbstractApplicationContext的构造方法
		//它会根据传入的ApplicationContext调用this.setParent方法
        //但这里不是重点 过
        super(parent);
    }
	
    public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException {
        super(parent);
        // 根据提供的路径，处理成配置文件数组
        this.setConfigLocations(configLocations);
        if (refresh) {
        	//重点重点重点！！！
        	//核心方法 继承自AbstractApplicationContext
            this.refresh();
        }
    }
}

接下来我们进入refresh()方法，这个方法之所以叫refresh，是因为ApplicationContext建立以后，我们是可以通过调用refresh()方法进行重建的，refresh()会将原来的ApplicationContext销毁，然后重新执行一次初始化操作。

Refresh方法

从该方法调用了许多方法就看的出来，这个refresh方法肯定不简单了。

public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        //这里需要加锁的原因是，如果refresh()还没执行结束，又来个启动或销毁的操作，那就乱套了
        synchronized(this.startupShutdownMonitor) {
        
        	//准备工作 记录容器的启动时间，设置flag，处理配置文件占位符
            this.prepareRefresh();

			//重点重点重点！！！
			//这个步骤执行完成后，配置文件会解析成一个个bean定义，注册到BeanFactory中
			//当然这里的Bean还没有初始化，只是将配置信息提取出来了
			//注册也只是将这些信息保存到了注册中心
			//说到底核心是一个key=beanName value=beanDefinition的map容器
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            
			//设置BeanFactory的类加载器，添加几个BeanPostProcessor，手动注册几个特殊的bean
			//待会儿会展开说
            this.prepareBeanFactory(beanFactory);

            try {
            	//【这里需要知道 BeanFactoryPostProcessor 这个知识点，Bean 如果实现了此接口，
         		// 那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。】	
         		//这个方法是提供给子类的扩展点，进行到这一步所有的bean都加载，注册完成了（配置文件中的bean和特殊bean），但是还没有被初始化
         		// 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
                this.postProcessBeanFactory(beanFactory);

				//调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法
                this.invokeBeanFactoryPostProcessors(beanFactory);

				// 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
         		// 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
         		// 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化
                this.registerBeanPostProcessors(beanFactory);
                
				//初始化当前 ApplicationContext 的 MessageSource
				this.initMessageSource();
				
				//初始化当前ApplicationContext的事件广播器
                this.initApplicationEventMulticaster();
                
                // 从方法名就可以知道，典型的模板方法(钩子方法)，
         		// 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
                this.onRefresh();
				
				// 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点
                this.registerListeners();
      			
      			// 重点，重点，重点！！！
         		// 初始化所有的 singleton beans
         		//（lazy-init 的除外）
                this.finishBeanFactoryInitialization(beanFactory);

				// 终于到最后，广播事件，ApplicationContext 初始化完成
                this.finishRefresh();
            } catch (BeansException var9) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }
				//销毁已经初始化的singleton beans 以免有些bean会一直占用资源
                this.destroyBeans();
                
                //重置“active”flag
                this.cancelRefresh(var9);
                throw var9;
            } finally {
            	// Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                this.resetCommonCaches();
            }
        }
    }

接下来我们一步一步地对refresh方法进行肢解：

1. 创建Bean容器的准备工作：prepareRefresh方法

protected void prepareRefresh() {
		//记录启动时间
        this.startupDate = System.currentTimeMillis();
        //设置flag
        this.closed.set(false);
        this.active.set(true);
        if (this.logger.isInfoEnabled()) {
            this.logger.info("Refreshing " + this);
        }
        this.initPropertySources();
        //校验xml配置文件
        this.getEnvironment().validateRequiredProperties();
        this.earlyApplicationEvents = new LinkedHashSet();
    }

2. 创建Bean容器，加载并注册Bean ：obtainFreshBeanFactory方法

这个方法是全文最重要的部分之一，这里将会初始化 BeanFactory，加载、注册 Bean到BeanFactory等等。
当然，这步结束后，Bean 并没有完成初始化，仅仅只是提取了配置信息并将这些信息保存到了注册中心。

// AbstractApplicationContext.java

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		//关闭旧的BeanFactory（如果有的话），创建新的BeanFactory，加载bean定义，注册bean等
        this.refreshBeanFactory();
        
        //反回刚创建的BeanFactory
        ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
        
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Bean factory for " + this.getDisplayName() + ": " + beanFactory);
        }
        return beanFactory;
    }

再深入查看refreshBeanFactory()方法：
// AbstractRefreshableApplicationContext.java

protected final void refreshBeanFactory() throws BeansException {
		//如果ApplicationContext中已经加载了BeanFactory
		//注意，应用中 BeanFactory 本来就是可以多个的，这里可不是说应用全局是否有 BeanFactory，而是当前的ApplicationContext 是否有 BeanFactory
        if (this.hasBeanFactory()) {
        	//则销毁所有Bean
            this.destroyBeans();
            //并关闭BeanFactory
            this.closeBeanFactory();
        }

        try {
        	//初始化一个DefaultListableBeanFactory
            //为什么用这个一会儿展开说
            DefaultListableBeanFactory beanFactory = this.createBeanFactory();
            
            //用于BeanFactory的序列化，非重点，过
            beanFactory.setSerializationId(this.getId());
            
            //以下这两个方法非常重要，具体细节一会儿进行展开
            //重点！设置BeanFactory的两个配置属性：是否允许Bean覆盖，是否允许循环引用
			this.customizeBeanFactory(beanFactory);
			//重点！加载Bean到BeanFactory中
            this.loadBeanDefinitions(beanFactory);

            Object var2 = this.beanFactoryMonitor;
            synchronized(this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        } catch (IOException var5) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var5);
        }
    }

看到这里的时候，我们应该有个深刻的认识，ApplicationContext 继承自 BeanFactory，但是它不应该被理解为 BeanFactory 的实现类，而是说其内部持有一个实例化的 BeanFactory（DefaultListableBeanFactory），至于为什么请参考refreshBeanFactory()方法。以后所有的 BeanFactory 相关的操作其实是委托给这个实例来处理的。

但是为什么要选择实例化 DefaultListableBeanFactory来处理BeanFactory的相关操作呢 ？

在我的SpringIOC容器源码分析（一）
中，BeanFactory继承结构图中提到了很重要的接口 ConfigurableListableBeanFactory，它实现了 BeanFactory 下面一层的所有三个接口，我把之前的继承图再拿过来大家再仔细看一下：

我们可以看到 ConfigurableListableBeanFactory 只有一个实现类 DefaultListableBeanFactory，而且实现类 DefaultListableBeanFactory 还通过实现右边的 AbstractAutowireCapableBeanFactory 通吃了右路。所以结论就是，最底下这个家伙 DefaultListableBeanFactory 基本上是最牛的 BeanFactory 了，这也是为什么这边会使用这个类来实例化的原因。

java如果你想要在程序运行的时候动态往 Spring IOC 容器注册新的 bean，就会使用到这个类。那我们怎么在运行时获得这个实例呢？之前我们说过 ApplicationContext 接口能获取到 AutowireCapableBeanFactory，就是最右上角那个，然后它向下转型就能得到 DefaultListableBeanFactory 了。

在继续往下之前，我们需要先了解 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 {
	//可以看到默认只提供单例和多例两种
	//request, session, globalSession, application, websocket 这几种，它们属于基于 web 的扩展
    String SCOPE_SINGLETON = "singleton";
    String SCOPE_PROTOTYPE = "prototype";
    int ROLE_APPLICATION = 0;
    int ROLE_SUPPORT = 1;
    int ROLE_INFRASTRUCTURE = 2;

	//继承父Bean的配置信息
    void setParentName(String var1);
	//获取父Bean的Name
    String getParentName();
	//设置Bean类的Name
    void setBeanClassName(String var1);
	//获取Bean类的Name
    String getBeanClassName();
	//设置Bean的scope
    void setScope(String var1);
	//获取Bean的scope
    String getScope();
	//设置是否懒加载
    void setLazyInit(boolean var1);
	
    boolean isLazyInit();

	//设置该Bean依赖的所有Bean
	//注意，这里的依赖不是指属性依赖(如 @Autowire 标记的)，而是 depends-on="" 属性设置的值。
    void setDependsOn(String... var1);
	//返回Bean的所有依赖
    String[] getDependsOn();
    
	//设置Bean是否可以注入到其他Bean中，只对根据类型注入有效，如果根据名称注入，即便这边设置了false，也是可以的
    void setAutowireCandidate(boolean var1);
    boolean isAutowireCandidate();
    
	//设置primary，同一接口多个实现，如果不指定名字，spring优先选择primary为true的bean
    void setPrimary(boolean var1);
    boolean isPrimary();

	//如果该Bean采用工厂方法生成，指定工厂名称。（有些实例不是用反射生成的，而是用工厂模式生成的）
    void setFactoryBeanName(String var1);
    String getFactoryBeanName();
	
	//指定工厂类中的工厂方法的名称
    void setFactoryMethodName(String var1);
    String getFactoryMethodName();

	//构造器参数
    ConstructorArgumentValues getConstructorArgumentValues();
    
	//Bean中的属性值，之后给bean注入属性时会提到 
    MutablePropertyValues getPropertyValues();

    boolean isSingleton();

    boolean isPrototype();

	//如果这个Bean被设置为abstract，那么不能对其实例化
	//当为true时，常用于作为父bean被继承，很少被使用
    boolean isAbstract();

    int getRole();

    String getDescription();

    String getResourceDescription();

    BeanDefinition getOriginatingBeanDefinition();
}

这里接口虽然那么多，但是没有类似 getInstance() 这种方法来获取我们定义的类的实例，真正的我们定义的类生成的实例到哪里去了呢？别着急，这个要很后面才能讲到。

有了 BeanDefinition 的概念以后，我们再回到 refreshBeanFactory() 方法中的剩余部分：

	customizeBeanFactory(beanFactory);
	loadBeanDefinitions(beanFactory);

CustomizeBeanFactory

之前说了该方法就是配置是否允许BeanDefinition 覆盖、是否允许循环引用。

但这个BeanDefinition覆盖是什么呢？
很简单，就我们平时在配置文件中定义的相同的id或name的bean，而allowBeanDefinitionOverriding这个参数默认是为空的。
也就是：如果我们在同一个配置文件中声明相同的id或name的bean会抛错；如果不在同一个配置文件中声明相同的id或name的bean则会覆盖

再说以下循环引用的概念
说白了也就是类A依赖类B，类B依赖了类C，类C又依赖了类A。
默认情况下Spring是允许循环引用的，当然构造方法除外。

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

loadBeanDefinitions：加载bean到beanFactory

接下来是最重要的 loadBeanDefinitions(beanFactory) 方法了，这个方法将根据配置，加载各个 Bean，然后放到 BeanFactory 中。

读取配置的操作在 XmlBeanDefinitionReader 中，其负责加载配置、解析。

//此方法将通过一个XmlBeanDefinitionReader实例来加载各个bean
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		
		//实例化一个XmlBeanDefinitionReader
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
        //配置这个beanDefinitionReader...过
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

		//初始化BeanDefinitionReader，用于提供给子类override，非重点，过
        this.initBeanDefinitionReader(beanDefinitionReader);
        //对该方法进行深入
        this.loadBeanDefinitions(beanDefinitionReader);
}

//AbstractXmlApplicationContext.java 120

//首先会先进入这个方法，也就是重复之前配置这个beanDefinitionReader的过程
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
        this.initBeanDefinitionReader(beanDefinitionReader);
        //直接到这里 再step into
        this.loadBeanDefinitions(beanDefinitionReader);
}

//继续往下看
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
   Resource[] configResources = getConfigResources();
   if (configResources != null) {
      // 过
      reader.loadBeanDefinitions(configResources);
   }
   String[] configLocations = getConfigLocations();
   if (configLocations != null) {
      // step into
      reader.loadBeanDefinitions(configLocations);
   }
}

public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
        Assert.notNull(locations, "Location array must not be null");
        int counter = 0;
        String[] var3 = locations;
        int var4 = locations.length;
		//注意这里是个for循环，也就是每个文件是一个resources
        for (Resource resource : resources) {
      	// 这里继续step into
      	counter += loadBeanDefinitions(resource);
   }
		//返回总共加载了BeanDefinition的数量
        return counter;
}

// XmlBeanDefinitionReader

@Override
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
   return loadBeanDefinitions(new EncodedResource(resource));
}

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());
         }
         // 核心部分是这里 继续step into
         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();
      }
   }
}

//一直step到这里
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
      throws BeanDefinitionStoreException {
   try {
      // 这里就不看了，将 xml 文件转换为 Document 对象
      Document doc = doLoadDocument(inputSource, resource);
      // 继续step into...
      return registerBeanDefinitions(doc, resource);
   }
   catch (...
}


// 还在这个文件中，第 246 行（不同版本不一样）
// 返回值：返回从当前配置文件加载了多少数量的 Bean
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
   BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
   int countBefore = getRegistry().getBeanDefinitionCount();
   // 这里step into
   documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
   return getRegistry().getBeanDefinitionCount() - countBefore;
}

// DefaultBeanDefinitionDocumentReader 43

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
        this.readerContext = readerContext;
        this.logger.debug("Loading bean definitions");
        Element root = doc.getDocumentElement();
        //从xml根节点解析文件 step into
        this.doRegisterBeanDefinitions(root);
    }

经过漫长的链路，一个配置文件终于转换为一颗DOM树了，需要注意的是，从刚才循环到这里的所有过程只是一个配置文件的。下面从根节点开始解析文件。

继续深入doRegisterBeanDefinitions

protected void doRegisterBeanDefinitions(Element root) {

		//BeanDefinitionParserDelegate非常重要，它负责解析Bean定义
		//至于这里为什么要定义一个parent，是一个递归问题
		//因为<Bean/>内部还是可以定义<Bean/>的，所以这个方法的root不一定就是xml的根节点
		//也可能是嵌套在里面的<Bean/>结点，但从源码分析的角度，就把它当作根节点就好
        BeanDefinitionParserDelegate parent = this.delegate;
        this.delegate = this.createDelegate(this.getReaderContext(), root, parent);
        if (this.delegate.isDefaultNamespace(root)) {

			//这里说的是根节点<beans .. profile="dev"/>中的profile是否当前环境需要
			//如果当前环境配置的profile不包含此profile，则直接return，不对此beans标签作解析
            String profileSpec = root.getAttribute("profile");
            if (StringUtils.hasText(profileSpec)) {
                String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec, ",; ");
                if (!this.getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                    if (this.logger.isInfoEnabled()) {
                        this.logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec + "] not matching: " + this.getReaderContext().getResource());
                    }

                    return;
                }
            }
        }

        this.preProcessXml(root);
        //step into
        this.parseBeanDefinitions(root, this.delegate);
        this.postProcessXml(root);
        this.delegate = parent;
}

接下来是核心方法parseBeanDefinitions

//默认命名空间只涉及4个标签<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下的几个元素
                    	//step into
                        this.parseDefaultElement(ele, delegate);
                    } else {
                    	//解析custom下namespace的元素
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        } else {
            delegate.parseCustomElement(root);
        }

}

我们只针对分析默认的标签，进入parseDefaultElement

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		//这些都可以见名知义就不再注释
        if (delegate.nodeNameEquals(ele, "import")) {
            this.importBeanDefinitionResource(ele);
        } else if (delegate.nodeNameEquals(ele, "alias")) {
            this.processAliasRegistration(ele);
        } else if (delegate.nodeNameEquals(ele, "bean")) {
            this.processBeanDefinition(ele, delegate);
        } else if (delegate.nodeNameEquals(ele, "beans")) {
        	//如果是beans标签则递归回到之前的doRegisterBeanDefinitions
            this.doRegisterBeanDefinitions(ele);
        }
}

再进入当ele equals bean时的processBeanDefinition

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		//将非<bean/>结点的信息提取，封装到BeanDefinitionHolder
		//step into
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
       
        if (bdHolder != null) {
       		//如果有自定义属性，则对其进行相应解析
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

            try {
            	//注册Bean
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.getReaderContext().getRegistry());
            } catch (BeanDefinitionStoreException var5) {
                this.getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, var5);
            }
			//注册完成后，发送事件
            this.getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }

}

继续往下看怎么解析之前，我们先回顾下bean标签中可以定义哪些属性：

回过头来继续查看如何解析bean元素并转换到BeanDefinitionHolder中的

//BeanDefinitionParserDelegate

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
        return this.parseBeanDefinitionElement(ele, (BeanDefinition)null);
    }

    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
        String id = ele.getAttribute("id");
        String nameAttr = ele.getAttribute("name");
        List<String> aliases = new ArrayList();
		
		//将name属性的定义按照“逗号、分号、空格” 切分，形成一个别名列表数组
		//当然如果不定义name则为空
        if (StringUtils.hasLength(nameAttr)) {
            String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, ",; ");
            aliases.addAll(Arrays.asList(nameArr));
        }

        String beanName = id;
        //如果没有指定id 那么用别名列表的第一个名字为beanName
        if (!StringUtils.hasText(id) && !aliases.isEmpty()) {
            beanName = (String)aliases.remove(0);
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("No XML 'id' specified - using '" + beanName + "' as bean name and " + aliases + " as aliases");
            }
        }

        if (containingBean == null) {
            this.checkNameUniqueness(beanName, aliases, ele);
        }
		// 根据 <bean ...>...</bean> 中的配置创建 BeanDefinition，然后把配置中的信息都设置到实例中,
   		// 细节后面细说，先知道下面这行结束后，一个 BeanDefinition 实例就出来了。
        AbstractBeanDefinition beanDefinition = this.parseBeanDefinitionElement(ele, beanName, containingBean);

		// 到这里，整个 <bean /> 标签就算解析结束了，一个 BeanDefinition 就形成了。
        if (beanDefinition != null) {
            if (!StringUtils.hasText(beanName)) {
                try {
                    if (containingBean != null) {
                        beanName = BeanDefinitionReaderUtils.generateBeanName(beanDefinition, this.readerContext.getRegistry(), true);
                    } else {
                    	// 如果我们不定义 id 和 name，那么就根据一开始创建的例子：
               			//   1. beanName 为com.xxx.MessageServiceImpl#0
               			//   2. beanClassName 为com.xxx.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 (this.logger.isDebugEnabled()) {
                        this.logger.debug("Neither XML 'id' nor 'name' specified - using generated bean name [" + beanName + "]");
                    }
                } catch (Exception var9) {
                    this.error(var9.getMessage(), ele);
                    return null;
                }
            }

            String[] aliasesArray = StringUtils.toStringArray(aliases);
            //返回BeanDefinitionHolder
            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
        } else {
            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标签配置创建了一个BeanDefinitionHolde实例了，注意，只是一个。

这个实例也就是一个BeanDefinition的实例和beanName aliases这三个信息，我们的关注点需要始终在BeanDefinition上

public class BeanDefinitionHolder implements BeanMetadataElement {

  private final BeanDefinition beanDefinition;

  private final String beanName;

  private final String[] aliases;

然后我们准备注册这个BeanDefinition，最后将其发送。

回到之前解析bean标签的入口方法processBeanDefinition，再深入registerBeanDefinition注册bean

别名注册不是重点

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的

@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标签也相应地转换成为了一个个的BeanDefinition，然后注册了各个BeanDefinition到注册中心，并且发送了注册事件。

到此为止，准备工作就已经做完了。
也就是刚执行完refresh的 obtainFreshBeanFactory() 方法，此时我已经麻了。

内容补充：

profile

我们可以把不同环境的配置分别配置到单独的文件中，例如：

<beans profile="development"
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xsi:schemaLocation="...">

    <jdbc:embedded-database id="dataSource">
        <jdbc:script location="classpath:com/bank/config/sql/schema.sql"/>
        <jdbc:script location="classpath:com/bank/config/sql/test-data.sql"/>
    </jdbc:embedded-database>
</beans>

<beans profile="production"
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xsi:schemaLocation="...">

    <jee:jndi-lookup id="dataSource" jndi-name="java:comp/env/jdbc/datasource"/>
</beans>

应该不必做过多解释了吧，看每个文件第一行的 profile=""。

当然，我们也可以在一个配置文件中使用：

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xsi:schemaLocation="...">

    <beans profile="development">
        <jdbc:embedded-database id="dataSource">
            <jdbc:script location="classpath:com/bank/config/sql/schema.sql"/>
            <jdbc:script location="classpath:com/bank/config/sql/test-data.sql"/>
        </jdbc:embedded-database>
    </beans>

    <beans profile="production">
        <jee:jndi-lookup id="dataSource" jndi-name="java:comp/env/jdbc/datasource"/>
    </beans>
</beans>

理解起来也很简单吧。

接下来的问题是，怎么使用特定的 profile 呢？Spring 在启动的过程中，会去寻找 “spring.profiles.active” 的属性值，根据这个属性值来的。那怎么配置这个值呢？

Spring 会在这几个地方寻找 spring.profiles.active 的属性值：操作系统环境变量、JVM 系统变量、web.xml 中定义的参数、JNDI。

最简单的方式莫过于在程序启动的时候指定：
-Dspring.profiles.active="profile1,profile2"

profile 可以激活多个

当然，我们也可以通过代码的形式从 Environment 中设置 profile：

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.getEnvironment().setActiveProfiles("development");
ctx.register(SomeConfig.class, StandaloneDataConfig.class, JndiDataConfig.class);
ctx.refresh(); // 重启

如果是 Spring Boot 的话更简单，我们一般会创建 application.properties、application-dev.properties、application-prod.properties 等文件，其中 application.properties 配置各个环境通用的配置，application-{profile}.properties 中配置特定环境的配置，然后在启动的时候指定 profile：

java -Dspring.profiles.active=prod -jar JavaDoop.jar

如果是单元测试中使用的话，在测试类中使用 @ActiveProfiles 指定，这里就不展开了。