主要是了解和学习spring解析xml文件的过程。

demo

本文使用一个小的demo来介绍spring的操作过程

public class Bootstrap {
    public static void main(String[] args){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("context.xml");
        Student student = (Student)applicationContext.getBean("student");
        System.out.println(student.toString());
    }
}

public class Student {

    private String name;
    private int age;

    @Value("${name}")
    private String className;

    public void init(){
        this.name = "heheh";
        this.age = 18;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", className='" + className + '\'' +
                '}';
    }
}

<bean id="student" class="Student" init-method="init" />
<context:annotation-config />
<context:property-placeholder location="pro.properties" />

代码结构

image.png

xml 读取

spring开始的入口就是Bootstrap.class实例化ClassPathXmlApplicationContext开始

ClassPathXmlApplicationContext 文件

public ClassPathXmlApplicationContext(String[] configLocations, 
        boolean refresh,    ApplicationContext parent)  throws BeansException {
    super(parent);
    setConfigLocations(configLocations);   // 根据当前环境修改配置文件
    if (refresh) {
        refresh();    // 刷新操作，也就是开始读取配置文件操作了
    }
}

AbstractApplicationContext 文件
先不看代码，通过这个文件名称就可以大致猜出来是各个具体的ApplicationContext的抽象类，提供了一些公共的公共。

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        prepareRefresh();  // 刷新前的准备工作，设置激活开始
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // 得到刷新的bean工厂，很重要！！！
        ....
    }
}

通知子类，刷新bean工厂,那么就存在了如果已经有了bean工厂，则清除掉，重新创建

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    refreshBeanFactory();  // 刷新获取bean工厂，很重要
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    return beanFactory;
}

AbstractRefreshableApplicationContext 文件继承自AbstractApplicationContext，主要是提供刷新的功能（也就是重置和填入数据的操作），也就意味着其实这里是读取xml数据的入口

// 刷新bean工厂
protected final void refreshBeanFactory() throws BeansException {
    if (hasBeanFactory()) { // 已经存在了ben工厂，清除掉，重新操作
        destroyBeans();
        closeBeanFactory();
    }
    try {
        DefaultListableBeanFactory beanFactory = createBeanFactory(); 
        // 生成一个默认的bean工厂DefaultListableBeanFactory 实例，接下来肯定是往里面塞数据了
        beanFactory.setSerializationId(getId());
        customizeBeanFactory(beanFactory);  // 自定义bean工厂参数，可以重载
        loadBeanDefinitions(beanFactory);  // 读取xml数据 
        synchronized (this.beanFactoryMonitor) {
            this.beanFactory = beanFactory;
        }
    }
    ...
    
    // 必须由子类实现，具体的读取xml加载方案
    protected abstract void loadBeanDefinitions(
                   DefaultListableBeanFactory beanFactory)
            throws BeansException, IOException;
}

AbstractXmlApplicationContext文件 继承自AbstractRefreshableApplicationContext

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);  // 创建一个读取对象

    beanDefinitionReader.setEnvironment(this.getEnvironment());
    beanDefinitionReader.setResourceLoader(this);  // 需要处理的对象塞入reader中
    beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
   
    initBeanDefinitionReader(beanDefinitionReader);  // 对reader初始化操作
    loadBeanDefinitions(beanDefinitionReader);  // 很重要的函数，装载数据
}

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
   // 多种方式存储的配置文件的路径
    Resource[] configResources = getConfigResources();
    if (configResources != null) {
        reader.loadBeanDefinitions(configResources);
    }
    String[] configLocations = getConfigLocations();
    // 这个路径是由AbstractRefreshableConfigApplicationContext提供的，为刷新beanfactory提供配置
    if (configLocations != null) {
        reader.loadBeanDefinitions(configLocations);
        // configLocations是传入的文件路径地址，如上所述的context.xml
        // 现在处理对象转到了XmlBeanDefinitionReader对象的装载xml文件
    }
}

xml 解析

XmlBeanDefinitionReader 文件， 中间经过了AbstractBeanDefinitionReader类的处理，会把具体的字符串路径转换为Resource,Resource由具体的Reader读取操作

public int loadBeanDefinitions(EncodedResource encodedResource) 
    throws BeanDefinitionStoreException {
    try {
        InputStream inputStream = encodedResource.getResource().getInputStream();
        // 获取文件的IO流
        try { 
            InputSource inputSource = new InputSource(inputStream);
            if (encodedResource.getEncoding() != null) {
                inputSource.setEncoding(encodedResource.getEncoding());
            }
            // 开始干活了，已经获取到具体的文件流
            return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
        }
        ...
        
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
        throws BeanDefinitionStoreException {
    Document doc = doLoadDocument(inputSource, resource);  // 获取到xml的root节点
    return registerBeanDefinitions(doc, resource);
}

public int registerBeanDefinitions(Document doc, Resource resource)  {
    BeanDefinitionDocumentReader documentReader =  createBeanDefinitionDocumentReader(); 
    // 创建一个DefaultBeanDefinitionDocumentReader对象
    int countBefore = getRegistry().getBeanDefinitionCount();
    documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    // 还有个createReaderContext需要注意到
    // 在BeanDefinitionDocumentReader 中去解析xml节点，并注册BeanDefinition
    return getRegistry().getBeanDefinitionCount() - countBefore;
}

// 生成xmlreader的上下文context，其中有配置好的命名空间
public XmlReaderContext createReaderContext(Resource resource) {
    return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
            this.sourceExtractor, this, getNamespaceHandlerResolver());
            // getNamespaceHandlerResolver 获取命名空间的处理器
}

如下图所示，初始化成的命名空间处理器
[图片上传失败...(image-fd762c-1515824172842)]

DefaultBeanDefinitionDocumentReader 文件，传入的文档节点以及xmlreader上下文

// 注册解析xml
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
    this.readerContext = readerContext;
    // 这个readerContext就是上面传进来的读取xml的context上下文
    logger.debug("Loading bean definitions");
    Element root = doc.getDocumentElement();  // 获取的xml的根节点
    doRegisterBeanDefinitions(root);  // 开始干活了
}

protected void doRegisterBeanDefinitions(Element root) {
    BeanDefinitionParserDelegate parent = this.delegate;
    this.delegate = createDelegate(getReaderContext(), root, parent);
    // xml的解析器，只支持默认的beans的命名空间的解析操作
    if (this.delegate.isDefaultNamespace(root)) {  
        String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
        // 存在profile属性设置
        if (StringUtils.hasText(profileSpec)) {
            String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                    profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
            if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
            // 检查当前环境是否支持设置的profile，如果不支持则认为该xml无效，停止读取
                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;
}

// 真正的开始解析具体的xml元素！！！
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); // 循环遍历beans的子节点
            if (node instanceof Element) {
                Element ele = (Element) node;
                if (delegate.isDefaultNamespace(ele)) {
                    // 解析默认命名空间的元素，例如bean
                    parseDefaultElement(ele, delegate);
                }
                else {
                    // 非默认的命名空间，例如context或者其他元素例如dubbo
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }
    else {
        delegate.parseCustomElement(root);
    }
}

// 根据元素选择不同的解析方式
private void parseDefaultElement(Element ele, 
                BeanDefinitionParserDelegate delegate) {
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
        importBeanDefinitionResource(ele);
    }
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
        processAliasRegistration(ele);
    }
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
       // 解析bean元素设置,也是本次demo的目标
        processBeanDefinition(ele, delegate);
    }
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
        // recurse
        doRegisterBeanDefinitions(ele);
    }
}

protected void processBeanDefinition(Element ele, 
            BeanDefinitionParserDelegate delegate) {
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    //  非常！！！！非常！！！重要的解析操作,通过delegate去解析
    ...
}

BeanDefinitionParserDelegate 文件,通过一个xml节点信息去生成一个BeanDefinitionHolder对象

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
    String id = ele.getAttribute(ID_ATTRIBUTE);  // 解析id属性
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE); // 解析name属性

    List<String> aliases = new ArrayList<String>();
    if (StringUtils.hasLength(nameAttr)) {
        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
        // 意味着在给bean设置name的时候可以设置多个，通过“,“区分开来
        aliases.addAll(Arrays.asList(nameArr));
    }

    String beanName = id;
    if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
       // 如果没有设置id属性，而且有名称，则移除name的第一个设置为beanName属性
        beanName = aliases.remove(0);
    }

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

    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    // 也是很关键的步骤，解析生成beandefinition
    if (beanDefinition != null) {
        if (!StringUtils.hasText(beanName)) {
            try {
                if (containingBean != null) {
                    beanName = BeanDefinitionReaderUtils.generateBeanName(
                            beanDefinition, this.readerContext.getRegistry(), true);
                }
                else {
                    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.
                    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);
    }
    return null;
}

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);
        }
        AbstractBeanDefinition bd = createBeanDefinition(className, parent);
        // 根据类名创建一个beandefinition对象bd
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd); 
        // 解析bean的属性值
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
        // 设置描述 

        parseMetaElements(ele, bd); // 设置元素的meta属性
        parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

        parseConstructorArgElements(ele, bd); // 解析设置构造器参数
        parsePropertyElements(ele, bd);  // 解析property参数数据
        parseQualifierElements(ele, bd);  // 解析qualifier参数数据

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

        return bd; // 最后！！！！终于返回了我们需要的beandefinition对象
        ...
    return null;
}

至此，解析xml数据终于完成了，后续肯定还有生成具体的beandefinition，插入到对应的map，后续getBean等等一系列的操作。

如下图是整个xml解析的大致流程图，标为红色的背景的步骤是比较重要的步骤

image.png