2. 程式人生 > >Spring4.x原始碼解析：IOC容器底層原理解析

Spring4.x原始碼解析：IOC容器底層原理解析

阿新 • • 發佈：2018-12-17

引包

 		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>

IOC簡單介紹

1、作用

Spring IOC 主要負責建立物件，解決物件之間的依賴，並且管理這些物件的整個生命週期。

2、體系結構

IOC容器是由三部分組成

  • BeanDefinition(Bean定義)
  • BeanDefinition解析器
  • Bean管理

BeanDefinition

BeanDefinition：org.springframework.beans.factory.config.BeanDefinition

XML配置檔案裡的一個標籤（這裡就以<bean>標籤為例）對應一個BeanDefinition

	<bean id="" name="" class="" init-method=""  scope="" lazy-init="default" destroy-method="" >
		<property name=
 
"" ref=""></property>
	</bean>

1、常用的屬性

  • id：在IOC容器唯一標識，如果id重複，後面id的bean會覆蓋前面id的bean。
  • class：bean的class路徑
  • init-method：初始化方法，建立Bean後呼叫
  • scope：物件作用域，singleton（單例）、prototype(多例)。預設singleton
  • lazy-init：是否懶載入，使用該Bean的使用在初始化。false(否)、true(是)，預設false
  • destroy-method：銷燬方法，銷燬Bean後呼叫。
  • property：需要注入的屬性
  • name：bean的alias；如果沒有配置id，那麼id = name；如果id存在，那麼name只是一個alias；

2、儲存方式

  • xml

BeanDefinition解析器

BeanDefinitionReader：org.springframework.beans.factory.support.BeanDefinitionReader

當我們在xml定義了許多的<bean>標籤，需要一個工具去統一解析這些<bean>標籤，把這些<bean>標籤轉換成BeanDefinition，那麼這就是BeanDefinitionReader的工作

BeanDefinitionReader主要處理流程：

  1. 載入xml檔案
  2. 把xml檔案轉換成Document
  3. 解析Document成BeanDefinition
  4. 把BeanDefinition註冊到BeanDefinitionRegistry

Bean管理

當我們通過BeanDefinitionReader把所有的配置解析成一系列的BeanDefinition並且註冊到BeanDefinitionRegistry，那麼就需要一個容器，通過這些BeanDefinition去生成Bean，並且對Bean管理，那麼就是BeanFactory。

Spring我們常用的是DefaultListableBeanFactory：org.springframework.beans.factory.support.DefaultListableBeanFactory

主要作用

  1. Bean建立
  2. Bean儲存
  3. Bean獲取
  4. 自動完成依賴檢測與注入
  5. 獲取Bean的BeanDefinition
  6. 自動生成Bean

IOC簡單使用

這裡將會通過比較原始的2個Demo，去使用IOC，而不是使用ClassPathXmlApplicationContext

不使用XML配置建立Bean

public class BeanDefinitionReaderDemo {
    @Test
    public void testIOC(){
        // 建立BeanFactory
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();            
        // 建立BeanDefinition
        RootBeanDefinition beanDefinition = new RootBeanDefinition(IOCTestBean.class);  
        // 設定物件域為單例     
        beanDefinition.setScope(BeanDefinition.SCOPE_SINGLETON);       
        // 把BeanDefinition註冊到BeanFactory
        beanFactory.registerBeanDefinition("iocTest", beanDefinition);             
        // 從BeanFactory獲取Bean
        IOCTestBean iocTestBean = beanFactory.getBean("iocTest",IOCTestBean.class);
        iocTestBean.createBean();       
    }   
}
class IOCTestBean{
    public void createBean(){
        System.out.println("IOCTestBean.createBean()");
    }      
}

控制檯輸出： 在這裡插入圖片描述

使用XML配置建立Bean

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans.xsd">
          	
	<bean id="iocTest" class="com.dk.spring.IOCTestBean" />
</beans>

public class BeanDefinitionReaderDemo {
    @Test
    public void testIOC(){        
        // 建立BeanFactory
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();                      
        // 建立BeanDefinitionReader
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
        // 讀取xml配置檔案
        beanDefinitionReader.loadBeanDefinitions("classpath:applicationContext.xml");        
        // 從BeanFactory獲取Bean
        IOCTestBean iocTestBean = beanFactory.getBean("iocTest",IOCTestBean.class);
        iocTestBean.createBean();        
    }   
}
class IOCTestBean{
    public void createBean(){
        System.out.println("IOCTestBean.createBean()");
    }      
}

控制檯輸出： 在這裡插入圖片描述

使用XML配置建立Bean的原始碼解析

1、BeanDefinitionReader載入XML配置檔案，並且把BeanDefinition註冊到BeanFactory

 		// 建立BeanFactory
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();                      
        // 建立BeanDefinitionReader
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
        // 讀取xml配置檔案
        beanDefinitionReader.loadBeanDefinitions("classpath:applicationContext.xml");

1、XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

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

	protected AbstractBeanDefinitionReader(BeanDefinitionRegistry registry) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		this.registry = registry;

		// Determine ResourceLoader to use.
		if (this.registry instanceof ResourceLoader) {
			this.resourceLoader = (ResourceLoader) this.registry;
		}
		else {
			this.resourceLoader = new PathMatchingResourcePatternResolver();
		}

		// Inherit Environment if possible
		if (this.registry instanceof EnvironmentCapable) {
			this.environment = ((EnvironmentCapable) this.registry).getEnvironment();
		}
		else {
			this.environment = new StandardEnvironment();
		}
	}

建立了兩個物件，分別為

  • PathMatchingResourcePatternResolver，路徑解析器，主要用於把xml配置的路徑解析成Resource物件。
  • StandardEnvironment，配置環境物件，主要用於獲取JDK環境配置、系統環境配置；

2、XmlBeanDefinitionReader.loadBeanDefinitions(“classpath:applicationContext.xml”);

AbstractBeanDefinitionReader.java
	@Override
	public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(location, null);
	}

AbstractBeanDefinitionReader.java
		public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
		ResourceLoader resourceLoader = getResourceLoader();
		if (resourceLoader == null) {
			throw new BeanDefinitionStoreException(
					"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
		}

		if (resourceLoader instanceof ResourcePatternResolver) {
			// Resource pattern matching available.
			try {
				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
				int loadCount = loadBeanDefinitions(resources);
				if (actualResources != null) {
					for (Resource resource : resources) {
						actualResources.add(resource);
					}
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
				}
				return loadCount;
			}
			catch (IOException ex) {
				throw new BeanDefinitionStoreException(
						"Could not resolve bean definition resource pattern [" + location + "]", ex);
			}
		}
		else {
			// Can only load single resources by absolute URL.
			Resource resource = resourceLoader.getResource(location);
			int loadCount = loadBeanDefinitions(resource);
			if (actualResources != null) {
				actualResources.add(resource);
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
			}
			return loadCount;
		}
	}

在這裡插入圖片描述

把路徑location通過路徑解析器解析成Resouce物件，然後繼續呼叫loadBeanDefinitions(resources)

AbstractBeanDefinitionReader.java
	@Override
	public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
		Assert.notNull(resources, "Resource array must not be null");
		int counter = 0;
		for (Resource resource : resources) {
			counter += loadBeanDefinitions(resource);
		}
		return counter;
	}

XmlBeanDefinitionReader.java
	public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(new EncodedResource(resource));
	}

把Resource轉換成帶有編碼的EncodedResource物件

XmlBeanDefinitionReader.java

	private final ThreadLocal<Set<EncodedResource>> resourcesCurrentlyBeingLoaded =
			new NamedThreadLocal<Set<EncodedResource>>("XML bean definition resources currently being loaded");


	public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
		Assert.notNull(encodedResource, "EncodedResource must not be null");
		if (logger.isInfoEnabled()) {
			logger.info("Loading XML bean definitions from " + encodedResource.getResource());
		}

		Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
		if (currentResources == null) {
			currentResources = new HashSet<EncodedResource>(4);
			this.resourcesCurrentlyBeingLoaded.set(currentResources);
		}
		if (!currentResources.add(encodedResource)) {
			throw new BeanDefinitionStoreException(
					"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
		}
		try {
			InputStream inputStream = encodedResource.getResource().getInputStream();
			try {
				InputSource inputSource = new InputSource(inputStream);
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
				return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
			}
			finally {
				inputStream.close();
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException(
					"IOException parsing XML document from " + encodedResource.getResource(), ex);
		}
		finally {
			currentResources.remove(encodedResource);
			if (currentResources.isEmpty()) {
				this.resourcesCurrentlyBeingLoaded.remove();
			}
		}
	}

我們可以把上述拆分為幾個程式碼塊，然後依次分析

  • 獲取當前執行緒(ThreadLocal)正在載入resource的Set集合，如果當前resource在Set集合已經存在，那麼丟擲異常，說明當前resource正在被該執行緒載入；如果不存在，那麼加入Set集合，標記當前執行緒開始載入resource；
 		Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
		if (currentResources == null) {
			currentResources = new HashSet<EncodedResource>(4);
			this.resourcesCurrentlyBeingLoaded.set(currentResources);
		}
		if (!currentResources.add(encodedResource)) {
			throw new BeanDefinitionStoreException(
					"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
		}
  • 獲取該配置檔案的輸入流Inputstream物件，並且把它包裝成InputSource準備進行Java Dom XML解析，然後呼叫doLoadBeanDefinitions(inputSource, encodedResource.getResource());
try {
			InputStream inputStream = encodedResource.getResource().getInputStream();
			try {
				InputSource inputSource = new InputSource(inputStream);
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
				return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
			}
			finally {
				inputStream.close();
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException(
					"IOException parsing XML document from " + encodedResource.getResource(), ex);
		}
  • 最後全部完成，把當前resource成Set集合移除
			currentResources.remove(encodedResource);
			if (currentResources.isEmpty()) {
				this.resourcesCurrentlyBeingLoaded.remove();
			}

我們繼續看doLoadBeanDefinitions(inputSource, encodedResource.getResource())

XmlBeanDefinitionReader.java
	protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
		try {
			Document doc = doLoadDocument(inputSource, resource);
			return registerBeanDefinitions(doc, resource);
		}
		catch (BeanDefinitionStoreException ex) {
			throw ex;
		}
		catch (SAXParseException ex) {
			throw new XmlBeanDefinitionStoreException(resource.getDescription(),
					"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
		}
		catch (SAXException ex) {
			throw new XmlBeanDefinitionStoreException(resource.getDescription(),
					"XML document from " + resource + " is invalid", ex);
		}
		catch (ParserConfigurationException ex) {
			throw new BeanDefinitionStoreException(resource.getDescription(),
					"Parser configuration exception parsing XML from " + resource, ex);
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException(resource.getDescription(),
					"IOException parsing XML document from " + resource, ex);
		}
		catch (Throwable ex) {
			throw new BeanDefinitionStoreException(resource.getDescription(),
					"Unexpected exception parsing XML document from " + resource, ex);
		}
	}
  • 呼叫doLoadDocument(inputSource, resource)把inputSource通過JDK自帶的Dom技術，解析成Document文件樹 這裡為什麼使用Java自帶的Dom解析而不用Sax、Dom4J等一些開源的強大解析技術？我猜大概是使用Java自帶的，不用去解決一些相容問題，並且Spring配置檔案小的原因。
  • registerBeanDefinitions(doc, resource);把Document的每個Element解析成BeanDefinition，並且把BeanDefinition注入到BeanFactory
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		int countBefore = getRegistry().getBeanDefinitionCount();
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}
  • createBeanDefinitionDocumentReader()，建立一個用於解析Document的解析器
  • createReaderContext(resource)，把Resource包裝成XmlReaderContext物件，該物件具有XML NameSpace解析功能，並且具有XmlBeanDefinitionReader的引用。
  • documentReader.registerBeanDefinitions(doc, createReaderContext(resource));解析Docuemnt
	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		logger.debug("Loading bean definitions");
		Element root = doc.getDocumentElement();
		doRegisterBeanDefinitions(root);
	}
  • Element root = doc.getDocumentElement();獲取Document的根元素
  • doRegisterBeanDefinitions(root);從根元素開始解析XML配置檔案，並且註冊BeanDefinition
	protected void doRegisterBeanDefinitions(Element root) {
		BeanDefinitionParserDelegate parent = this.delegate;
		this.delegate = createDelegate(getReaderContext(), root, parent);

		if (this.delegate.isDefaultNamespace(root)) {
			String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
			if (StringUtils.hasText(profileSpec)) {
				String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
						profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
				if (!getReaderContext().getEnvironment().acceptsProfiles<

相關推薦

Spring4.x原始碼解析：IOC容器底層原理解析

引包 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans&

Mybaits 原始碼解析 （五）----- 面試原始碼系列：Mapper介面底層原理（為什麼Mapper不用寫實現類就能訪問到資料庫？）

剛開始使用Mybaits的同學有沒有這樣的疑惑，為什麼我們沒有編寫Mapper的實現類，卻能呼叫Mapper的方法呢？本篇文章我帶大家一起來解決這個疑問 上一篇文章我們獲取到了DefaultSqlSession，接著我們來看第一篇文章測試用例後面的程式碼 EmployeeMapper employee

Spring原始碼學習之IOC容器實現原理（一）-DefaultListableBeanFactory

從這個繼承體系結構圖來看，我們可以發現DefaultListableBeanFactory是第一個非抽象類，非介面類。實際IOC容器。所以這篇部落格以DefaultListableBeanFactoryIOC容器為基準進行IOC原理解析。 一.兩個重要介面 前面已經分析了BeanFactor，它的三個直接子

Spring原始碼解析--《SPRING技術內幕:深入解析Spring架構與設計原理》讀書筆記（一）：IOC容器初始化過程

通過閱讀相關章節內容，Spring中IOC容器的載入中，我們需要了解下列幾個概念： Resource：是一個定位、訪問資源的抽象介面，包含了多種資源操作的基礎方法定義，如getInputStream()、exists()、isOpen()、getD

Netty4.0原始碼解析：位元組容器UnpooledHeapByteBuf

一、引言 Java NIO提供了ByteBuffer作為位元組容器，供Channel讀入和寫入資料。但ByteBuffer使用過於繁瑣，靈活性不夠強。Netty實現了ByteBuf來替代JDK的ByteBuffer。 ByteBuf有以下幾大優點： 1、它可以被

spring原始碼解析之IOC容器（一）

　　學習優秀框架的原始碼，是提升個人技術水平必不可少的一個環節。如果只是停留在知道怎麼用，但是不懂其中的來龍去脈，在技術的道路上註定走不長遠。最近，學習了一段時間的spring原始碼，現在整理出來，以便日後溫故知新。 　　IOC容器是spring最核心的模組之一，是整個spring體系的基石，spring其

spring原始碼解析之IOC容器（二）------載入和註冊

　　上一篇跟蹤了IOC容器對配置檔案的定位，現在我們繼續跟蹤程式碼，看看IOC容器是怎麼載入和註冊配置檔案中的資訊的。開始之前，首先我們先來了解一下IOC容器所使用的資料結構-------BeanDefinition，它是一個上層介面，有很多實現類，分別對應不同的資料載體。我們平時開發的時候，也會定義很多po

spring原始碼解析之IOC容器（三）——依賴注入

　　上一篇主要是跟蹤了IOC容器對bean標籤進行解析之後存入Map中的過程，這些bean只是以BeanDefinition為載體單純的儲存起來了，並沒有轉換成一個個的物件，今天繼續進行跟蹤，看一看IOC容器是怎樣例項化物件的。 　　我們都使用過以下程式碼： 1 FileSystemXmlApplicati

支付寶客戶端架構解析：iOS 容器化框架初探

1. 前言 由本章節開始，我們將從支付寶客戶端的架構設計方案入手，細分拆解客戶端在“容器化框架設計”、“網路優化”、“效能啟動優化”、“自動化日誌收集”、“RPC 元件設計”、“移動應用監控、診斷、定位”等具體實現，帶領大家進一步瞭解支付寶在客戶端架構上的迭代與優化歷程。 本節將介紹支付寶 iOS 容器化

Spring中@Autowire的底層原理解析(附詳細原始碼閱讀步驟)

搭建原始碼閱讀環境 首先在IDEA中建立一個Maven工程，然後在pom.xml中加入依賴，因為以後可能會用到其他的功能，所以這裡直接使用的是springboot的依賴 <?xml version="1.0" encoding="UTF-8"?> <project

【spring原始碼分析】IOC容器初始化（二）

前言：在【spring原始碼分析】IOC容器初始化（一）中已經分析了匯入bean階段，本篇接著分析bean解析階段。 1.解析bean程式呼叫鏈 同樣，先給出解析bean的程式呼叫鏈： 根據程式呼叫鏈，整理出在解析bean過程中主要涉及的類和相關方法。 2.解析bean原始碼分

spring框架IOC容器和AOC解析

Spring框架IOC容器和AOP解析 主要分析點： 一、Spring開源框架的簡介  二、Spring下IOC容器和DI(依賴注入Dependency injection) 三、Spring下面向切面程式設計(A

Spring學習5（1）：IoC容器之IoC概述，JAVA反射機制，資源訪問器

spring學習5（1）  在經過了對spring框架基本開發的瞭解以及對spring boot流程的學習，《精通spring4.x…》這本書正式開始了spring的講解，我也跟隨著這本書的腳步進行學習。 IoC概述  首先需要學習的是spring的IoC技術，

Netty4.x原始碼分析：服務端接受客戶端Channel連線

引包 <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> &l

Spring原始碼剖析——核心IOC容器原理

IOC介紹   相信大多數人在學習Spring時 IOC 和 Bean 算得上是最常聽到的兩個名詞，IOC在學習Spring當中出現頻率如此之高必然有其原因。如果我們做一個比喻的話，把Bean說成Spring中主角的話，那麼IOC便是這個主角進行演出的舞臺,沒

spring beans原始碼解讀之 ioc容器之始祖--DefaultListableBeanFactory

spring Ioc容器的實現，從根源上是beanfactory，但真正可以作為一個可以獨立使用的ioc容器還是DefaultListableBeanFactory，因此可以這麼說， DefaultListableBeanFactory 是整個spring ioc的始祖，研究透它

Spring框架IOC容器和AOP解析

主要分析點： 一、Spring開源框架的簡介  二、Spring下IOC容器和DI(依賴注入Dependency injection) 三、Spring下面向切面程式設計(AOP)和事務管理配置  一、Spring開源框架的簡介  Spring是一個開源框架，

spring學習筆記：ioc容器高階特性

Spring容器的高階特性涉及到屬性編輯器，使用外部屬性檔案，國際化，容器事件等等; 今天講解一下屬性編輯器，使用外部資源，國際化。 屬性編輯器  如果你沒有了解過屬性編輯器，建議你先google一下，我簡單的解釋一下什麼是屬性編輯器，看一個新寫的有代表性的bean：pack

Spring MVC與Web環境(一)：IOC容器在Spring MVC中的啟動

            在原書的閱讀中我們可以看到，Spring並不是天生就能在Web容器中起作用的。我們同樣需要把我們的IoC容器手動新增到Web容器中，也就是在web.xml檔案中配置一些基礎的類比如DispatcherServlet,ContextLoaderListe

Spring5原始碼之IOC容器實現原理

1、 2、 3、定位、載入、註冊 定位：資源配置import，classpath，url 載入：解析配置檔案，把bean包裝成BeanDefinition物件 註冊：把已經初始化的BeanDefinition物件放到IOC容器中