主要是了解和學習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; // 最后！?。。〗K于返回了我們需要的beandefinition對象
        ...
    return null;
}

至此，解析xml數據終于完成了，后續肯定還有生成具體的beandefinition，插入到對應的map，后續getBean等等一系列的操作。

如下圖是整個xml解析的大致流程圖，標為紅色的背景的步驟是比較重要的步驟

image.png