Spring：源碼解讀Spring IOC原理
1、什麼是Ioc/DI？
IOC容器：主要是完成了 完成對象的建立和依賴的管理注入等。node
先從咱們本身設計這樣一個視角來考慮：web
所謂控制反轉，就是把原先咱們代碼裏面須要實現的 對象建立、依賴的代碼，反轉給容器來幫忙實現。那麼必然的1.咱們須要建立一個容器，2.同時須要一種描述來讓容器知道須要建立的對象與對象的關係。這個描述最具體表現就是咱們可配置的文件。spring
對象和對象關係怎麼表示？
能夠用xml、properties文件等語義化配置文件表示。編程
描述對象關係的文件存放在哪裏？
多是 classpath，fileSystem，或者是url網絡資源，servletContext等。設計模式
對配置文件的解析
不一樣的配置文件對對象的描述不同，如標準的，自定義聲明式的，如何統一？在內部須要有一個統一的關於對象的定義，全部外部的描述都必須轉化成爲統一的描述定義。數組
如何對不一樣的配置文件進行解析？須要對不一樣的配置文件語法，採用不一樣的解析器。緩存
Spring IOC 體系結構
Spring Bean的建立是典型的工廠模式，這一系列的Bean工廠，也既IOC容器爲開發者管理對象間的依賴關係提供了不少便利和基礎服務，在Spring中有許多的IOC容器的實現供用戶選擇和使用，其相互關係以下：安全
其中Beanfactory做爲最頂層的一個接口類，定義了IOC容器的基本功能規範，BeanFactory有三個子類：網絡
- Listable BeanFactory：這些Bean是可列表的
- Hierarchical BeanFactory：這些Bean是有繼承關係的，
- AutowireCapable BeanFactory：定義Bean的自動裝配規則。 這三個接口共同定義了 Bean的集合、Bean之間的關係、以及Bean行爲。
從上圖可發現最終的默認實現類是DefaultListableBeanFactory，他實現類全部的接口。數據結構
查看最基本的BeanFactory
public interface BeanFactory {
//對FactoryBean的轉義定義，由於若是使用bean的名字檢索FactoryBean獲得的對象是工廠生成的對象，
//若是須要獲得工廠自己，須要轉義
String FACTORY_BEAN_PREFIX = "&";
//根據bean的名字，獲取在IOC容器中獲得bean實例
Object getBean(String name) throws BeansException;
//根據bean的名字和Class類型來獲得bean實例，增長了類型安全驗證機制。
Object getBean(String name, Class requiredType) throws BeansException;
//提供對bean的檢索，看看是否在IOC容器有這個名字的bean
boolean containsBean(String name);
//根據bean名字獲得bean實例，並同時判斷這個bean是否是單例
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
//獲得bean實例的Class類型
Class getType(String name) throws NoSuchBeanDefinitionException;
//獲得bean的別名，若是根據別名檢索，那麼其原名也會被檢索出來
String[] getAliases(String name);
}
在BeanFactory裏只對IOC容器的最基本行爲做了定義，不關心你的bean是如何定義和怎樣加載的。正如咱們只關心工廠裏獲得什麼的產品對象，只要工廠是怎麼生產這些對象的，這個基本的接口不關心。
而要知道工廠是如何生產對象的，須要看IOC容器的實現，spring提供了許多IOC容器的實現，好比：
- XmlBeanFactory
- ClassPathxmlApplicationContext
其中XmlBeanFactory就是針對最基本的IOC容器的實現，這個IOC容器能夠讀取XML文件定義的BeanDefinition（Xml文件中對bean的描述），若是說XMLBeanFactory是容器中的屌絲，ApplicationContext 應該算是容器中的高富帥。
ApplicationContext是Spring提供的一個高級的IOC容器，它處理可以提供IOC容器的基本功能外，還爲用戶提供瞭如下的附加服務。從ApplicationContext接口的實現，能夠看出其特色。
- 支持信息源，能夠實現國際化。（實現MessageSource接口）
- 訪問資源。（實現ResourcePatternResolver接口）
- 支持應用事件。（實現ApplicationEventPublisher接口）
ApplicationContext（應用上下文）經常使用的應用上下文：
- AnnotationConfigApplicationContext：從一個或多個基於Java的配置類中加載Spring應用上下文。
- AnnotationConfigWebApplicationContext:從一個或多個基於Java的配置類中加載Spring Web 應用上下文。
- ClassPathXMLApplicationContext：從類路徑下的一個或多個xml配置文件中加載上下文定義，把應用上下文的定義文件做爲類資源。
- FileSystemXMlApplicationContext：從文件系統下的一個或多個XML配置文件中加載上下文定義。
- XMLWebApplicationContext：從web應用下的一個或多個xml配置文件中加載上下文定義。
BeanDefinition：Bean的對象
SpringIOC容器管理了咱們定義的各類Bean對象及其相互的關係，Bean對象在Spring實現中是以BeanDefinition來描述的，其繼承體系以下：
Bean的解析
Bean 的解析過程很是複雜，功能被分的很細，由於這裏須要被擴展的地方不少，必須保證有足夠的靈活性，以應對可能的變化。Bean的解析主要就是對Spring配置文件的解析。這個解析過程主要經過下圖中的類完成：
IOC容器的初始化
IOC容器的初始化包括 BeanDefinition的Resource定義，載入和註冊這桑基本的過程。咱們以ApplicationContext爲例講解。其繼承體系以下圖所示：
ApplicationContext容許上下文嵌套，經過保持父上下文能夠維持一個上下文體系。對於Bean的查找能夠在這個上下文體系中發生，首先檢查當前上下文，其次是父上下文，逐級向上，這樣爲不一樣的Spring應用提供了一個共享的Bean定義環境。
XMLBeanFactory（屌絲IOC）的整個流程
經過XmlBeanFactory源碼能夠發現：
public class XmlBeanFactory extends DefaultListableBeanFactory{
private final XmlBeanDefinitionReader reader;
public XmlBeanFactory(Resource resource)throws BeansException{
this(resource, null);
}
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory)
throws BeansException{
super(parentBeanFactory);
this.reader = new XmlBeanDefinitionReader(this);
this.reader.loadBeanDefinitions(resource);
}
}
//根據Xml配置文件建立Resource資源對象，該對象中包含了BeanDefinition的信息
ClassPathResource resource =new ClassPathResource("application-context.xml");
//建立DefaultListableBeanFactory
DefaultListableBeanFactory factory =new DefaultListableBeanFactory();
//建立XmlBeanDefinitionReader讀取器，用於載入BeanDefinition。之因此須要BeanFactory做爲參數，是由於會將讀取的信息回調配置給factory
XmlBeanDefinitionReader reader =new XmlBeanDefinitionReader(factory);
//XmlBeanDefinitionReader執行載入BeanDefinition的方法，最後會完成Bean的載入和註冊。完成後Bean就成功的放置到IOC容器當中，之後咱們就能夠從中取得Bean來使用
reader.loadBeanDefinitions(resource);
經過前面的源碼，this.reader = new XmlBeanDefinitionReader(this); 中其中this 傳的是factory對象
二、FileSystemXmlApplicationContext 的IOC容器流程
高富帥IOC剖解
1 ApplicationContext =new FileSystemXmlApplicationContext(xmlPath);
先看其構造函數：
/**
* Create a new FileSystemXmlApplicationContext, loading the definitions
* from the given XML files and automatically refreshing the context.
* @param configLocations array of file paths
* @throws BeansException if context creation failed
*/public FileSystemXmlApplicationContext(String... configLocations) throws BeansException {
this(configLocations, true, null);
}
實際調用
public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
throws BeansException {
super(parent);
setConfigLocations(configLocations);
if (refresh) {
refresh();
}
}
二、設置資源加載器和資源定位
經過分析FileSystemXmlApplicationContext的源代碼能夠知道，在建立FileSystemXmlApplicationContext容器時，構造方法作如下兩項重要工做：
首先，調用父類容器的構造方法(super(parent)方法)爲容器設置好Bean資源加載器。
而後，再調用父類AbstractRefreshableConfigApplicationContext的setConfigLocations(configLocations)方法設置Bean定義資源文件的定位路徑。
經過追蹤FileSystemXmlApplicationContext的繼承體系，發現其父類的父類AbstractApplicationContext中初始化IoC容器所作的主要源碼以下：
public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements ConfigurableApplicationContext, DisposableBean {
//靜態初始化塊，在整個容器建立過程當中只執行一次
static {
//爲了不應用程序在Weblogic8.1關閉時出現類加載異常加載問題，加載IoC容
//器關閉事件(ContextClosedEvent)類
ContextClosedEvent.class.getName();
}
//FileSystemXmlApplicationContext調用父類構造方法調用的就是該方法
public AbstractApplicationContext(ApplicationContext parent) {
this.parent = parent;
this.resourcePatternResolver = getResourcePatternResolver();
}
//獲取一個Spring Source的加載器用於讀入Spring Bean定義資源文件
protected ResourcePatternResolver getResourcePatternResolver() {
// AbstractApplicationContext繼承DefaultResourceLoader，也是一個S
//Spring資源加載器，其getResource(String location)方法用於載入資源
return new PathMatchingResourcePatternResolver(this);
}
……
}
AbstractApplicationContext構造方法中調用PathMatchingResourcePatternResolver的構造方法建立Spring資源加載器：
public PathMatchingResourcePatternResolver(ResourceLoader resourceLoader) {
Assert.notNull(resourceLoader, "ResourceLoader must not be null");
//設置Spring的資源加載器
this.resourceLoader = resourceLoader;
}
在設置容器的資源加載器以後，接下來FileSystemXmlApplicationContet執行setConfigLocations方法經過調用其父類AbstractRefreshableConfigApplicationContext的方法進行對Bean定義資源文件的定位，該方法的源碼以下：
//處理單個資源文件路徑爲一個字符串的狀況
public void setConfigLocation(String location) {
//String CONFIG_LOCATION_DELIMITERS = ",; /t/n";
//即多個資源文件路徑之間用」 ,; /t/n」分隔，解析成數組形式
setConfigLocations(StringUtils.tokenizeToStringArray(location, CONFIG_LOCATION_DELIMITERS));
}
//解析Bean定義資源文件的路徑，處理多個資源文件字符串數組
public void setConfigLocations(String[] locations) {
if (locations != null) {
Assert.noNullElements(locations, "Config locations must not be null");
this.configLocations = new String[locations.length];
for (int i = 0; i < locations.length; i++) {
// resolvePath爲同一個類中將字符串解析爲路徑的方法
this.configLocations[i] = resolvePath(locations[i]).trim();
}
}
else {
this.configLocations = null;
}
}
經過這兩個方法的源碼咱們能夠看出，咱們既可使用一個字符串來配置多個Spring Bean定義資源文件，也可使用字符串數組，即下面兩種方式都是能夠的：
a. ClasspathResource res = new ClasspathResource(「a.xml,b.xml,……」);
多個資源文件路徑之間能夠是用」 ,; /t/n」等分隔。
b. ClasspathResource res = new ClasspathResource(newString[]{「a.xml」,」b.xml」,……});
至此，Spring IoC容器在初始化時將配置的Bean定義資源文件定位爲Spring封裝的Resource。
三、AbstractApplicationContext的refresh函數載入Bean定義過程：
Spring IoC容器對Bean定義資源的載入是從refresh()函數開始的，refresh()是一個模板方法，refresh()方法的做用是：在建立IoC容器前，若是已經有容器存在，則須要把已有的容器銷燬和關閉，以保證在refresh以後使用的是新創建起來的IoC容器。refresh的做用相似於對IoC容器的重啓，在新創建好的容器中對容器進行初始化，對Bean定義資源進行載入
FileSystemXmlApplicationContext經過調用其父類AbstractApplicationContext的refresh()函數啓動整個IoC容器對Bean定義的載入過程：
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
//調用容器準備刷新的方法，獲取容器的當時時間，同時給容器設置同步標識
prepareRefresh();
//告訴子類啓動refreshBeanFactory()方法，Bean定義資源文件的載入從
//子類的refreshBeanFactory()方法啓動
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//爲BeanFactory配置容器特性，例如類加載器、事件處理器等
prepareBeanFactory(beanFactory);
try {
//爲容器的某些子類指定特殊的BeanPost事件處理器
postProcessBeanFactory(beanFactory);
//調用全部註冊的BeanFactoryPostProcessor的Bean
invokeBeanFactoryPostProcessors(beanFactory);
//爲BeanFactory註冊BeanPost事件處理器.
//BeanPostProcessor是Bean後置處理器，用於監聽容器觸發的事件
registerBeanPostProcessors(beanFactory);
//初始化信息源，和國際化相關.
initMessageSource();
//初始化容器事件傳播器.
initApplicationEventMulticaster();
//調用子類的某些特殊Bean初始化方法
onRefresh();
//爲事件傳播器註冊事件監聽器.
registerListeners();
//初始化全部剩餘的單態Bean.
finishBeanFactoryInitialization(beanFactory);
//初始化容器的生命週期事件處理器，併發布容器的生命週期事件
finishRefresh();
}
catch (BeansException ex) {
//銷燬以建立的單態Bean
destroyBeans();
//取消refresh操做，重置容器的同步標識.
cancelRefresh(ex);
throw ex;
}
}
}
refresh()方法主要爲IoC容器Bean的生命週期管理提供條件，Spring IoC容器載入Bean定義資源文件從其子類容器的refreshBeanFactory()方法啓動，因此整個refresh()中「ConfigurableListableBeanFactory beanFactory =obtainFreshBeanFactory();」這句之後代碼的都是註冊容器的信息源和生命週期事件，載入過程就是從這句代碼啓動。
refresh()方法的做用是：在建立IoC容器前，若是已經有容器存在，則須要把已有的容器銷燬和關閉，以保證在refresh以後使用的是新創建起來的IoC容器。refresh的做用相似於對IoC容器的重啓，在新創建好的容器中對容器進行初始化，對Bean定義資源進行載入
AbstractApplicationContext的obtainFreshBeanFactory()方法調用子類容器的refreshBeanFactory()方法，啓動容器載入Bean定義資源文件的過程，代碼以下：
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//這裏使用了委派設計模式，父類定義了抽象的refreshBeanFactory()方法，具體實現調用子類容器的refreshBeanFactory()方法
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
AbstractApplicationContext子類的refreshBeanFactory()方法：AbstractApplicationContext類中只抽象定義了refreshBeanFactory()方法，容器真正調用的是其子類AbstractRefreshableApplicationContext實現的 refreshBeanFactory()方法，方法的源碼以下：
protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) {//若是已經有容器，銷燬容器中的bean，關閉容器
destroyBeans();
closeBeanFactory();
}
try {
//建立IoC容器
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
//對IoC容器進行定製化，如設置啓動參數，開啓註解的自動裝配等
customizeBeanFactory(beanFactory);
//調用載入Bean定義的方法，主要這裏又使用了一個委派模式，在當前類中只定義了抽象的loadBeanDefinitions方法，具體的實現調用子類容器
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
在這個方法中，先判斷BeanFactory是否存在，若是存在則先銷燬beans並關閉beanFactory，接着建立DefaultListableBeanFactory，並調用loadBeanDefinitions(beanFactory)裝載bean定義。
五、AbstractRefreshableApplicationContext子類的loadBeanDefinitions方法：
AbstractRefreshableApplicationContext中只定義了抽象的loadBeanDefinitions方法，容器真正調用的是其子類AbstractXmlApplicationContext對該方法的實現，AbstractXmlApplicationContext的主要源碼以下：loadBeanDefinitions方法一樣是抽象方法，是由其子類實現的，也即在AbstractXmlApplicationContext中。
public abstract class AbstractXmlApplicationContext extends AbstractRefreshableConfigApplicationContext {
……
//實現父類抽象的載入Bean定義方法
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
//建立XmlBeanDefinitionReader，即建立Bean讀取器，並經過回調設置到容器中去，容 器使用該讀取器讀取Bean定義資源
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
//爲Bean讀取器設置Spring資源加載器，AbstractXmlApplicationContext的
//祖先父類AbstractApplicationContext繼承DefaultResourceLoader，所以，容器自己也是一個資源加載器
beanDefinitionReader.setResourceLoader(this);
//爲Bean讀取器設置SAX xml解析器
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
//當Bean讀取器讀取Bean定義的Xml資源文件時，啓用Xml的校驗機制
initBeanDefinitionReader(beanDefinitionReader);
//Bean讀取器真正實現加載的方法
loadBeanDefinitions(beanDefinitionReader);
}
//Xml Bean讀取器加載Bean定義資源
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
//獲取Bean定義資源的定位
Resource[] configResources = getConfigResources();
if (configResources != null) {
//Xml Bean讀取器調用其父類AbstractBeanDefinitionReader讀取定位
//的Bean定義資源
reader.loadBeanDefinitions(configResources);
}
//若是子類中獲取的Bean定義資源定位爲空，則獲取FileSystemXmlApplicationContext構造方法中setConfigLocations方法設置的資源
String[] configLocations = getConfigLocations();
if (configLocations != null) {
//Xml Bean讀取器調用其父類AbstractBeanDefinitionReader讀取定位
//的Bean定義資源
reader.loadBeanDefinitions(configLocations);
}
}
//這裏又使用了一個委託模式，調用子類的獲取Bean定義資源定位的方法
//該方法在ClassPathXmlApplicationContext中進行實現，對於咱們
//舉例分析源碼的FileSystemXmlApplicationContext沒有使用該方法
protected Resource[] getConfigResources() {
return null;
} ……
41}
Xml Bean讀取器(XmlBeanDefinitionReader)調用其父類AbstractBeanDefinitionReader的 reader.loadBeanDefinitions方法讀取Bean定義資源。因爲咱們使用FileSystemXmlApplicationContext做爲例子分析，所以getConfigResources的返回值爲null，所以程序執行reader.loadBeanDefinitions(configLocations)分支。
六、AbstractBeanDefinitionReader讀取Bean定義資源：
AbstractBeanDefinitionReader的loadBeanDefinitions方法源碼以下： 能夠到org.springframework.beans.factory.support看一下BeanDefinitionReader的結構
在其抽象父類AbstractBeanDefinitionReader中定義了載入過程
//重載方法，調用下面的loadBeanDefinitions(String, Set<Resource>);方法
public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
return loadBeanDefinitions(location, null);
}
public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
//獲取在IoC容器初始化過程當中設置的資源加載器
ResourceLoader resourceLoader = getResourceLoader();
if (resourceLoader == null) {
throw new BeanDefinitionStoreException(
"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
}
if (resourceLoader instanceof ResourcePatternResolver) {
try {
//將指定位置的Bean定義資源文件解析爲Spring IoC容器封裝的資源
//加載多個指定位置的Bean定義資源文件
Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
//委派調用其子類XmlBeanDefinitionReader的方法，實現加載功能
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 {
//將指定位置的Bean定義資源文件解析爲Spring IoC容器封裝的資源
//加載單個指定位置的Bean定義資源文件
Resource resource = resourceLoader.getResource(location);
//委派調用其子類XmlBeanDefinitionReader的方法，實現加載功能
int loadCount = loadBeanDefinitions(resource);
if (actualResources != null) {
actualResources.add(resource);
}
if (logger.isDebugEnabled()) {
logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
}
return loadCount;
}
}
//重載方法，調用loadBeanDefinitions(String);
public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
Assert.notNull(locations, "Location array must not be null");
int counter = 0;
for (String location : locations) {
counter += loadBeanDefinitions(location);
}
return counter;
}
loadBeanDefinitions(Resource...resources)方法和上面分析的3個方法相似，一樣也是調用XmlBeanDefinitionReader的loadBeanDefinitions方法。
從對AbstractBeanDefinitionReader的loadBeanDefinitions方法源碼分析能夠看出該方法作了如下兩件事：
首先，調用資源加載器的獲取資源方法resourceLoader.getResource(location)，獲取到要加載的資源。
其次，真正執行加載功能是其子類XmlBeanDefinitionReader的loadBeanDefinitions方法。
看到第八、16行，結合上面的ResourceLoader與ApplicationContext的繼承關係圖，能夠知道此時調用的是DefaultResourceLoader中的getSource()方法定位Resource，由於FileSystemXmlApplicationContext自己就是DefaultResourceLoader的實現類，因此此時又回到了FileSystemXmlApplicationContext中來。
七、資源加載器獲取要讀入的資源：
XmlBeanDefinitionReader經過調用其父類DefaultResourceLoader的getResource方法獲取要加載的資源，其源碼以下
//獲取Resource的具體實現方法
public Resource getResource(String location) {
Assert.notNull(location, "Location must not be null");
//若是是類路徑的方式，那須要使用ClassPathResource 來獲得bean 文件的資源對象
if (location.startsWith(CLASSPATH_URL_PREFIX)) {
return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
}
try {
// 若是是URL 方式，使用UrlResource 做爲bean 文件的資源對象
URL url = new URL(location);
return new UrlResource(url);
}
catch (MalformedURLException ex) {
}
//若是既不是classpath標識，又不是URL標識的Resource定位，則調用
//容器自己的getResourceByPath方法獲取Resource
return getResourceByPath(location);
}
FileSystemXmlApplicationContext容器提供了getResourceByPath方法的實現，就是爲了處理既不是classpath標識，又不是URL標識的Resource定位這種狀況。
protected Resource getResourceByPath(String path) {
if (path != null && path.startsWith("/")) {
path = path.substring(1);
}
//這裏使用文件系統資源對象來定義bean 文件
return new FileSystemResource(path);
}
這樣代碼就回到了 FileSystemXmlApplicationContext 中來，他提供了FileSystemResource 來完成從文件系統獲得配置文件的資源定義。
這樣，就能夠從文件系統路徑上對IOC 配置文件進行加載 - 固然咱們能夠按照這個邏輯從任何地方加載，在Spring 中咱們看到它提供 的各類資源抽象，好比ClassPathResource, URLResource,FileSystemResource 等來供咱們使用。上面咱們看到的是定位Resource 的一個過程，而這只是加載過程的一部分.
八、XmlBeanDefinitionReader加載Bean定義資源：
Bean定義的Resource獲得了， 繼續回到XmlBeanDefinitionReader的loadBeanDefinitions(Resource …)方法看到表明bean文件的資源定義之後的載入過程。
//XmlBeanDefinitionReader加載資源的入口方法
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
//將讀入的XML資源進行特殊編碼處理
return loadBeanDefinitions(new EncodedResource(resource));
}
//這裏是載入XML形式Bean定義資源文件方法
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
.......
try {
//將資源文件轉爲InputStream的IO流
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
//從InputStream中獲得XML的解析源
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
//這裏是具體的讀取過程
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
finally {
//關閉從Resource中獲得的IO流
inputStream.close();
}
}
.........
26}
//從特定XML文件中實際載入Bean定義資源的方法
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
try {
int validationMode = getValidationModeForResource(resource);
//將XML文件轉換爲DOM對象，解析過程由documentLoader實現
Document doc = this.documentLoader.loadDocument(
inputSource, this.entityResolver, this.errorHandler, validationMode, this.namespaceAware);
//這裏是啓動對Bean定義解析的詳細過程，該解析過程會用到Spring的Bean配置規則
return registerBeanDefinitions(doc, resource);
}
.......
}
經過源碼分析，載入Bean定義資源文件的最後一步是將Bean定義資源轉換爲Document對象，該過程由documentLoader實現
九、DocumentLoader將Bean定義資源轉換爲Document對象：
DocumentLoader將Bean定義資源轉換成Document對象的源碼以下：
//使用標準的JAXP將載入的Bean定義資源轉換成document對象
public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {
//建立文件解析器工廠
DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
if (logger.isDebugEnabled()) {
logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]");
}
//建立文檔解析器
DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
//解析Spring的Bean定義資源
return builder.parse(inputSource);
}
protected DocumentBuilderFactory createDocumentBuilderFactory(int validationMode, boolean namespaceAware)
throws ParserConfigurationException {
//建立文檔解析工廠
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(namespaceAware);
//設置解析XML的校驗
if (validationMode != XmlValidationModeDetector.VALIDATION_NONE) {
factory.setValidating(true);
if (validationMode == XmlValidationModeDetector.VALIDATION_XSD) {
factory.setNamespaceAware(true);
try {
factory.setAttribute(SCHEMA_LANGUAGE_ATTRIBUTE, XSD_SCHEMA_LANGUAGE);
}
catch (IllegalArgumentException ex) {
ParserConfigurationException pcex = new ParserConfigurationException(
"Unable to validate using XSD: Your JAXP provider [" + factory +
"] does not support XML Schema. Are you running on Java 1.4 with Apache Crimson? " +
"Upgrade to Apache Xerces (or Java 1.5) for full XSD support.");
pcex.initCause(ex);
throw pcex;
}
}
}
return factory;
}
該解析過程調用JavaEE標準的JAXP標準進行處理。
至此Spring IoC容器根據定位的Bean定義資源文件，將其加載讀入並轉換成爲Document對象過程完成。
接下來咱們要繼續分析Spring IoC容器將載入的Bean定義資源文件轉換爲Document對象以後，是如何將其解析爲Spring IoC管理的Bean對象並將其註冊到容器中的。
十、XmlBeanDefinitionReader解析載入的Bean定義資源文件：
XmlBeanDefinitionReader類中的doLoadBeanDefinitions方法是從特定XML文件中實際載入Bean定義資源的方法，該方法在載入Bean定義資源以後將其轉換爲Document對象，接下來調用registerBeanDefinitions啓動Spring IoC容器對Bean定義的解析過程，registerBeanDefinitions方法源碼以下：
//按照Spring的Bean語義要求將Bean定義資源解析並轉換爲容器內部數據結構
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
//獲得BeanDefinitionDocumentReader來對xml格式的BeanDefinition解析
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
//得到容器中註冊的Bean數量
int countBefore = getRegistry().getBeanDefinitionCount();
//解析過程入口，這裏使用了委派模式，BeanDefinitionDocumentReader只是個接口，//具體的解析實現過程有實現類DefaultBeanDefinitionDocumentReader完成
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
//統計解析的Bean數量
return getRegistry().getBeanDefinitionCount() - countBefore;
}
//建立BeanDefinitionDocumentReader對象，解析Document對象
protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {
return BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass(this.documentReaderClass));
}
Bean定義資源的載入解析分爲如下兩個過程：
首先，經過調用XML解析器將Bean定義資源文件轉換獲得Document對象，可是這些Document對象並無按照Spring的Bean規則進行解析。這一步是載入的過程
其次，在完成通用的XML解析以後，按照Spring的Bean規則對Document對象進行解析。
按照Spring的Bean規則對Document對象解析的過程是在接口BeanDefinitionDocumentReader的實現類DefaultBeanDefinitionDocumentReader中實現的。
十一、DefaultBeanDefinitionDocumentReader對Bean定義的Document對象解析：
BeanDefinitionDocumentReader接口經過registerBeanDefinitions方法調用其實現類DefaultBeanDefinitionDocumentReader對Document對象進行解析，解析的代碼以下：
//根據Spring DTD對Bean的定義規則解析Bean定義Document對象
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
//得到XML描述符
this.readerContext = readerContext;
logger.debug("Loading bean definitions");
//得到Document的根元素
Element root = doc.getDocumentElement();
//具體的解析過程由BeanDefinitionParserDelegate實現，
//BeanDefinitionParserDelegate中定義了Spring Bean定義XML文件的各類元素
BeanDefinitionParserDelegate delegate = createHelper(readerContext, root);
//在解析Bean定義以前，進行自定義的解析，加強解析過程的可擴展性
preProcessXml(root);
//從Document的根元素開始進行Bean定義的Document對象
parseBeanDefinitions(root, delegate);
//在解析Bean定義以後，進行自定義的解析，增長解析過程的可擴展性
postProcessXml(root);
}
//建立BeanDefinitionParserDelegate，用於完成真正的解析過程
protected BeanDefinitionParserDelegate createHelper(XmlReaderContext readerContext, Element root) {
BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);
//BeanDefinitionParserDelegate初始化Document根元素
delegate.initDefaults(root);
return delegate;
}
//使用Spring的Bean規則從Document的根元素開始進行Bean定義的Document對象
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
//Bean定義的Document對象使用了Spring默認的XML命名空間
if (delegate.isDefaultNamespace(root)) {
//獲取Bean定義的Document對象根元素的全部子節點
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
//得到Document節點是XML元素節點
if (node instanceof Element) {
Element ele = (Element) node;
//Bean定義的Document的元素節點使用的是Spring默認的XML命名空間
if (delegate.isDefaultNamespace(ele)) {
//使用Spring的Bean規則解析元素節點
parseDefaultElement(ele, delegate);
}
else {
//沒有使用Spring默認的XML命名空間，則使用用戶自定義的解//析規則解析元素節點
delegate.parseCustomElement(ele);
}
}
}
}
else {
//Document的根節點沒有使用Spring默認的命名空間，則使用用戶自定義的
//解析規則解析Document根節點
delegate.parseCustomElement(root);
}
}
//使用Spring的Bean規則解析Document元素節點
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
//若是元素節點是<Import>導入元素，進行導入解析
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
//若是元素節點是<Alias>別名元素，進行別名解析
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
//元素節點既不是導入元素，也不是別名元素，即普通的<Bean>元素，
//按照Spring的Bean規則解析元素
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
}
//解析<Import>導入元素，從給定的導入路徑加載Bean定義資源到Spring IoC容器中
protected void importBeanDefinitionResource(Element ele) {
//獲取給定的導入元素的location屬性
String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
//若是導入元素的location屬性值爲空，則沒有導入任何資源，直接返回
if (!StringUtils.hasText(location)) {
getReaderContext().error("Resource location must not be empty", ele);
return;
}
//使用系統變量值解析location屬性值
location = SystemPropertyUtils.resolvePlaceholders(location);
Set<Resource> actualResources = new LinkedHashSet<Resource>(4);
//標識給定的導入元素的location是不是絕對路徑
boolean absoluteLocation = false;
try {
absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
}
catch (URISyntaxException ex) {
//給定的導入元素的location不是絕對路徑
}
//給定的導入元素的location是絕對路徑
if (absoluteLocation) {
try {
//使用資源讀入器加載給定路徑的Bean定義資源
int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
if (logger.isDebugEnabled()) {
logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]");
}
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error(
"Failed to import bean definitions from URL location [" + location + "]", ele, ex);
}
}
else {
//給定的導入元素的location是相對路徑
try {
int importCount;
//將給定導入元素的location封裝爲相對路徑資源
Resource relativeResource = getReaderContext().getResource().createRelative(location);
//封裝的相對路徑資源存在
if (relativeResource.exists()) {
//使用資源讀入器加載Bean定義資源
importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
actualResources.add(relativeResource);
}
//封裝的相對路徑資源不存在
else {
//獲取Spring IoC容器資源讀入器的基本路徑
String baseLocation = getReaderContext().getResource().getURL().toString();
//根據Spring IoC容器資源讀入器的基本路徑加載給定導入
//路徑的資源
importCount = getReaderContext().getReader().loadBeanDefinitions(
StringUtils.applyRelativePath(baseLocation, location), actualResources);
}
if (logger.isDebugEnabled()) {
logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]");
}
}
catch (IOException ex) {
getReaderContext().error("Failed to resolve current resource location", ele, ex);
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]",
ele, ex);
}
}
Resource[] actResArray = actualResources.toArray(new Resource[actualResources.size()]);
//在解析完<Import>元素以後，發送容器導入其餘資源處理完成事件
getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}
//解析<Alias>別名元素，爲Bean向Spring IoC容器註冊別名
protected void processAliasRegistration(Element ele) {
//獲取<Alias>別名元素中name的屬性值
String name = ele.getAttribute(NAME_ATTRIBUTE);
//獲取<Alias>別名元素中alias的屬性值
String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
boolean valid = true;
//<alias>別名元素的name屬性值爲空
if (!StringUtils.hasText(name)) {
getReaderContext().error("Name must not be empty", ele);
valid = false;
}
//<alias>別名元素的alias屬性值爲空
if (!StringUtils.hasText(alias)) {
getReaderContext().error("Alias must not be empty", ele);
valid = false;
}
if (valid) {
try {
//向容器的資源讀入器註冊別名
getReaderContext().getRegistry().registerAlias(name, alias);
}
catch (Exception ex) {
getReaderContext().error("Failed to register alias '" + alias +
"' for bean with name '" + name + "'", ele, ex);
}
//在解析完<Alias>元素以後，發送容器別名處理完成事件
getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
}
}
//解析Bean定義資源Document對象的普通元素
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// BeanDefinitionHolder是對BeanDefinition的封裝，即Bean定義的封裝類
//對Document對象中<Bean>元素的解析由BeanDefinitionParserDelegate實現 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
//向Spring IoC容器註冊解析獲得的Bean定義，這是Bean定義向IoC容器註冊的入口
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
//在完成向Spring IoC容器註冊解析獲得的Bean定義以後，發送註冊事件
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
經過上述Spring IoC容器對載入的Bean定義Document解析能夠看出，咱們使用Spring時，在Spring配置文件中可使用<Import>元素來導入IoC容器所須要的其餘資源，Spring IoC容器在解析時會首先將指定導入的資源加載進容器中。使用<Ailas>別名時，Spring IoC容器首先將別名元素所定義的別名註冊到容器中。
對於既不是<Import>元素，又不是<Alias>元素的元素，即Spring配置文件中普通的<Bean>元素的解析由BeanDefinitionParserDelegate類的parseBeanDefinitionElement方法來實現。
十二、BeanDefinitionParserDelegate解析Bean定義資源文件中的<Bean>元素：
Bean定義資源文件中的<Import>和<Alias>元素解析在DefaultBeanDefinitionDocumentReader中已經完成，對Bean定義資源文件中使用最多的<Bean>元素交由BeanDefinitionParserDelegate來解析，其解析實現的源碼以下：
//解析<Bean>元素的入口
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
return parseBeanDefinitionElement(ele, null);
}
//解析Bean定義資源文件中的<Bean>元素，這個方法中主要處理<Bean>元素的id，name
//和別名屬性
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
//獲取<Bean>元素中的id屬性值
String id = ele.getAttribute(ID_ATTRIBUTE);
//獲取<Bean>元素中的name屬性值
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
////獲取<Bean>元素中的alias屬性值
List<String> aliases = new ArrayList<String>();
//將<Bean>元素中的全部name屬性值存放到別名中
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, BEAN_NAME_DELIMITERS);
aliases.addAll(Arrays.asList(nameArr));
}
String beanName = id;
//若是<Bean>元素中沒有配置id屬性時，將別名中的第一個值賦值給beanName
if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
beanName = aliases.remove(0);
if (logger.isDebugEnabled()) {
logger.debug("No XML 'id' specified - using '" + beanName +
"' as bean name and " + aliases + " as aliases");
}
}
//檢查<Bean>元素所配置的id或者name的惟一性，containingBean標識<Bean>
//元素中是否包含子<Bean>元素
if (containingBean == null) {
//檢查<Bean>元素所配置的id、name或者別名是否重複
checkNameUniqueness(beanName, aliases, ele);
}
//詳細對<Bean>元素中配置的Bean定義進行解析的地方
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null) {
if (!StringUtils.hasText(beanName)) {
try {
if (containingBean != null) {
//若是<Bean>元素中沒有配置id、別名或者name，且沒有包含子//<Bean>元素，爲解析的Bean生成一個惟一beanName並註冊
beanName = BeanDefinitionReaderUtils.generateBeanName(
beanDefinition, this.readerContext.getRegistry(), true);
}
else {
//若是<Bean>元素中沒有配置id、別名或者name，且包含了子//<Bean>元素，爲解析的Bean使用別名向IoC容器註冊
beanName = this.readerContext.generateBeanName(beanDefinition);
//爲解析的Bean使用別名註冊時，爲了向後兼容 //Spring1.2/2.0，給別名添加類名後綴
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);
}
//當解析出錯時，返回null
return null;
}
//詳細對<Bean>元素中配置的Bean定義其餘屬性進行解析，因爲上面的方法中已經對//Bean的id、name和別名等屬性進行了處理，該方法中主要處理除這三個之外的其餘屬性數據
public AbstractBeanDefinition parseBeanDefinitionElement(
Element ele, String beanName, BeanDefinition containingBean) {
//記錄解析的<Bean>
this.parseState.push(new BeanEntry(beanName));
//這裏只讀取<Bean>元素中配置的class名字，而後載入到BeanDefinition中去
//只是記錄配置的class名字，不作實例化，對象的實例化在依賴注入時完成
String className = null;
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
try {
String parent = null;
//若是<Bean>元素中配置了parent屬性，則獲取parent屬性的值
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
//根據<Bean>元素配置的class名稱和parent屬性值建立BeanDefinition
//爲載入Bean定義信息作準備
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
//對當前的<Bean>元素中配置的一些屬性進行解析和設置，如配置的單態(singleton)屬性等
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
//爲<Bean>元素解析的Bean設置description信息 bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
//對<Bean>元素的meta(元信息)屬性解析
parseMetaElements(ele, bd);
//對<Bean>元素的lookup-method屬性解析
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
//對<Bean>元素的replaced-method屬性解析
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
//解析<Bean>元素的構造方法設置
parseConstructorArgElements(ele, bd);
//解析<Bean>元素的<property>設置
parsePropertyElements(ele, bd);
//解析<Bean>元素的qualifier屬性
parseQualifierElements(ele, bd);
//爲當前解析的Bean設置所需的資源和依賴對象
bd.setResource(this.readerContext.getResource());
bd.setSource(extractSource(ele));
return bd;
}
catch (ClassNotFoundException ex) {
error("Bean class [" + className + "] not found", ele, ex);
}
catch (NoClassDefFoundError err) {
error("Class that bean class [" + className + "] depends on not found", ele, err);
}
catch (Throwable ex) {
error("Unexpected failure during bean definition parsing", ele, ex);
}
finally {
this.parseState.pop();
}
//解析<Bean>元素出錯時，返回null
return null;
}
只要使用過Spring，對Spring配置文件比較熟悉的人，經過對上述源碼的分析，就會明白咱們在Spring配置文件中<Bean>元素的中配置的屬性就是經過該方法解析和設置到Bean中去的。
注意：在解析<Bean>元素過程當中沒有建立和實例化Bean對象，只是建立了Bean對象的定義類BeanDefinition，將<Bean>元素中的配置信息設置到BeanDefinition中做爲記錄，當依賴注入時才使用這些記錄信息建立和實例化具體的Bean對象。
上面方法中一些對一些配置如元信息(meta)、qualifier等的解析，咱們在Spring中配置時使用的也很少，咱們在使用Spring的<Bean>元素時，配置最多的是<property>屬性，所以咱們下面繼續分析源碼，瞭解Bean的屬性在解析時是如何設置的。
1三、BeanDefinitionParserDelegate解析<property>元素：
BeanDefinitionParserDelegate在解析<Bean>調用parsePropertyElements方法解析<Bean>元素中的<property>屬性子元素，解析源碼以下：
//解析<Bean>元素中的<property>子元素
public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
//獲取<Bean>元素中全部的子元素
NodeList nl = beanEle.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
//若是子元素是<property>子元素，則調用解析<property>子元素方法解析
if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
parsePropertyElement((Element) node, bd);
}
}
}
//解析<property>元素
public void parsePropertyElement(Element ele, BeanDefinition bd) {
//獲取<property>元素的名字
String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
if (!StringUtils.hasLength(propertyName)) {
error("Tag 'property' must have a 'name' attribute", ele);
return;
}
this.parseState.push(new PropertyEntry(propertyName));
try {
//若是一個Bean中已經有同名的property存在，則不進行解析，直接返回。
//即若是在同一個Bean中配置同名的property，則只有第一個起做用
if (bd.getPropertyValues().contains(propertyName)) {
error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
return;
}
//解析獲取property的值
Object val = parsePropertyValue(ele, bd, propertyName);
//根據property的名字和值建立property實例
PropertyValue pv = new PropertyValue(propertyName, val);
//解析<property>元素中的屬性
parseMetaElements(ele, pv);
pv.setSource(extractSource(ele));
bd.getPropertyValues().addPropertyValue(pv);
}
finally {
this.parseState.pop();
}
}
//解析獲取property值
public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {
String elementName = (propertyName != null) ?
"<property> element for property '" + propertyName + "'" :
"<constructor-arg> element";
//獲取<property>的全部子元素，只能是其中一種類型:ref,value,list等
NodeList nl = ele.getChildNodes();
Element subElement = null;
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
//子元素不是description和meta屬性
if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
!nodeNameEquals(node, META_ELEMENT)) {
if (subElement != null) {
error(elementName + " must not contain more than one sub-element", ele);
}
else {//當前<property>元素包含有子元素
subElement = (Element) node;
}
}
}
//判斷property的屬性值是ref仍是value，不容許既是ref又是value
boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
if ((hasRefAttribute && hasValueAttribute) ||
((hasRefAttribute || hasValueAttribute) && subElement != null)) {
error(elementName +
" is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
}
//若是屬性是ref，建立一個ref的數據對象RuntimeBeanReference，這個對象
//封裝了ref信息
if (hasRefAttribute) {
String refName = ele.getAttribute(REF_ATTRIBUTE);
if (!StringUtils.hasText(refName)) {
error(elementName + " contains empty 'ref' attribute", ele);
}
//一個指向運行時所依賴對象的引用
RuntimeBeanReference ref = new RuntimeBeanReference(refName);
//設置這個ref的數據對象是被當前的property對象所引用
ref.setSource(extractSource(ele));
return ref;
}
//若是屬性是value，建立一個value的數據對象TypedStringValue，這個對象
//封裝了value信息
else if (hasValueAttribute) {
//一個持有String類型值的對象
TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
//設置這個value數據對象是被當前的property對象所引用
valueHolder.setSource(extractSource(ele));
return valueHolder;
}
//若是當前<property>元素還有子元素
else if (subElement != null) {
//解析<property>的子元素
return parsePropertySubElement(subElement, bd);
}
else {
//propery屬性中既不是ref，也不是value屬性，解析出錯返回null error(elementName + " must specify a ref or value", ele);
return null;
}
}
經過對上述源碼的分析，咱們能夠了解在Spring配置文件中，<Bean>元素中<property>元素的相關配置是如何處理的：
a. ref被封裝爲指向依賴對象一個引用。
b.value配置都會封裝成一個字符串類型的對象。
c.ref和value都經過「解析的數據類型屬性值.setSource(extractSource(ele));」方法將屬性值/引用與所引用的屬性關聯起來。
在方法的最後對於<property>元素的子元素經過parsePropertySubElement 方法解析，咱們繼續分析該方法的源碼，瞭解其解析過程。
1四、解析<property>元素的子元素：
在BeanDefinitionParserDelegate類中的parsePropertySubElement方法對<property>中的子元素解析，源碼以下：
//解析<property>元素中ref,value或者集合等子元素
public Object parsePropertySubElement(Element ele, BeanDefinition bd, String defaultValueType) {
//若是<property>沒有使用Spring默認的命名空間，則使用用戶自定義的規則解析//內嵌元素
if (!isDefaultNamespace(ele)) {
return parseNestedCustomElement(ele, bd);
}
//若是子元素是bean，則使用解析<Bean>元素的方法解析
else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
if (nestedBd != null) {
nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
}
return nestedBd;
}
//若是子元素是ref，ref中只能有如下3個屬性：bean、local、parent
else if (nodeNameEquals(ele, REF_ELEMENT)) {
//獲取<property>元素中的bean屬性值，引用其餘解析的Bean的名稱
//能夠再也不同一個Spring配置文件中，具體請參考Spring對ref的配置規則
String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
boolean toParent = false;
if (!StringUtils.hasLength(refName)) {
//獲取<property>元素中的local屬性值，引用同一個Xml文件中配置
//的Bean的id，local和ref不一樣，local只能引用同一個配置文件中的Bean
refName = ele.getAttribute(LOCAL_REF_ATTRIBUTE);
if (!StringUtils.hasLength(refName)) {
//獲取<property>元素中parent屬性值，引用父級容器中的Bean
refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);
toParent = true;
if (!StringUtils.hasLength(refName)) {
error("'bean', 'local' or 'parent' is required for <ref> element", ele);
return null;
}
}
}
//沒有配置ref的目標屬性值
if (!StringUtils.hasText(refName)) {
error("<ref> element contains empty target attribute", ele);
return null;
}
//建立ref類型數據，指向被引用的對象
RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
//設置引用類型值是被當前子元素所引用
ref.setSource(extractSource(ele));
return ref;
}
//若是子元素是<idref>，使用解析ref元素的方法解析
else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
return parseIdRefElement(ele);
}
//若是子元素是<value>，使用解析value元素的方法解析
else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
return parseValueElement(ele, defaultValueType);
}
//若是子元素是null，爲<property>設置一個封裝null值的字符串數據
else if (nodeNameEquals(ele, NULL_ELEMENT)) {
TypedStringValue nullHolder = new TypedStringValue(null);
nullHolder.setSource(extractSource(ele));
return nullHolder;
}
//若是子元素是<array>，使用解析array集合子元素的方法解析
else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
return parseArrayElement(ele, bd);
}
//若是子元素是<list>，使用解析list集合子元素的方法解析
else if (nodeNameEquals(ele, LIST_ELEMENT)) {
return parseListElement(ele, bd);
}
//若是子元素是<set>，使用解析set集合子元素的方法解析
else if (nodeNameEquals(ele, SET_ELEMENT)) {
return parseSetElement(ele, bd);
}
//若是子元素是<map>，使用解析map集合子元素的方法解析
else if (nodeNameEquals(ele, MAP_ELEMENT)) {
return parseMapElement(ele, bd);
}
//若是子元素是<props>，使用解析props集合子元素的方法解析
else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
return parsePropsElement(ele);
}
//既不是ref，又不是value，也不是集合，則子元素配置錯誤，返回null
else {
error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
return null;
}
}
經過上述源碼分析，咱們明白了在Spring配置文件中，對<property>元素中配置的Array、List、Set、Map、Prop等各類集合子元素的都經過上述方法解析，生成對應的數據對象，好比ManagedList、ManagedArray、ManagedSet等，這些Managed類是Spring對象BeanDefiniton的數據封裝，對集合數據類型的具體解析有各自的解析方法實現，解析方法的命名很是規範，一目瞭然，咱們對<list>集合元素的解析方法進行源碼分析，瞭解其實現過程。
1五、解析<list>子元素：
在BeanDefinitionParserDelegate類中的parseListElement方法就是具體實現解析<property>元素中的<list>集合子元素，源碼以下：
//解析<list>集合子元素
public List parseListElement(Element collectionEle, BeanDefinition bd) {
//獲取<list>元素中的value-type屬性，即獲取集合元素的數據類型
String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE);
//獲取<list>集合元素中的全部子節點
NodeList nl = collectionEle.getChildNodes();
//Spring中將List封裝爲ManagedList
ManagedList<Object> target = new ManagedList<Object>(nl.getLength());
target.setSource(extractSource(collectionEle));
//設置集合目標數據類型
target.setElementTypeName(defaultElementType);
target.setMergeEnabled(parseMergeAttribute(collectionEle));
//具體的<list>元素解析
parseCollectionElements(nl, target, bd, defaultElementType);
return target;
}
//具體解析<list>集合元素，<array>、<list>和<set>都使用該方法解析
protected void parseCollectionElements(
NodeList elementNodes, Collection<Object> target, BeanDefinition bd, String defaultElementType) {
//遍歷集合全部節點
for (int i = 0; i < elementNodes.getLength(); i++) {
Node node = elementNodes.item(i);
//節點不是description節點
if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT)) {
//將解析的元素加入集合中，遞歸調用下一個子元素
target.add(parsePropertySubElement((Element) node, bd, defaultElementType));
}
}
}
通過對Spring Bean定義資源文件轉換的Document對象中的元素層層解析，Spring IoC如今已經將XML形式定義的Bean定義資源文件轉換爲Spring IoC所識別的數據結構——BeanDefinition，它是Bean定義資源文件中配置的POJO對象在Spring IoC容器中的映射，咱們能夠經過AbstractBeanDefinition爲入口，榮IoC容器進行索引、查詢和操做。
經過Spring IoC容器對Bean定義資源的解析後，IoC容器大體完成了管理Bean對象的準備工做，即初始化過程，可是最爲重要的依賴注入尚未發生，如今在IoC容器中BeanDefinition存儲的只是一些靜態信息，接下來須要向容器註冊Bean定義信息才能所有完成IoC容器的初始化過程
##1六、解析事後的BeanDefinition在IoC容器中的註冊：
讓咱們繼續跟蹤程序的執行順序，接下來會到咱們第3步中分析DefaultBeanDefinitionDocumentReader對Bean定義轉換的Document對象解析的流程中，在其parseDefaultElement方法中完成對Document對象的解析後獲得封裝BeanDefinition的BeanDefinitionHold對象，而後調用BeanDefinitionReaderUtils的registerBeanDefinition方法向IoC容器註冊解析的Bean，BeanDefinitionReaderUtils的註冊的源碼以下：
//將解析的BeanDefinitionHold註冊到容器中
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
//獲取解析的BeanDefinition的名稱
String beanName = definitionHolder.getBeanName();
//向IoC容器註冊BeanDefinition
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
//若是解析的BeanDefinition有別名，向容器爲其註冊別名
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String aliase : aliases) {
registry.registerAlias(beanName, aliase);
}
}
}
當調用BeanDefinitionReaderUtils向IoC容器註冊解析的BeanDefinition時，真正完成註冊功能的是DefaultListableBeanFactory。
1七、DefaultListableBeanFactory向IoC容器註冊解析後的BeanDefinition：
DefaultListableBeanFactory中使用一個HashMap的集合對象存放IoC容器中註冊解析的BeanDefinition，向IoC容器註冊的主要源碼以下：
//存儲註冊的俄BeanDefinition
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>();
//向IoC容器註冊解析的BeanDefiniton
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
//校驗解析的BeanDefiniton
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
//註冊的過程當中須要線程同步，以保證數據的一致性
synchronized (this.beanDefinitionMap) {
Object oldBeanDefinition = this.beanDefinitionMap.get(beanName);
//檢查是否有同名的BeanDefinition已經在IoC容器中註冊，若是已經註冊，
//而且不容許覆蓋已註冊的Bean，則拋出註冊失敗異常
if (oldBeanDefinition != null) {
if (!this.allowBeanDefinitionOverriding) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
"': There is already [" + oldBeanDefinition + "] bound.");
}
else {//若是容許覆蓋，則同名的Bean，後註冊的覆蓋先註冊的
if (this.logger.isInfoEnabled()) {
this.logger.info("Overriding bean definition for bean '" + beanName +
"': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
}
}
}
//IoC容器中沒有已經註冊同名的Bean，按正常註冊流程註冊
else {
this.beanDefinitionNames.add(beanName);
this.frozenBeanDefinitionNames = null;
}
this.beanDefinitionMap.put(beanName, beanDefinition);
//重置全部已經註冊過的BeanDefinition的緩存
resetBeanDefinition(beanName);
}
}
至此，Bean定義資源文件中配置的Bean被解析事後，已經註冊到IoC容器中，被容器管理起來，真正完成了IoC容器初始化所作的所有工做。現 在IoC容器中已經創建了整個Bean的配置信息，這些BeanDefinition信息已經可使用，而且能夠被檢索，IoC容器的做用就是對這些註冊的Bean定義信息進行處理和維護。這些的註冊的Bean定義信息是IoC容器控制反轉的基礎，正是有了這些註冊的數據，容器才能夠進行依賴注入。
總結：
如今經過上面的代碼，總結一下IOC容器初始化的基本步驟：
u 初始化的入口在容器實現中的 refresh()調用來完成
u 對 bean 定義載入 IOC 容器使用的方法是 loadBeanDefinition,其中的大體過程以下：經過 ResourceLoader 來完成資源文件位置的定位，DefaultResourceLoader 是默認的實現，同時上下文自己就給出了 ResourceLoader 的實現，能夠從類路徑，文件系統, URL 等方式來定爲資源位置。若是是 XmlBeanFactory做爲 IOC 容器，那麼須要爲它指定 bean 定義的資源，也就是說 bean 定義文件時經過抽象成 Resource 來被 IOC 容器處理的，容器經過 BeanDefinitionReader來完成定義信息的解析和 Bean 信息的註冊,每每使用的是XmlBeanDefinitionReader 來解析 bean 的 xml 定義文件 - 實際的處理過程是委託給 BeanDefinitionParserDelegate 來完成的，從而獲得 bean 的定義信息，這些信息在 Spring 中使用 BeanDefinition 對象來表示 - 這個名字可讓咱們想到loadBeanDefinition,RegisterBeanDefinition 這些相關的方法 - 他們都是爲處理 BeanDefinitin 服務的， 容器解析獲得 BeanDefinitionIoC 之後，須要把它在 IOC 容器中註冊，這由 IOC 實現 BeanDefinitionRegistry 接口來實現。註冊過程就是在 IOC 容器內部維護的一個HashMap 來保存獲得的 BeanDefinition 的過程。這個 HashMap 是 IoC 容器持有 bean 信息的場所，之後對 bean 的操做都是圍繞這個HashMap 來實現的.
u 而後咱們就能夠經過 BeanFactory 和 ApplicationContext 來享受到 Spring IOC 的服務了,在使用 IOC 容器的時候，咱們注意到除了少許粘合代碼，絕大多數以正確 IoC 風格編寫的應用程序代碼徹底不用關心如何到達工廠，由於容器將把這些對象與容器管理的其餘對象鉤在一塊兒。基本的策略是把工廠放到已知的地方，最好是放在對預期使用的上下文有意義的地方，以及代碼將實際須要訪問工廠的地方。 Spring 自己提供了對聲明式載入 web 應用程序用法的應用程序上下文,並將其存儲在ServletContext 中的框架實現。具體能夠參見之後的文章
在使用 Spring IOC 容器的時候咱們還須要區別兩個概念:
Beanfactory 和 Factory bean，其中 BeanFactory 指的是 IOC 容器的編程抽象，好比 ApplicationContext， XmlBeanFactory 等，這些都是 IOC 容器的具體表現，須要使用什麼樣的容器由客戶決定,但 Spring 爲咱們提供了豐富的選擇。 FactoryBean 只是一個能夠在 IOC而容器中被管理的一個 bean,是對各類處理過程和資源使用的抽象,Factory bean 在須要時產生另外一個對象，而不返回 FactoryBean自己,咱們能夠把它當作是一個抽象工廠，對它的調用返回的是工廠生產的產品。全部的 Factory bean 都實現特殊的org.springframework.beans.factory.FactoryBean 接口，當使用容器中 factory bean 的時候，該容器不會返回 factory bean 自己,而是返回其生成的對象。Spring 包括了大部分的通用資源和服務訪問抽象的 Factory bean 的實現，其中包括:對 JNDI 查詢的處理，對代理對象的處理，對事務性代理的處理，對 RMI 代理的處理等，這些咱們均可以當作是具體的工廠,當作是SPRING 爲咱們創建好的工廠。也就是說 Spring 經過使用抽象工廠模式爲咱們準備了一系列工廠來生產一些特定的對象,免除咱們手工重複的工做，咱們要使用時只須要在 IOC 容器裏配置好就能很方便的使用了
4、IOC容器的依賴注入
- 1. Spring：源碼解讀Spring IOC原理
- 2. spring 源碼解讀Spring IOC原理
- 3. Spring：源碼解讀Spring IOC原理（一）
- 4. Spring IOC源碼解讀
- 5. Spring源碼解讀IOC
- 6. spring的IOC源碼解讀
- 7. Spring源碼之IoC原理
- 8. Spring IOC原理解讀
- 9. Spring源碼：IOC原理解析（二）
- 10. Spring源碼：IOC原理解析（一）
- 更多相關文章...
- • Spring IoC容器：BeanFactory和ApplicationContext - Spring教程
- • Spring體系結構詳解 - Spring教程
- • Spring Cloud 微服務實戰(三) - 服務註冊與發現
- • JDK13 GA發佈：5大特性解讀
-
每一个你不满意的现在，都有一个你没有努力的曾经。