【Spring源码开整】04. Spring BeanDefinition加载

Spring BeanDefinition加载

1. 目标

​ 经过两轮简单的手撕代码，最为核心几个类的作用已经基本解释清楚了。之前一直强调写代码是为了帮助理解，这里我们来看看spring BeanDefinition的加载流程。Bean的加载安排在下一篇。

​ 源码的阅读，老实是去理解设计者的思维。老实说不会是很简单有趣的事情，当时会有收获。spring的源码体现着优秀的设计原则与设计模式。

2. 准备与入口

​ 读源码最好是本地把源码跑起来，网上已经有很多基于各种IDE+gradle把源码跑起来的博客，这里我就不重复来介绍了。下面用ClassPathXmlApplicationContext作为起点来读读Spring源码的bean加载流程。

ClassPathXmlApplicationContext context = 
    new ClassPathXmlApplicationContext("beans.xml");
Object alice = context.getBean("alice");

ps：beans.xml和对应bean准备个能跑就行。对于AnnotationConfigApplicationContext作为入口的看官可以看完后自己阅读。

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

    super(parent);
    setConfigLocations(configLocations);
    if (refresh) {
        //高级容器的入口
        refresh();
    }
}

接着跳到AbstractRefreshableApplicationContext#refreshBeanFactory()，为了focse核心代码，把一些异常处理去掉了没有摘录，可以打开自行阅读。

protected final void refreshBeanFactory() throws BeansException {
    //这里创建的BeanFactory熟不熟悉，干什么用的还记得吗？可以看看上一篇
    DefaultListableBeanFactory beanFactory = createBeanFactory();
    beanFactory.setSerializationId(getId());
    customizeBeanFactory(beanFactory);
    //看名字就知道是我们要找的入口了
    loadBeanDefinitions(beanFactory);
    synchronized (this.beanFactoryMonitor) {
        this.beanFactory = beanFactory;
    }
}

//很遗憾，这类并没有实现这个方法，熟悉的模板方法
protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)throws BeansException, IOException;

上面方法的实现在AbstractXmlApplicationContext ,它继承了上面的AbstractRefreshableApplicationContext，spring原本的注释已经写的非常清晰了(请大家一定要读一下原滋原味的注释，英文阅读能力对读一手资料真真很重要)

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    // Create a new XmlBeanDefinitionReader for the given BeanFactory.
    // 通过前面创建的DefaultListableBeanFactory来创建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));

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

// 看着有两个分支，实际上下面的String[] configLocations会被封装为Resource[] configResources调用重载的方法
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
    Resource[] configResources = getConfigResources();
    if (configResources != null) {
        reader.loadBeanDefinitions(configResources);
    }
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        reader.loadBeanDefinitions(configLocations);
    }
}

问题：创建XmlBeanDefinitionReader为什么要把DefaultListableBeanFactory传进去？

大家可以看下这个构造方法入参是BeanDefinitionRegistry,记得上一篇我们给出的BeanFactory的继承体系吗？DefaultListableBeanFactory实现了BeanDefinitionRegistry接口用来注册

最后它们都走到了XmlBeanDefinitionReader#loadBeanDefinitions，又移除了一部分异常处理资源释放的逻辑

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
    //添加EncodedResource
    Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
    if (currentResources == null) {
        currentResources = new HashSet<EncodedResource>(4);
        this.resourcesCurrentlyBeingLoaded.set(currentResources);
    }
	//因为配置文件是又不同编码的，这里有封装，通过不同编码来获取输入流
    InputStream inputStream = encodedResource.getResource().getInputStream();
    try {
        InputSource inputSource = new InputSource(inputStream);
        if (encodedResource.getEncoding() != null) {
            inputSource.setEncoding(encodedResource.getEncoding());
        }
        //有了do终于开始做了
        return doLoadBeanDefinitions(inputSource, 
                                     encodedResource.getResource());
    }
}

到了这里算是真正找到了入口，接下来看看到底怎么解析的吧

3. BeanDefinition封装与注册

接着上面的来还是XmlBeanDefinitionReader，去掉异常处理就者两行，一个生成Document对象，一个解析Document封装BeanDefinition并注册，和上一篇写的是不是有那么一点像呢

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
    //生成Document对象
    Document doc = doLoadDocument(inputSource, resource);
    //解析`Document`封装`BeanDefinition`并注册
    return registerBeanDefinitions(doc, resource);
}

第一部分套路差不多DocumentBuilderFactory–>DocumentBuilder–>builder.parse(inputSource);得到我们要的Document对象，这个逻辑是不是在MyBatis看到过，是什么设计模式出于什么考虑有什么好处，看官思考下。

接下来就是解析注册的流程了

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    
    BeanDefinitionDocumentReader documentReader = 
        createBeanDefinitionDocumentReader();
    //标记之前加载BeanDefinition数量
    int countBefore = getRegistry().getBeanDefinitionCount();
    //****准备了这么，真的准备开始解析注册，ps：还没看到do
    documentReader.registerBeanDefinitions(doc, 
                                           createReaderContext(resource));
    //返回本次加载的BeanDefinition数量
    return getRegistry().getBeanDefinitionCount() - countBefore;
}

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
    this.readerContext = readerContext;
    logger.debug("Loading bean definitions");
    //提前root
    Element root = doc.getDocumentElement();
    //从root开始解析注册BeanDefiniton，ps：终于看到do了
    doRegisterBeanDefinitions(root);
}

上面还是拆分了几个函数来处理不同的逻辑，下面终于真正开始了。

下面的profile属性的处理被移除掉了，看官可以自行看看源码

protected void doRegisterBeanDefinitions(Element root) {
    //解析处理的类，应为不同的命名空间要不同的NamespaceHandler处理
    BeanDefinitionParserDelegate parent = this.delegate;
    this.delegate = createDelegate(getReaderContext(), root, parent);
	
    //模板方法
    preProcessXml(root);
    //解析
    parseBeanDefinitions(root, this.delegate);
    //模板方法
    postProcessXml(root);

    this.delegate = parent;
}

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    //判定是不是bean命名空间，如果是就用默认处理
    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;
                //判定是不是bean命名空间，是就用默认处理
                if (delegate.isDefaultNamespace(ele)) {
                    parseDefaultElement(ele, delegate);
                }
                //不是就用custom的NamespaceHandler处理
                else {
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }
    else {//不是就用custom的NamespaceHandler处理
        delegate.parseCustomElement(root);
    }
}

下面我们只关注下默认的命名空间bean，下面的这些标签相信大家都相当熟悉了。这里不准备一个个的去看了，我们只关状一个最重要的BEAN_ELEMENT

public static final String BEAN_ELEMENT = 
    BeanDefinitionParserDelegate.BEAN_ELEMENT;
public static final String NESTED_BEANS_ELEMENT = "beans";
public static final String ALIAS_ELEMENT = "alias";
public static final String NAME_ATTRIBUTE = "name";
public static final String ALIAS_ATTRIBUTE = "alias";
public static final String IMPORT_ELEMENT = "import";

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
        importBeanDefinitionResource(ele);
    }
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
        processAliasRegistration(ele);
    }
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
        processBeanDefinition(ele, delegate);
    }
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
        // recurse
        // 递归调用
        doRegisterBeanDefinitions(ele);
    }
}

protected void processBeanDefinition(Element ele, 
                                     BeanDefinitionParserDelegate delegate) {
    //解析出一个BeanDefinitionHolder
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        
        // 注册
        BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
       
        // Send registration event.
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

为什么是BeanDefinitionHolder不是BeanDefinition呢？

因为它还封装了name，id，alias属性

装饰是为什么？

因为默认标签的子节点还有可能有custom element

好了最后关注的两个方法parseBeanDefinitionElement和registerBeanDefinition

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
    //提取id和name
    String id = ele.getAttribute(ID_ATTRIBUTE);
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

    List<String> aliases = new ArrayList<String>();
    if (StringUtils.hasLength(nameAttr)) {
        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
        aliases.addAll(Arrays.asList(nameArr));
    }

    String beanName = id;
    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);
    }
	//解析封装其他属性为BeanDefinition
    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    if (beanDefinition != null) {
        //如果没有指定beanName根据默认规则生成
        if (!StringUtils.hasText(beanName)) {
            if (containingBean != null) {
                beanName = BeanDefinitionReaderUtils.generateBeanName(
                    beanDefinition, this.readerContext.getRegistry(), true);
            }
            else {
                beanName = 
                    this.readerContext.generateBeanName(beanDefinition);
                String beanClassName = beanDefinition.getBeanClassName();
                if (beanClassName != null &&
                    beanName.startsWith(beanClassName) && 
                    beanName.length() > beanClassName.length() &&
           	!this.readerContext.getRegistry().isBeanNameInUse(beanClassName{
                    aliases.add(beanClassName);
                }
            }
        }
        //处理别名
        String[] aliasesArray = StringUtils.toStringArray(aliases);
        //将beanDefinition，beanName和别名封装为BeanDefinitionHolder返回
        return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
    }

    return null;
}
                    
public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean) {
    this.parseState.push(new BeanEntry(beanName));

    String className = null;
     //解析parent属性
    if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
        className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    }

    String parent = null;
    //解析parent属性
    if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
        parent = ele.getAttribute(PARENT_ATTRIBUTE);
    }
    //创建beanDefinition封装接下来的属性
    AbstractBeanDefinition bd = createBeanDefinition(className, parent);
	//默认属性解析
    parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
    bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
	//解析元数据
    parseMetaElements(ele, bd);
    //解析lookup-method
    parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
    //解析replaced-method
    parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
	//解析构造参数
    parseConstructorArgElements(ele, bd);
    //解析property子元素
    parsePropertyElements(ele, bd);
    //解析qualifier子元素
    parseQualifierElements(ele, bd);

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

    return bd;
}

各种属性的解析就是通过xxx.getAttribute(),这里不再深入到每个解析方法了。

最后看看注册

public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)throws BeanDefinitionStoreException {
    // Register bean definition under primary name.
	// 用大名注册bean definition
    String beanName = definitionHolder.getBeanName();
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

    // Register aliases for bean name, if any.
    // 注册别名
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        for (String alias : aliases) {
            registry.registerAlias(beanName, alias);
        }
    }
}

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException {
    if (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_INFRASTRUCTURE
            if (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 {//没有注册过，直接加入beanDefinitionMap
        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 {
            // Still in startup registration phase
            this.beanDefinitionMap.put(beanName, beanDefinition);
            this.beanDefinitionNames.add(beanName);
            this.manualSingletonNames.remove(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }
	//重置所有beanName对应的缓存
    if (oldBeanDefinition != null || containsSingleton(beanName)) {
        resetBeanDefinition(beanName);
    }
}