spring源碼解析（1）----IOC
一、IOC容器
在Spring中，IOC容器的重要地位我們就不多說了，對於Spring的使用者而言，IOC容器實際上是什麼呢？我們可以說BeanFactory就是我們看到的IoC容器，當然了Spring爲我們準備了許多種IoC容器來使用，這樣可以方便我們從不同的層面，不同的資源位置，不同的形式的定義信息來建立我們需要的IoC容器。
在Spring中，最基本的IOC容器接口是BeanFactory - 這個接口爲具體的IOC容器的實現作了最基本的功能規定 - 不管怎麼着，作爲IOC容器，這些接口你必須要滿足應用程序的最基本要求：
public interface BeanFactory {
//這裏是對FactoryBean的轉義定義，因爲如果使用bean的名字檢索FactoryBean得到的對象是工廠生成的對象，
//如果需要得到工廠本身，需要轉義
String FACTORY_BEAN_PREFIX = "&";
//這裏根據bean的名字，在IOC容器中得到bean實例，這個IOC容器就是一個大的抽象工廠。
Object getBean(String name) throws BeansException;
//這裏根據bean的名字和Class類型來得到bean實例，和上面的方法不同在於它會拋出異常：如果根據名字取得的bean實例的Class類型和需要的不同的話。
Object getBean(String name, Class requiredType) throws BeansException;
//這裏提供對bean的檢索，看看是否在IOC容器有這個名字的bean
//這裏根據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容器實現，當然你可以自己根據這個BeanFactory來實現自己的IOC容器，但這個沒有必要，因爲Spring已經爲我們準備好了一系列工廠來讓我們使用。比如XmlBeanFactory就是針對最基礎的BeanFactory的IOC容器的實現，這個實現使用xml來定義IOC容器中的bean。
Spring提供了一個BeanFactory的基本實現，XmlBeanFactory同樣的通過使用模板模式來得到對IOC容器的抽象，AbstractBeanFactory,DefaultListableBeanFactory這些抽象類爲其提供模板服務。其中通過resource 接口來抽象bean定義數據，對Xml定義文件的解析通過委託給XmlBeanDefinitionReader來完成。下面我們根據書上的例子，簡單的演示IOC容器的創建過程
<span style="font-size:12px;"> ClassPathResource res = new ClassPathResource("beans.xml");
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
reader.loadBeanDefinitions(res);</span>1. 創建IOC配置文件的抽象資源
2. 創建一個BeanFactory
3. 把讀取配置信息的BeanDefinitionReader,這裏是XmlBeanDefinitionReader配置給BeanFactory
4. 從定義好的資源位置讀入配置信息，具體的解析過程由XmlBeanDefinitionReader來完成，這樣完成整個載入bean定義的過程。我們的IoC容器就建立起來了。在BeanFactory的源代碼中我們可以看到：
public class XmlBeanFactory extends DefaultListableBeanFactory {
//這裏爲容器定義了一個默認使用的bean定義讀取器
private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
public XmlBeanFactory(Resource resource) throws BeansException {
this(resource, null);
}
//在初始化函數中使用讀取器來對資源進行讀取，得到bean定義信息。
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
super(parentBeanFactory);
this.reader.loadBeanDefinitions(resource);
}
仔細分析Spring BeanFactory的結構，我們來看看在BeanFactory基礎上擴展出的ApplicationContext，我們最常使用的上下文。除了具備BeanFactory的全部能力，上下文爲應用程序又增添了許多便利：
* 可以支持不同的信息源，我們看到ApplicationContext擴展了MessageSource
* 訪問資源 , 體現在對ResourceLoader和Resource的支持上面，這樣我們可以從不同地方得到bean定義資源
* 支持應用事件，繼承了接口ApplicationEventPublisher,這樣在上下文中引入了事件機制而BeanFactory是沒有的。
ApplicationContext允許上下文嵌套，通過保持父上下文可以維持一個上下文體系，這個體系我們在以後對Web容器中的上下文環境的分析中可以清楚地看到。對於bean的查找可以在這個上下文體系中發生，首先檢查當前上下文，其次是父上下文，逐級向上，這樣爲不同的Spring應用提供了一個共享的bean定義環境。這個我們在分析Web容器中的上下文環境時也能看到。
ApplicationContext提供IoC容器的主要接口，在其體系中有許多抽象子類比如AbstractApplicationContext爲具體的BeanFactory的實現，比如FileSystemXmlApplicationContext和 ClassPathXmlApplicationContext提供上下文的模板，使得他們只需要關心具體的資源定位問題。當應用程序代碼實例化 FileSystemXmlApplicationContext的時候，得到IoC容器的一種具體表現 - ApplicationContext，從而應用程序通過ApplicationContext來管理對bean的操作。
BeanFactory 是一個接口，在實際應用中我們一般使用ApplicationContext來使用IOC容器，它們也是IOC容器展現給應用開發者的使用接口。對應用程序開發者來說，可以認爲BeanFactory和ApplicationFactory在不同的使用層面上代表了SPRING提供的IOC容器服務。
下面我們具體看看通過FileSystemXmlApplicationContext是怎樣建立起IOC容器的, 顯而易見我們可以通過new來得到IoC容器：
ApplicationContext applicationContext = new FileSystemXmlApplicationContext("xmlPath");
public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
throws BeansException {
super(parent);
this.configLocations = configLocations;
if (refresh) {
//這裏是IoC容器的初始化過程，其初始化過程的大致步驟由AbstractApplicationContext來定義
refresh();
}
} public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
synchronized (this.activeMonitor) {
this.active = true;
}
// 這裏需要子類來協助完成資源位置定義,bean載入和向IOC容器註冊的過程
refreshBeanFactory();
............
} 在AbstractXmlApplicationContext中定義了對資源的讀取過程，默認由XmlBeanDefinitionReader來讀取：
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws IOException {
// 這裏使用XMLBeanDefinitionReader來載入bean定義信息的XML文件
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
//這裏配置reader的環境，其中ResourceLoader是我們用來定位bean定義信息資源位置的
///因爲上下文本身實現了ResourceLoader接口，所以可以直接把上下文作爲ResourceLoader傳遞給XmlBeanDefinitionReader
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
initBeanDefinitionReader(beanDefinitionReader);
//這裏轉到定義好的XmlBeanDefinitionReader中對載入bean信息進行處理
loadBeanDefinitions(beanDefinitionReader);
} protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
Resource[] configResources = getConfigResources();
if (configResources != null) {
//調用XmlBeanDefinitionReader來載入bean定義信息。
reader.loadBeanDefinitions(configResources);
}
String[] configLocations = getConfigLocations();
if (configLocations != null) {
reader.loadBeanDefinitions(configLocations);
}
}public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
//這裏得到當前定義的ResourceLoader,默認的我們使用DefaultResourceLoader
ResourceLoader resourceLoader = getResourceLoader();
//如果沒有找到我們需要的ResourceLoader，直接拋出異常
if (resourceLoader instanceof ResourcePatternResolver) {
// 這裏處理我們在定義位置時使用的各種pattern,需要ResourcePatternResolver來完成
try {
Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
int loadCount = loadBeanDefinitions(resources);
return loadCount;
}
}else{
// 這裏通過ResourceLoader來完成位置定位
Resource resource = resourceLoader.getResource(location);
// 這裏已經把一個位置定義轉化爲Resource接口，可以供XmlBeanDefinitionReader來使用了
int loadCount = loadBeanDefinitions(resource);
return loadCount;
}
} public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
public Resource getResource(String location) {
/這裏調用當前的loader也就是DefaultResourceLoader來完成載入
if (this.resourceLoader != null) {
return this.resourceLoader.getResource(location);
}
. return super.getResource(location);
}
} public Resource getResource(String location) {
//如果是類路徑的方式，那需要使用ClassPathResource來得到bean文件的資源對象
if (location.startsWith(CLASSPATH_URL_PREFIX)) {
return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
}
else {
try {
// 如果是URL方式，使用UrlResource作爲bean文件的資源對象
URL url = new URL(location);
return new UrlResource(url);
}catch (MalformedURLException ex) {
// 如果都不是，那我們只能委託給子類由子類來決定使用什麼樣的資源對象了
return getResourceByPath(location);
}
}
}protected Resource getResourceByPath(String path) {
if (path != null && path.startsWith("/")) {
path = path.substring(1);
}
//這裏使用文件系統資源對象來定義bean文件
return FileSystemResource(path);
}
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
try {
//這裏通過Resource得到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();
}
}
}
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
try {
int validationMode = getValidationModeForResource(resource);
//通過解析得到DOM，然後完成bean在IOC容器中的註冊
Document doc = this.documentLoader.loadDocument( inputSource, this.entityResolver, this.errorHandler, validationMode, this.namespaceAware);
return registerBeanDefinitions(doc, resource);
} .
} public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
// 這裏定義解析器，使用XmlBeanDefinitionParser來解析xml方式的bean定義文件，現在的版本不用這個解析器了，使用的是XmlBeanDefinitionReader
if (this.parserClass != null) {
XmlBeanDefinitionParser parser = (XmlBeanDefinitionParser)BeanUtils.instantiateClass(this.parserClass);
return parser.registerBeanDefinitions(this, doc, resource);
}
// 具體的註冊過程,首先得到XmlBeanDefinitionReader,來處理xml的bean定義文件
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
int countBefore = getBeanFactory().getBeanDefinitionCount();
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
return getBeanFactory().getBeanDefinitionCount() - countBefore;
} public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
logger.debug("Loading bean definitions");
Element root = doc.getDocumentElement();
BeanDefinitionParserDelegate delegate = createHelper(readerContext, root);
preProcessXml(root);
parseBeanDefinitions(root, delegate);
postProcessXml(root);
}
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
if (delegate.isDefaultNamespace(root.getNamespaceURI())) {
//這裏得到xml文件的子節點，比如各個bean節點
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;
String namespaceUri = ele.getNamespaceURI();
if (delegate.isDefaultNamespace(namespaceUri)) {
//這裏是解析過程的調用，對缺省的元素進行分析比如bean元素
parseDefaultElement(ele, delegate);
}else {
delegate.parseCustomElement(ele);
}
}
}
}else {
delegate.parseCustomElement(root);
}
}
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
//這裏對元素Import進行處理
if (DomUtils.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}else if (DomUtils.nodeNameEquals(ele, ALIAS_ELEMENT)) {
String name = ele.getAttribute(NAME_ATTRIBUTE);
String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
getReaderContext().getReader().getBeanFactory().registerAlias(name, alias);
getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
}
. //這裏對我們最熟悉的bean元素進行處理
else if (DomUtils.nodeNameEquals(ele, BEAN_ELEMENT)) {
//委託給BeanDefinitionParserDelegate來完成對bean元素的處理，這個類包含了具體的bean解析的過程。
// 把解析bean文件得到的信息放到BeanDefinition裏，他是bean信息的主要載體，也是IOC容器的管理對象。
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
// 這裏是向IOC容器註冊，實際上是放到IOC容器的一個map裏
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); .
// 這裏向IOC容器發送事件，表示解析和註冊完成。
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
} public static void registerBeanDefinition(BeanDefinitionHolder bdHolder, BeanDefinitionRegistry beanFactory) throws BeansException {
// 這裏得到需要註冊bean的名字；
String beanName = bdHolder.getBeanName();
//這是調用IOC來註冊的bean的過程，需要得到BeanDefinition
beanFactory.registerBeanDefinition(beanName, bdHolder.getBeanDefinition());
// 別名也是可以通過IOC容器和bean聯繫起來的進行註冊
String[] aliases = bdHolder.getAliases();
if (aliases != null) {
for (int i = 0; i < aliases.length; i++) {
beanFactory.registerAlias(beanName, aliases[i]);
}
}
} //---------------------------------------------------------------------
// 這裏是IOC容器對BeanDefinitionRegistry接口的實現
//---------------------------------------------------------------------
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
//這裏省略了對BeanDefinition的驗證過程
//先看看在容器裏是不是已經有了同名的bean,如果有拋出異常。
Object oldBeanDefinition = this.beanDefinitionMap.get(beanName);
if (oldBeanDefinition != null) {
if (!this.allowBeanDefinitionOverriding) {
..
}
else {
//把bean的名字加到IOC容器中去
this.beanDefinitionNames.add(beanName);
}
//這裏把bean的名字和Bean定義聯繫起來放到一個HashMap中去,IOC容器通過這個Map來維護容器裏的Bean定義信息。
this.beanDefinitionMap.put(beanName, beanDefinition);
removeSingleton(beanName);
} 從上面的代碼來看，我們總結一下IOC容器初始化的基本步驟：
* 初始化的入口在容器實現中的refresh()調用來完成
* 對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服務的，IoC容器解析得到BeanDefinition以後，需要把它在IOC容器中註冊，這由IOC實現 BeanDefinitionRegistry接口來實現。註冊過程就是在IOC容器內部維護的一個HashMap來保存得到的 BeanDefinition的過程。這個HashMap是IoC容器持有bean信息的場所，以後對bean的操作都是圍繞這個HashMap來實現的。
* 然後我們就可以通過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容器裏配置好就能很方便的使用了