2. 程式人生 > >深入研究Spring-IoC：原始碼分析容器建立

深入研究Spring-IoC：原始碼分析容器建立

阿新 • • 發佈：2018-11-01

1.前言

從之前的分析中可以知道IOC容器的建立大致分為3步：Resource定位、BeanDefinition載入解析、向容器註冊BeanDefinition。

Tiny-spring手動實現了Spring框架，通過對這個原始碼的解讀可以更好更有效的理解Spring。

2.容器建立的硬編碼

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("tinyioc.xml");
        HelloWorldService helloWorldService = (HelloWorldService) applicationContext.getBean
 
("helloWorldService");
        helloWorldService.helloWorld();

這是我手動建立ioc容器最常見的方式了，但是這段程式碼底層是如何實現的呢？下面通過tiny-spirng原始碼分析一下。

回到最初：

BeanDefinition的Resource定位：

 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("tinyioc.xml");

Resource的介面實現類ClassPathXmlApplicationContext並不能直接被BeanFatory的簡單實現類呼叫，因為ClassPathXmlApplicationContext讀取了xml後是由BeanDefnintionReader來處理的。除非是實現了ResourceLoader介面，也就是ApplicationContext及其子類。

BeanDefinition的載入和BeanDefinition註冊往下看：

BeanFactory基本容器介面：

public interface BeanFactory {

    Object getBean(String name) throws Exception;

}

ApplicationContext繼承BeanFatory:

public interface ApplicationContext extends BeanFactory {
}

AbstractApplicationContext實現了ApplicationContext介面：

public
 
 abstract class AbstractApplicationContext implements ApplicationContext {
    protected AbstractBeanFactory beanFactory;

    public AbstractApplicationContext(AbstractBeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

    public void refresh() throws Exception {
        loadBeanDefinitions(beanFactory);
        registerBeanPostProcessors(beanFactory);
        onRefresh();
    }

    protected abstract void loadBeanDefinitions(AbstractBeanFactory beanFactory) throws Exception;

    protected void registerBeanPostProcessors(AbstractBeanFactory beanFactory) throws Exception {
        List beanPostProcessors = beanFactory.getBeansForType(BeanPostProcessor.class);
        for (Object beanPostProcessor : beanPostProcessors) {
            beanFactory.addBeanPostProcessor((BeanPostProcessor) beanPostProcessor);
        }
    }

    protected void onRefresh() throws Exception{
        beanFactory.preInstantiateSingletons();
    }

    @Override
    public Object getBean(String name) throws Exception {
        return beanFactory.getBean(name);
    }
}

ClassPathXmlApplicationContext繼承AbstractApplicationContext：

public class ClassPathXmlApplicationContext extends AbstractApplicationContext {

    private String configLocation;

    public ClassPathXmlApplicationContext(String configLocation) throws Exception {
        this(configLocation, new AutowireCapableBeanFactory());
    }

    public ClassPathXmlApplicationContext(String configLocation, AbstractBeanFactory beanFactory) throws Exception {
        super(beanFactory);
        this.configLocation = configLocation;
        refresh();
    }

    @Override
    protected void loadBeanDefinitions(AbstractBeanFactory beanFactory) throws Exception {
        XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(new ResourceLoader());
        xmlBeanDefinitionReader.loadBeanDefinitions(configLocation);
        for (Map.Entry<String, BeanDefinition> beanDefinitionEntry : xmlBeanDefinitionReader.getRegistry().entrySet()) {
            beanFactory.registerBeanDefinition(beanDefinitionEntry.getKey(), beanDefinitionEntry.getValue());
        }
    }

}

XmlBeanDefinitionReader處理類（核心）：

package us.codecraft.tinyioc.beans.xml;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import us.codecraft.tinyioc.BeanReference;
import us.codecraft.tinyioc.beans.AbstractBeanDefinitionReader;
import us.codecraft.tinyioc.beans.BeanDefinition;
import us.codecraft.tinyioc.beans.PropertyValue;
import us.codecraft.tinyioc.beans.io.ResourceLoader;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.InputStream;

/**
 * @author [email protected]
 */
public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {

    public XmlBeanDefinitionReader(ResourceLoader resourceLoader) {
        super(resourceLoader);
    }

    @Override
    public void loadBeanDefinitions(String location) throws Exception {
        InputStream inputStream = getResourceLoader().getResource(location).getInputStream();
        doLoadBeanDefinitions(inputStream);
    }

    protected void doLoadBeanDefinitions(InputStream inputStream) throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder = factory.newDocumentBuilder();
        Document doc = docBuilder.parse(inputStream);
        // 解析bean
        registerBeanDefinitions(doc);
        inputStream.close();
    }

    public void registerBeanDefinitions(Document doc) {
        Element root = doc.getDocumentElement();

        parseBeanDefinitions(root);
    }

    protected void parseBeanDefinitions(Element 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;
                processBeanDefinition(ele);
            }
        }
    }

    protected void processBeanDefinition(Element ele) {
        String name = ele.getAttribute("id");
        String className = ele.getAttribute("class");
        BeanDefinition beanDefinition = new BeanDefinition();
        processProperty(ele, beanDefinition);
        beanDefinition.setBeanClassName(className);
        getRegistry().put(name, beanDefinition);
    }

    private void processProperty(Element ele, BeanDefinition beanDefinition) {
        NodeList propertyNode = ele.getElementsByTagName("property");
        for (int i = 0; i < propertyNode.getLength(); i++) {
            Node node = propertyNode.item(i);
            if (node instanceof Element) {
                Element propertyEle = (Element) node;
                String name = propertyEle.getAttribute("name");
                String value = propertyEle.getAttribute("value");
                if (value != null && value.length() > 0) {
                    beanDefinition.getPropertyValues().addPropertyValue(new PropertyValue(name, value));
                } else {
                    String ref = propertyEle.getAttribute("ref");
                    if (ref == null || ref.length() == 0) {
                        throw new IllegalArgumentException("Configuration problem: <property> element for property '"
                                + name + "' must specify a ref or value");
                    }
                    BeanReference beanReference = new BeanReference(ref);
                    beanDefinition.getPropertyValues().addPropertyValue(new PropertyValue(name, beanReference));
                }
            }
        }
    }
}

3.分析

當執行：

 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("tinyioc.xml");

ClassPathXmlApplicationContext的構造方法為：

    public ClassPathXmlApplicationContext(String configLocation) throws Exception {
        this(configLocation, new AutowireCapableBeanFactory());
    }

    public ClassPathXmlApplicationContext(String configLocation, AbstractBeanFactory beanFactory) throws Exception {
        super(beanFactory);
        this.configLocation = configLocation;
        refresh();
    }

其中configLocation為傳入xml定位，BeanFatory指定了容器的可自動配置。最後調refresh()方法。

    public void refresh() throws Exception {
        loadBeanDefinitions(beanFactory);
        registerBeanPostProcessors(beanFactory);
        onRefresh();
    }

在refresh（）方法中呼叫了loadBeanDefinitions(beanFactory)和 registerBeanPostProcessors(beanFactory)方法。先看loadBeanDefinitions(beanFactory)方法的實現：

    @Override
    protected void loadBeanDefinitions(AbstractBeanFactory beanFactory) throws Exception {
        XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(new ResourceLoader());
        xmlBeanDefinitionReader.loadBeanDefinitions(configLocation);
        for (Map.Entry<String, BeanDefinition> beanDefinitionEntry : xmlBeanDefinitionReader.getRegistry().entrySet()) {
            beanFactory.registerBeanDefinition(beanDefinitionEntry.getKey(), beanDefinitionEntry.getValue());
        }
    }

底層中是呼叫了XmlBeanDefinitionReader來讀取xml內的bean.loadBeanDefinitions方法是用io流inputStream 讀取資源。

    @Override
    public void loadBeanDefinitions(String location) throws Exception {
        InputStream inputStream = getResourceLoader().getResource(location).getInputStream();
        doLoadBeanDefinitions(inputStream);
    }

doLoadBeanDefinitions(inputStream)方法將讀取的資源轉換成Document物件，通過registerBeanDefinitions(Document），解析其中的每個Elements。然後得到BeanDefinition然後註冊。

protected void doLoadBeanDefinitions(InputStream inputStream) throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder = factory.newDocumentBuilder();
        Document doc = docBuilder.parse(inputStream);
        // 解析bean
        registerBeanDefinitions(doc);
        inputStream.close();
    }
    public void registerBeanDefinitions(Document doc) {
        Element root = doc.getDocumentElement();

        parseBeanDefinitions(root);
    }

    protected void parseBeanDefinitions(Element 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;
                processBeanDefinition(ele);
            }
        }
    }

    protected void processBeanDefinition(Element ele) {
        String name = ele.getAttribute("id");
        String className = ele.getAttribute("class");
        BeanDefinition beanDefinition = new BeanDefinition();
        processProperty(ele, beanDefinition);
        beanDefinition.setBeanClassName(className);
        getRegistry().put(name, beanDefinition);
    }

4.總結

短短的一行程式碼，卻包含了太多的東西：

  ApplicationContext applicationContext = new ClassPathXmlApplicationContext("tinyioc.xml");

ClassPathXmlApplicationContext構造方法中指定了url和實現BeanFatory介面的容器–AutowireCapableBeanFactory。呼叫refresh（）方法時加載出來了XmlBeanDefinitionReader和registerBeanPostProcessors方法。

通過XmlBeanDefinitionReader將xml中的bean轉換成了BeanDefinition並註冊;

通過registerBeanPostProcessors介面幫助我們，當需要在Spring容器完成Bean的例項化、配置和其他的初始化前後新增一些自己的邏輯處理，我們就可以定義一個或者多個BeanPostProcessor介面的實現，然後註冊到容器中。

讀原始碼總是能看到更多的東西。

學習資料git《tiny-Spring》

相關推薦

深入研究Spring-IoC：原始碼分析容器建立

1.前言 從之前的分析中可以知道IOC容器的建立大致分為3步：Resource定位、BeanDefinition載入解析、向容器註冊BeanDefinition。 Tiny-spring手動實現了Spring框架，通過對這個原始碼的解讀可以更好更有效的理解Spring。 2.

深入研究Spring-IoC：原始碼分析依賴注入

1.前言 對於容器建立的過程已經闡述過一遍了，下面是依賴注入的問題。Spring提供的依賴注入的方法主要由兩種：一種是通過getBean的方法；另一種是通過註解@Autowaire。 需要指出的是依賴注入的過程是使用者第一次向ioc容器索要Bean的時候開始生產的，也可以通過設定

深入研究Spring-IoC ：容器建立的幾種方式

1.前言 本文為對tiny-spring的學習解讀，程式碼參考自tiny-spring。一個手寫的Spring簡易版框架。 前面已經提到了Spring IOC容器的建立大致分為3個步驟。但是這個三個步驟是有一個演進的過程的，Spring容器建立方式前後有6種，從最基本的例項化建立

深入研究Spring-IoC:兩種設計和實現

一.Sprng IOC 解除了物件例項化造成的耦合現象；將物件的建立和對生命週期的管理交給了容器來管理，可以通過注入的方式將IOC容器中的物件供給開發者使用，極大方便了開發。 二.IOC容器系列的兩種設計和實現–BeanFactory和ApplicationCont

從零開始開發IoC依賴注入框架 -- containerx （深入研究Spring原始碼）（含github原始碼）

摘要: 自己寫了一個開源的IoC控制反轉（依賴注入）框架，名為containerx。初學Spring原始碼的同學，可以先研究下這個小專案。更容易理解Spring的原始碼 自己寫了一個開源的IoC控制反轉（依賴注入）框架，名為containerx。初學Spring原始碼的同學，可以先研究下這個

Spring Developer Tools 原始碼分析：三、重啟自動配置'

接上文 Spring Developer Tools 原始碼分析：二、類路徑監控，接下來看看前面提到的這些類是如何配置，如何啟動的。 spring-boot-devtools 使用了 Spring Boot 的自動配置方式，我們先關注本地開發環境中自動重啟的部分。 在 LocalDevToolsAut

自定義spring boot starter三部曲之三：原始碼分析spring.factories載入過程

本文是《自定義spring boot starter三部曲》系列的終篇，前文中我們開發了一個starter並做了驗證，發現關鍵點在於spring.factories的自動載入能力，讓應用只要依賴starter的jar包即可，今天我們來分析Spring和Spring boot原始碼，瞭解s

Spring Core Container 原始碼分析三：Spring Beans 初始化流程分析

前言 本文是筆者所著的 Spring Core Container 原始碼分析系列之一； 本篇文章主要試圖梳理出 Spring Beans 的初始化主流程和相關核心程式碼邏輯； 本文轉載自本人的部落格，傷神的部落格 http://www.shangyang.me/2017/

Spring Core Container 原始碼分析七：註冊 Bean Definitions

前言 原本以為，Spring 通過解析 bean 的配置，生成並註冊 bean defintions 的過程不太複雜，比較簡單，不用單獨開闢一篇博文來講述；但是當在分析前面兩個章節有關 @Autowired、@Component、@Service 註解的注入機制的時候，發現，如果沒有對有關 bea

Spring IOC原理原始碼解析(@Autowired原理詳解 ：標識屬性與方法)（二 ）

原始碼推薦看這篇部落格的時候開啟Spring原始碼，一邊看原始碼，一邊看部落格上程式碼的關鍵處的註釋，這樣能更好的理解Spring IOC的流程及內部實現和使用方法。如果你對IOC的原理有些瞭解，則這些註釋能幫你更深入的理解其實現方式。 Spring容器在每個

Spring學習（七）深入理解Spring IoC容器

IoC：他是Spring容器的核心，AOP、宣告式事務等功能都依賴於此功能，它涉及程式碼解耦，設計模式、程式碼優化等問題的考量。 接下來使用電影與演員的關係來詳細解釋一下IoC： 我們來使用電影《無

(精)Spring IOC核心原始碼學習III：bean標籤和自定義標籤實現原理

本文將解析spring bean定義標籤和自定義標籤的解析實現原理。這裡說的標籤僅限於以xml作為bean定義描述符的spring容器，繼承AbstractXmlApplicationContext的一些子 容器，如XmlApplicationContext、ClassPat

【Android開發】深入理解硬碟快取類DiskLruCache：原始碼分析

1.   原理     DisKLruCache是一個用於硬碟儲存的cache的類，它不是Android API，其GitHub地址為【https://github.com/JakeWharton/DiskLruCache】，也有些部落格對其進行了介紹【Android

Spring IOC原理原始碼解析(@Autowired原理詳解 ：標識建構函式)（一 ）

IOC，inversion of control 控制反轉，有時候也叫DI，dependency injection 依賴注入，是一種程式碼解耦的方式。 在一個類中定義一個屬性，正常情況下需要在此類中有對此屬性賦值的程式碼，如setter方法，或者在建構函式中

最詳細的Spring核心IOC的原始碼分析(每次看都有不同的感悟)

Spring 最重要的概念是 IOC 和 AOP，本篇文章其實就是要帶領大家來分析下 Spring 的 IOC 容器。既然大家平時都要用到 Spring，怎麼可以不好好了解 Spring 呢？閱讀本文並不能讓你成為 Spring 專家，不過一定有助於大家理解 Spring

深入理解Spring IOC

epo 弊端 容器 one bsp 增加 代碼 改變 直接 　　為什麽會出現spring，spring出現解決了什麽問題? 　　1.分析普通多層架構存在的問題 　　JSP->Servlet->Service->Dao 層與層之間的依賴很強，屬於耦

Spring Cloud Zuul原始碼分析

如何使用Spring Cloud Zuul？ 之前的文章中，我們學習了Spring Cloud Zuul如何使用，這裡再回顧下： 1.引入依賴，在啟動類中新增@EnableZuulProxy，宣告這是一個Zuul代理。 2.註冊到Eureka Server，啟動服務，訪問這個埠，ur

spring-boot-admin原始碼分析及單機監控spring-boot-monitor的實現（三）

SpringBootMonitor spring-boot-admin原始碼分析及單機監控spring-boot-monitor的實現（一） spring-boot-admin原始碼分析及單機監控spring-boot-monitor的實現（二）

spring-boot-admin原始碼分析及單機監控spring-boot-monitor的實現（二）

SpringBootMonitor spring-boot-admin原始碼分析及單機監控spring-boot-monitor的實現（一） spring-boot-admin原始碼分析及單機監控spring-boot-monitor的實現（二）

spring-boot-admin原始碼分析及單機監控spring-boot-monitor的實現（一）

SpringBootMonitor spring-boot-admin原始碼分析及單機監控spring-boot-monitor的實現（一） spring-boot-admin原始碼分析及單機監控spring-boot-monitor的實現（二） spring-boot-ad