手擼Spring框架，設計與實現資源載入器，從Spring.xml解析和註冊Bean物件

作者：小傅哥
部落格：https://bugstack.cn

沉澱、分享、成長，讓自己和他人都能有所收穫！?

一、前言

你寫的程式碼，能接的住產品加需求嗎？

接，是能接的，接幾次也行，哪怕就一個類一片的 if...else 也可以！但接完成什麼樣可就不一定了，會不會出事故也不是能控制住的。

那出事故時，你說因為我寫 if...else 多了導致程式碼爛了，但可是你先動的手啊：你說的需求還得加、你說的老闆讓上線、你說的合同都簽了，搬磚碼農的我沒辦法，才以堆程式碼平需求，需求太多不好搞，我才以搬磚平需求！諸侯不服，我才以兵服諸侯，你不服，我就打到你服！

但程式碼爛了有時候並不是因為需求加的快、也不是著急上線。因為往往在承接產品需求的前幾次，一個功能邏輯的設計並不會太複雜，也不會有多急迫，甚至會留出讓你做設計、做評審、做開發的時間，如果這個時候仍不能把以後可能會發生的事情評估到需求裡，那麼導致程式碼的混亂從一開始就已經埋下了，以後只能越來越亂！

承接需求並能把它做好，這來自於對需求的理解，產品場景開發的經驗以及對程式碼實踐落地的把控能力等綜合多方面因素的結果。就像你現在做的開發中，你的程式碼有哪些是經常變化的，有哪些是固定通用的，有哪些是負責邏輯拼裝的、有哪些是來做核心實現的。那麼現在如果你的核心共用層做了頻繁變化的業務層包裝，那麼肯定的說，你的程式碼即將越來越亂，甚至可能埋下事故的風險！

在我們實現的 Spring 框架中，每一個章節都會結合上一章節繼續擴充套件功能，就像每一次產品都在加需求一樣，那麼在學習的過程中可以承上啟下的對照和參考，看看每一個模組的新增都是用什麼邏輯和技術細節實現的。這些內容的學習，會非常有利於你以後在設計和實現，自己承接產品需求時做的具體開發，程式碼的質量也會越來越高，越來越有擴充套件性和可維護性。

二、目標

在完成 Spring 的框架雛形後，現在我們可以通過單元測試進行手動操作 Bean 物件的定義、註冊和屬性填充，以及最終獲取物件呼叫方法。但這裡會有一個問題，就是如果實際使用這個 Spring 框架，是不太可能讓使用者通過手動方式建立的，而是最好能通過配置檔案的方式簡化建立過程。需要完成如下操作：

• 如圖中我們需要把步驟：2、3、4整合到Spring框架中，通過 Spring 配置檔案的方式將 Bean 物件例項化。
• 接下來我們就需要在現有的 Spring 框架中，新增能解決 Spring 配置的讀取、解析、註冊Bean的操作。

三、設計

依照本章節的需求背景，我們需要在現有的 Spring 框架雛形中新增一個資源解析器，也就是能讀取classpath、本地檔案和雲檔案的配置內容。這些配置內容就是像使用 Spring 時配置的 Spring.xml 一樣，裡面會包括 Bean 物件的描述和屬性資訊。 在讀取配置檔案資訊後，接下來就是對配置檔案中的 Bean 描述資訊解析後進行註冊操作，把 Bean 物件註冊到 Spring 容器中。整體設計結構如下圖：

• 資源載入器屬於相對獨立的部分，它位於 Spring 框架核心包下的IO實現內容，主要用於處理Class、本地和雲環境中的檔案資訊。
• 當資源可以載入後，接下來就是解析和註冊 Bean 到 Spring 中的操作，這部分實現需要和 DefaultListableBeanFactory 核心類結合起來，因為你所有的解析後的註冊動作，都會把 Bean 定義資訊放入到這個類中。
• 那麼在實現的時候就設計好介面的實現層級關係，包括我們需要定義出 Bean 定義的讀取介面 BeanDefinitionReader 以及做好對應的實現類，在實現類中完成對 Bean 物件的解析和註冊。

四、實現

1. 工程結構

small-spring-step-05
└── src
    ├── main
    │   └── java
    │       └── cn.bugstack.springframework  
    │           ├── beans
    │           │   ├── factory
    │           │   │   ├── factory
    │           │   │   │   ├── AutowireCapableBeanFactory.java
    │           │   │   │   ├── BeanDefinition.java
    │           │   │   │   ├── BeanReference.java
    │           │   │   │   ├── ConfigurableBeanFactory.java
    │           │   │   │   └── SingletonBeanRegistry.java
    │           │   │   ├── support
    │           │   │   │   ├── AbstractAutowireCapableBeanFactory.java
    │           │   │   │   ├── AbstractBeanDefinitionReader.java
    │           │   │   │   ├── AbstractBeanFactory.java
    │           │   │   │   ├── BeanDefinitionReader.java
    │           │   │   │   ├── BeanDefinitionRegistry.java
    │           │   │   │   ├── CglibSubclassingInstantiationStrategy.java
    │           │   │   │   ├── DefaultListableBeanFactory.java
    │           │   │   │   ├── DefaultSingletonBeanRegistry.java
    │           │   │   │   ├── InstantiationStrategy.java
    │           │   │   │   └── SimpleInstantiationStrategy.java  
    │           │   │   ├── support
    │           │   │   │   └── XmlBeanDefinitionReader.java
    │           │   │   ├── BeanFactory.java
    │           │   │   ├── ConfigurableListableBeanFactory.java
    │           │   │   ├── HierarchicalBeanFactory.java
    │           │   │   └── ListableBeanFactory.java
    │           │   ├── BeansException.java
    │           │   ├── PropertyValue.java
    │           │   └── PropertyValues.java 
    │           ├── core.io
    │           │   ├── ClassPathResource.java 
    │           │   ├── DefaultResourceLoader.java 
    │           │   ├── FileSystemResource.java 
    │           │   ├── Resource.java 
    │           │   ├── ResourceLoader.java 
    │           │   └── UrlResource.java
    │           └── utils
    │               └── ClassUtils.java
    └── test
        └── java
            └── cn.bugstack.springframework.test
                ├── bean
                │   ├── UserDao.java
                │   └── UserService.java
                └── ApiTest.java

工程原始碼：公眾號「bugstack蟲洞棧」，回覆：Spring 專欄，獲取完整原始碼

Spring Bean 容器資源載入和使用類關係，如圖 6-3

• 本章節為了能把 Bean 的定義、註冊和初始化交給 Spring.xml 配置化處理，那麼就需要實現兩大塊內容，分別是：資源載入器、xml資源處理類，實現過程主要以對介面 Resource、ResourceLoader 的實現，而另外 BeanDefinitionReader 介面則是對資源的具體使用，將配置資訊註冊到 Spring 容器中去。
• 在 Resource 的資源載入器的實現中包括了，ClassPath、系統檔案、雲配置檔案，這三部分與 Spring 原始碼中的設計和實現保持一致，最終在 DefaultResourceLoader 中做具體的呼叫。
• 介面：BeanDefinitionReader、抽象類：AbstractBeanDefinitionReader、實現類：XmlBeanDefinitionReader，這三部分內容主要是合理清晰的處理了資源讀取後的註冊 Bean 容器操作。介面管定義，抽象類處理非介面功能外的註冊Bean元件填充，最終實現類即可只關心具體的業務實現

另外本章節還參考 Spring 原始碼，做了相應介面的整合和實現的關係，雖然這些介面目前還並沒有太大的作用，但隨著框架的逐步完善，它們也會發揮作用。如圖 6-4

• BeanFactory，已經存在的 Bean 工廠介面用於獲取 Bean 物件，這次新增加了按照型別獲取 Bean 的方法：<T> T getBean(String name, Class<T> requiredType)
• ListableBeanFactory，是一個擴充套件 Bean 工廠介面的介面，新增加了 getBeansOfType、getBeanDefinitionNames() 方法，在 Spring 原始碼中還有其他擴充套件方法。
• HierarchicalBeanFactory，在 Spring 原始碼中它提供了可以獲取父類 BeanFactory 方法，屬於是一種擴充套件工廠的層次子介面。Sub-interface implemented by bean factories that can be part of a hierarchy.
• AutowireCapableBeanFactory，是一個自動化處理Bean工廠配置的介面，目前案例工程中還沒有做相應的實現，後續逐步完善。
• ConfigurableBeanFactory，可獲取 BeanPostProcessor、BeanClassLoader等的一個配置化介面。
• ConfigurableListableBeanFactory，提供分析和修改Bean以及預先例項化的操作介面，不過目前只有一個 getBeanDefinition 方法。

2. 資源載入介面定義和實現

cn.bugstack.springframework.core.io.Resource

public interface Resource {

    InputStream getInputStream() throws IOException;

}

• 在 Spring 框架下建立 core.io 核心包，在這個包中主要用於處理資源載入流。
• 定義 Resource 介面，提供獲取 InputStream 流的方法，接下來再分別實現三種不同的流檔案操作：classPath、FileSystem、URL

ClassPath：cn.bugstack.springframework.core.io.ClassPathResource

public class ClassPathResource implements Resource {

    private final String path;

    private ClassLoader classLoader;

    public ClassPathResource(String path) {
        this(path, (ClassLoader) null);
    }

    public ClassPathResource(String path, ClassLoader classLoader) {
        Assert.notNull(path, "Path must not be null");
        this.path = path;
        this.classLoader = (classLoader != null ? classLoader : ClassUtils.getDefaultClassLoader());
    }

    @Override
    public InputStream getInputStream() throws IOException {
        InputStream is = classLoader.getResourceAsStream(path);
        if (is == null) {
            throw new FileNotFoundException(
                    this.path + " cannot be opened because it does not exist");
        }
        return is;
    }
}

• 這一部分的實現是用於通過 ClassLoader 讀取 ClassPath 下的檔案資訊，具體的讀取過程主要是：classLoader.getResourceAsStream(path)

FileSystem：cn.bugstack.springframework.core.io.FileSystemResource

public class FileSystemResource implements Resource {

    private final File file;

    private final String path;

    public FileSystemResource(File file) {
        this.file = file;
        this.path = file.getPath();
    }

    public FileSystemResource(String path) {
        this.file = new File(path);
        this.path = path;
    }

    @Override
    public InputStream getInputStream() throws IOException {
        return new FileInputStream(this.file);
    }

    public final String getPath() {
        return this.path;
    }

}

• 通過指定檔案路徑的方式讀取檔案資訊，這部分大家肯定還是非常熟悉的，經常會讀取一些txt、excel檔案輸出到控制檯。

Url：cn.bugstack.springframework.core.io.UrlResource

public class UrlResource implements Resource{

    private final URL url;

    public UrlResource(URL url) {
        Assert.notNull(url,"URL must not be null");
        this.url = url;
    }

    @Override
    public InputStream getInputStream() throws IOException {
        URLConnection con = this.url.openConnection();
        try {
            return con.getInputStream();
        }
        catch (IOException ex){
            if (con instanceof HttpURLConnection){
                ((HttpURLConnection) con).disconnect();
            }
            throw ex;
        }
    }

}

• 通過 HTTP 的方式讀取雲服務的檔案，我們也可以把配置檔案放到 GitHub 或者 Gitee 上。

3. 包裝資源載入器

按照資源載入的不同方式，資源載入器可以把這些方式集中到統一的類服務下進行處理，外部使用者只需要傳遞資源地址即可，簡化使用。

定義介面：cn.bugstack.springframework.core.io.ResourceLoader

public interface ResourceLoader {

    /**
     * Pseudo URL prefix for loading from the class path: "classpath:"
     */
    String CLASSPATH_URL_PREFIX = "classpath:";

    Resource getResource(String location);

}

• 定義獲取資源介面，裡面傳遞 location 地址即可。

實現介面：cn.bugstack.springframework.core.io.DefaultResourceLoader

public class DefaultResourceLoader implements ResourceLoader {

    @Override
    public Resource getResource(String location) {
        Assert.notNull(location, "Location must not be null");
        if (location.startsWith(CLASSPATH_URL_PREFIX)) {
            return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()));
        }
        else {
            try {
                URL url = new URL(location);
                return new UrlResource(url);
            } catch (MalformedURLException e) {
                return new FileSystemResource(location);
            }
        }
    }

}

• 在獲取資源的實現中，主要是把三種不同型別的資源處理方式進行了包裝，分為：判斷是否為ClassPath、URL以及檔案。
• 雖然 DefaultResourceLoader 類實現的過程簡單，但這也是設計模式約定的具體結果，像是這裡不會讓外部呼叫放知道過多的細節，而是僅關心具體呼叫結果即可。

4. Bean定義讀取介面

cn.bugstack.springframework.beans.factory.support.BeanDefinitionReader

public interface BeanDefinitionReader {

    BeanDefinitionRegistry getRegistry();

    ResourceLoader getResourceLoader();

    void loadBeanDefinitions(Resource resource) throws BeansException;

    void loadBeanDefinitions(Resource... resources) throws BeansException;

    void loadBeanDefinitions(String location) throws BeansException;

}

• 這是一個 Simple interface for bean definition readers. 其實裡面無非定義了幾個方法，包括：getRegistry()、getResourceLoader()，以及三個載入Bean定義的方法。
• 這裡需要注意 getRegistry()、getResourceLoader()，都是用於提供給後面三個方法的工具，載入和註冊，這兩個方法的實現會包裝到抽象類中，以免汙染具體的介面實現方法。

5. Bean定義抽象類實現

cn.bugstack.springframework.beans.factory.support.AbstractBeanDefinitionReader

public abstract class AbstractBeanDefinitionReader implements BeanDefinitionReader {

    private final BeanDefinitionRegistry registry;

    private ResourceLoader resourceLoader;

    protected AbstractBeanDefinitionReader(BeanDefinitionRegistry registry) {
        this(registry, new DefaultResourceLoader());
    }

    public AbstractBeanDefinitionReader(BeanDefinitionRegistry registry, ResourceLoader resourceLoader) {
        this.registry = registry;
        this.resourceLoader = resourceLoader;
    }

    @Override
    public BeanDefinitionRegistry getRegistry() {
        return registry;
    }

    @Override
    public ResourceLoader getResourceLoader() {
        return resourceLoader;
    }

}

• 抽象類把 BeanDefinitionReader 介面的前兩個方法全部實現完了，並提供了建構函式，讓外部的呼叫使用方，把Bean定義注入類，傳遞進來。
• 這樣在介面 BeanDefinitionReader 的具體實現類中，就可以把解析後的 XML 檔案中的 Bean 資訊，註冊到 Spring 容器去了。以前我們是通過單元測試使用，呼叫 BeanDefinitionRegistry 完成Bean的註冊，現在可以放到 XMl 中操作了

6. 解析XML處理Bean註冊

cn.bugstack.springframework.beans.factory.xml.XmlBeanDefinitionReader

public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {

    public XmlBeanDefinitionReader(BeanDefinitionRegistry registry) {
        super(registry);
    }

    public XmlBeanDefinitionReader(BeanDefinitionRegistry registry, ResourceLoader resourceLoader) {
        super(registry, resourceLoader);
    }

    @Override
    public void loadBeanDefinitions(Resource resource) throws BeansException {
        try {
            try (InputStream inputStream = resource.getInputStream()) {
                doLoadBeanDefinitions(inputStream);
            }
        } catch (IOException | ClassNotFoundException e) {
            throw new BeansException("IOException parsing XML document from " + resource, e);
        }
    }

    @Override
    public void loadBeanDefinitions(Resource... resources) throws BeansException {
        for (Resource resource : resources) {
            loadBeanDefinitions(resource);
        }
    }

    @Override
    public void loadBeanDefinitions(String location) throws BeansException {
        ResourceLoader resourceLoader = getResourceLoader();
        Resource resource = resourceLoader.getResource(location);
        loadBeanDefinitions(resource);
    }

    protected void doLoadBeanDefinitions(InputStream inputStream) throws ClassNotFoundException {
        Document doc = XmlUtil.readXML(inputStream);
        Element root = doc.getDocumentElement();
        NodeList childNodes = root.getChildNodes();

        for (int i = 0; i < childNodes.getLength(); i++) {
            // 判斷元素
            if (!(childNodes.item(i) instanceof Element)) continue;
            // 判斷物件
            if (!"bean".equals(childNodes.item(i).getNodeName())) continue;
            
            // 解析標籤
            Element bean = (Element) childNodes.item(i);
            String id = bean.getAttribute("id");
            String name = bean.getAttribute("name");
            String className = bean.getAttribute("class");
            // 獲取 Class，方便獲取類中的名稱
            Class<?> clazz = Class.forName(className);
            // 優先順序 id > name
            String beanName = StrUtil.isNotEmpty(id) ? id : name;
            if (StrUtil.isEmpty(beanName)) {
                beanName = StrUtil.lowerFirst(clazz.getSimpleName());
            }

            // 定義Bean
            BeanDefinition beanDefinition = new BeanDefinition(clazz);
            // 讀取屬性並填充
            for (int j = 0; j < bean.getChildNodes().getLength(); j++) {
                if (!(bean.getChildNodes().item(j) instanceof Element)) continue;
                if (!"property".equals(bean.getChildNodes().item(j).getNodeName())) continue;
                // 解析標籤：property
                Element property = (Element) bean.getChildNodes().item(j);
                String attrName = property.getAttribute("name");
                String attrValue = property.getAttribute("value");
                String attrRef = property.getAttribute("ref");
                // 獲取屬性值：引入物件、值物件
                Object value = StrUtil.isNotEmpty(attrRef) ? new BeanReference(attrRef) : attrValue;
                // 建立屬性資訊
                PropertyValue propertyValue = new PropertyValue(attrName, value);
                beanDefinition.getPropertyValues().addPropertyValue(propertyValue);
            }
            if (getRegistry().containsBeanDefinition(beanName)) {
                throw new BeansException("Duplicate beanName[" + beanName + "] is not allowed");
            }
            // 註冊 BeanDefinition
            getRegistry().registerBeanDefinition(beanName, beanDefinition);
        }
    }

}

XmlBeanDefinitionReader 類最核心的內容就是對 XML 檔案的解析，把我們本來在程式碼中的操作放到了通過解析 XML 自動註冊的方式。

• loadBeanDefinitions 方法，處理資源載入，這裡新增加了一個內部方法：doLoadBeanDefinitions，它主要負責解析 xml
• 在 doLoadBeanDefinitions 方法中，主要是對xml的讀取 XmlUtil.readXML(inputStream) 和元素 Element 解析。在解析的過程中通過迴圈操作，以此獲取 Bean 配置以及配置中的 id、name、class、value、ref 資訊。
• 最終把讀取出來的配置資訊，建立成 BeanDefinition 以及 PropertyValue，最終把完整的 Bean 定義內容註冊到 Bean 容器：getRegistry().registerBeanDefinition(beanName, beanDefinition)

五、測試

1. 事先準備

cn.bugstack.springframework.test.bean.UserDao

public class UserDao {

    private static Map<String, String> hashMap = new HashMap<>();

    static {
        hashMap.put("10001", "小傅哥");
        hashMap.put("10002", "八杯水");
        hashMap.put("10003", "阿毛");
    }

    public String queryUserName(String uId) {
        return hashMap.get(uId);
    }

}

cn.bugstack.springframework.test.bean.UserService

public class UserService {

    private String uId;

    private UserDao userDao;

    public void queryUserInfo() {
        return userDao.queryUserName(uId);
    }

    // ...get/set
}

• Dao、Service，是我們平常開發經常使用的場景。在 UserService 中注入 UserDao，這樣就能體現出Bean屬性的依賴了。

2. 配置檔案

important.properties

# Config File
system.key=OLpj9823dZ

spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans>

    <bean id="userDao" class="cn.bugstack.springframework.test.bean.UserDao"/>

    <bean id="userService" class="cn.bugstack.springframework.test.bean.UserService">
        <property name="uId" value="10001"/>
        <property name="userDao" ref="userDao"/>
    </bean>

</beans>

• 這裡有兩份配置檔案，一份用於測試資源載入器，另外 spring.xml 用於測試整體的 Bean 註冊功能。

3. 單元測試(資源載入)

案例

private DefaultResourceLoader resourceLoader;      

@Before
public void init() {
    resourceLoader = new DefaultResourceLoader();
}   

@Test
public void test_classpath() throws IOException {
    Resource resource = resourceLoader.getResource("classpath:important.properties");
    InputStream inputStream = resource.getInputStream();
    String content = IoUtil.readUtf8(inputStream);
    System.out.println(content);
}   

@Test
public void test_file() throws IOException {
    Resource resource = resourceLoader.getResource("src/test/resources/important.properties");
    InputStream inputStream = resource.getInputStream();
    String content = IoUtil.readUtf8(inputStream);
    System.out.println(content);
}    

@Test
public void test_url() throws IOException {
    Resource resource = resourceLoader.getResource("https://github.com/fuzhengwei/small-spring/important.properties"
    InputStream inputStream = resource.getInputStream();
    String content = IoUtil.readUtf8(inputStream);
    System.out.println(content);
}

測試結果

# Config File
system.key=OLpj9823dZ

Process finished with exit code 0

• 這三個方法：test_classpath、test_file、test_url，分別用於測試載入 ClassPath、FileSystem、Url 檔案，URL檔案在Github，可能載入時會慢

4. 單元測試(配置檔案註冊Bean)

案例

@Test
public void test_xml() {
    // 1.初始化 BeanFactory
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

    // 2. 讀取配置檔案&註冊Bean
    XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
    reader.loadBeanDefinitions("classpath:spring.xml");

    // 3. 獲取Bean物件呼叫方法
    UserService userService = beanFactory.getBean("userService", UserService.class);
    String result = userService.queryUserInfo();
    System.out.println("測試結果：" + result);
}

測試結果

測試結果：小傅哥

Process finished with exit code 0

• 在上面的測試案例中可以看到，我們把以前通過手動註冊 Bean 以及配置屬性資訊的內容，交給了 new XmlBeanDefinitionReader(beanFactory) 類讀取 Spring.xml 的方式來處理，並通過了測試驗證。

六、總結

• 此時的工程結構已經越來越有 Spring 框架的味道了，以配置檔案為入口解析和註冊 Bean 資訊，最終再通過 Bean 工廠獲取 Bean 以及做相應的呼叫操作。
• 關於案例中每一個步驟的實現小傅哥這裡都會盡可能參照 Spring 原始碼的介面定義、抽象類實現、名稱規範、程式碼結構等，做相應的簡化處理。這樣大家在學習的過程中也可以通過類名或者介面和整個結構體學習 Spring 原始碼，這樣學習起來就容易多了。
• 看完絕對不等於會，你只有動起手來從一個小小的工程框架結構，敲到現在以及以後不斷的變大、變多、變強時，才能真的掌握這裡面的知識。另外每一個章節的功能實現都會涉及到很多的程式碼設計思路，要認真去領悟。當然實踐起來是最好的領悟方式！

七、系列推薦

• 給你一臺伺服器，你能把你寫的程式碼部署到線上嗎？
• 畢業前寫了20萬行程式碼，讓我從成為同學眼裡的麵霸！
• 數學，離一個程式設計師有多近？
• 一次程式碼評審，差點過不了試用期！
• 以數學知識點開始，深入講解 Java 的核心技術400頁Java面經