Spring IoC容器設計原理及高階特性
文章目錄
Spring IoC容器概述
IoC是Spring容器的核心，其字面意思是控制反轉。那麼究竟是哪些方面的控制被反轉了？其實是依賴物件的獲得被反轉了。基於此，提出了DI（依賴注入）的概念。
IoC容器系列的設計與實現：BeanFactory和ApplicationContext
在Spring IoC容器的設計中，主要有兩個容器系列，一個是實現BeanFactory介面餓簡單容器系列，這系列容器只實現了容器的最基本功能；另一個是ApplicationContext應用上下文，它作為容器的高階形態而存在。應用上下文在簡單容器的基礎上，增加了許多面向框架的特性，同時對應用環境做了許多適配。
Spring通過定義BeanDefinition來管理基於Spring的應用中的各種物件以及它們之間的相互依賴關係。對IoC容器來說，BeanDefinition就是依賴反轉模式中管理的物件依賴關係的資料抽象，也是容器實現依賴反轉功能的核心資料結構，依賴反轉功能都是圍繞這個BeanDefinition的處理來完成的。
• 從介面BeanFactory到HierarchicalBeanFactory，再到ConfigurableBeanFactory，是一條主要的BeanFactory設計路徑
BeanFactory定義了基本的IoC容器的規範。包括了getBean()（通過這個方法可以從容器中取得Bean）。
HierarchicalBeanFactory介面在繼承了BeanFactory後，增加了getParentBeanFactory()，使BeanFactory具備了雙親IoC容器的管理功能。
在接下來的ConfigurableBeanFactory中，定義了一些對BeanFactory的配置功能，比如通過setParentBeanFactory()設定雙親IoC容器，通過addBeanPostProcessor()配置Bean後置處理器，等等。
• 第二條介面設計主線是，以ApplicationContext為核心的介面設計
我們常用的應用上下文基本上都是ConfigurableApplicationContext或者WebApplicationContext的實現
在這個介面體系中，ListableBeanFactory和HierarchicalBeanFactory兩個介面，連線BeanFactory介面定義和ApplicationConext應用上下文的介面定義。
在ListableBeanFactory介面中，細化了許多BeanFactory的介面功能，比如定義了getBeanDefinitionNames()介面方法；對於HierarchicalBeanFactory介面，我們在前文中已經提到過；對於ApplicationContext介面，它通過繼承MessageSource、ResourceLoader、ApplicationEventPublisher介面，在BeanFactory簡單IoC容器的基礎上添加了許多對高階容器的特性的支援
• 這裡涉及的是主要介面關係，而具體的IoC容器都是在這個介面體系下實現的，比如DefaultListableBeanFactory，這個基本IoC容器的實現就是實現了ConfigurableBeanFactory，從而成為一個簡單IoC容器的實現。
像其他IoC容器，比如XmlBeanFactory，都是在DefaultListableBeanFactory的基礎上做擴充套件
• 這個介面系統是以BeanFactory和ApplicationContext為核心
而BeanFactory又是IoC容器的最基本介面，在ApplicationContext的設計中，一方面，可以看到它繼承了BeanFactory介面體系的介面，具備了BeanFactory IoC容器的基本功能
另一方面，通過繼承MessageSource、ResourceLoadr、ApplicationEventPublisher這些介面，BeanFactory為ApplicationContext賦予了更高階的IoC容器特性。
對於ApplicationContext而言，為了在Web環境中使用它，還設計了WebApplicationContext介面，而這個介面通過繼承ThemeSource介面來擴充功能。
BeanFactory
Spring Bean的建立是典型的工廠模式，這一系列的Bean工廠，也即IOC容器為開發者管理物件間的依賴關係提供了很多便利和基礎服務，在Spring中有許多的IOC容器的實現供使用者選擇和使用，其相互關係如下：
BeanFactory介面定義了IoC容器最基本的形式,不關心 Bean 是怎樣定義和載入的。如果我們想要知道一個工廠具體產生物件的過程，則要看這個介面的實現類。
其中BeanFactory作為最頂層的一個介面類，它定義了IOC容器的基本功能規範，BeanFactory 有三個子類：
ListableBeanFactory、HierarchicalBeanFactory 和AutowireCapableBeanFactory。
但是從上圖中我們可以發現最終的預設實現類是 DefaultListableBeanFactory，他實現了所有的介面。那為何要定義這麼多層次的介面呢？查閱這些介面的原始碼和說明發現，每個介面都有他使用的場合，它主要是為了區分在 Spring 內部在操作過程中物件的傳遞和轉化過程中，對物件的資料訪問所做的限制。例如 ListableBeanFactory 介面表示這些 Bean 是可列表的，而 HierarchicalBeanFactory 表示子容器可以通過介面方法訪問父容器，AutowireCapableBeanFactory 介面定義 Bean 的自動裝配規則。這四個介面共同定義了 Bean 的集合、Bean 之間的關係、以及 Bean 行為。
最基本的IOC容器介面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容器的設計原理
在BeanFactory介面的基礎上，Spring提供了一系列容器的實現供開發人員使用。我們以XmlBeanFactory的實現為例來說明簡單IoC容器的設計原理。
XmlBeanFactory繼承自DefaultListableBeanFactory這個類，同時實現了其他諸如XML讀取的附加功能。即它是一個可以讀取以XML檔案方式定義的BeanDefinition的IoC容器。
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);
}
}
在XmlBeanFactory中，初始化了一個XmlBeanDefinitionReader物件，由它來完成XML形式的資訊處理。構造XmlBeanFactory這個容器時，需要指定BeanDefinition的資訊來源，將它封裝成Spring中的Resource類來給出。然後傳遞給XmlBeanFactory建構函式，IoC容器就可以方便地定位到需要的BeanDefinition資訊來對Bean完成容器的初始化和依賴注入過程。對XmlBeanDefinitionReader物件的初始化，以及使用這個物件來完成對loadBeanDefinition的呼叫，就是這個呼叫啟動從Resource中載入BeanDefinitions的過程。
ApplicationContext
ApplicationContext是Spring提供的一個高階的IoC容器，它除了能夠提供IoC容器的基本功能外，還為使用者提供了以下的附加服務。
- 支援資訊源，可以實現國際化。（實現MessageSource介面）
- 訪問資源。(實現ResourcePatternResolver介面，這個後面要講)
- 支援應用事件。(實現ApplicationEventPublisher介面)
- 在ApplicationContext中提供的附加服務
ApplicationContext容器的設計原理
我們以常用的FileSystemXmlApplicationContext的實現為例說明ApplicationContext容器的設計原理。
public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
throws BeansException {
super(parent);
setConfigLocations(configLocations);
if (refresh) {
refresh();
}
}
在FileSystemXmlApplicationContext的設計中，我們看到ApplicationContext應用上下文的主要功能已經在FileSystemXmlApplicationContext的基類AbstractXmlApplicationContext中實現了，FileSystemXmlApplicationContext作為一個具體的應用上下文，只需要實現和它自身設計相關的兩個功能。一個功能是，如果應用直接使用FileSystemXmlApplicationContext，對於例項化這個應用上下文的支援，同時啟動IoC容器的refresh()過程。另一個功能是與FileSystemXmlApplicationContext設計具體相關的功能，這部分與怎樣從檔案系統中載入XML的Bean定義資源有關。
IoC容器的初始化過程
IoC容器的初始化是由refresh()方法來啟動的，這個方法標誌著容器的正式啟動。具體來說，這個啟動包括BeanDefinition的Resource定位、載入和註冊三個基本過程。
- Resource定位：指的是BeanDefinition的資源定位，它由ResourceLoader通過統一的Resource介面來完成。
- BeanDefinition的載入：把使用者定義好的Bea表示成IoC容器內部的資料結構，而這個容器內部的資料結構就是BeanDefinition。
- BeanDefinition的註冊：通過呼叫BeanDefinitionRegistry介面的實現來完成的。這個註冊過程是把載入過程中解析得到的BeanDefinition向IoC容器進行註冊。
IoC容器的依賴注入
依賴注入發生的時間
當Spring IoC容器完成了Bean定義資源的定位、載入和解析註冊以後，IoC容器中已經管理類Bean定義的相關資料，即初始化過程完成的主要工作是在IoC容器中建立BeanDefinition資料對映。
但是此時IoC容器還沒有對所管理的Bean進行依賴注入，依賴注入在以下兩種情況發生：
(1) 使用者第一次通過getBean方法向IoC容索要Bean時，IoC容器觸發依賴注入。
(2) 當用戶在Bean定義資源中為< Bean >元素配置了lazy-init屬性，即讓容器在解析註冊Bean定義時進行預例項化，觸發依賴注入。
BeanFactory介面定義了Spring IoC容器的基本功能規範，是Spring IoC容器所應遵守的最底層和最基本的程式設計規範。BeanFactory介面中定義了幾個getBean方法，就是使用者向IoC容器索取管理的Bean的方法，我們通過分析其子類的具體實現，理解Spring IoC容器在使用者索取Bean時如何完成依賴注入。
依賴注入的流程圖
依賴注入的原始碼分析
在BeanFactory中我們看到getBean()函式，它的具體實現在AbstractBeanFactory中。
- AbstractBeanFactory通過getBean向IoC容器獲取被管理的Bean。
AbstractBeanFactory的getBean相關方法的原始碼如下：
//獲取IoC容器中指定名稱的Bean
public Object getBean(String name) throws BeansException {
//doGetBean才是真正向IoC容器獲取被管理Bean的過程
return doGetBean(name, null, null, false);
}
//獲取IoC容器中指定名稱和型別的Bean
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
//doGetBean才是真正向IoC容器獲取被管理Bean的過程
return doGetBean(name, requiredType, null, false);
}
//獲取IoC容器中指定名稱和引數的Bean
public Object getBean(String name, Object... args) throws BeansException {
//doGetBean才是真正向IoC容器獲取被管理Bean的過程
return doGetBean(name, null, args, false);
}
//獲取IoC容器中指定名稱、型別和引數的Bean
public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {
//doGetBean才是真正向IoC容器獲取被管理Bean的過程
return doGetBean(name, requiredType, args, false);
}
//真正實現向IoC容器獲取Bean的功能，也是觸發依賴注入功能的地方
@SuppressWarnings("unchecked")
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
//根據指定的名稱獲取被管理Bean的名稱，剝離指定名稱中對容器的相關依賴
//如果指定的是別名，將別名轉換為規範的Bean名稱
final String beanName = transformedBeanName(name);
Object bean;
//先從快取中取是否已經有被建立過的單例型別的Bean，對於單例模式的Bean整
//個IoC容器中只建立一次，不需要重複建立
Object sharedInstance = getSingleton(beanName);
//IoC容器建立單例模式Bean例項物件
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
//如果指定名稱的Bean在容器中已有單例模式的Bean被建立，直接返回
//已經建立的Bean
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//獲取給定Bean的例項物件，主要是完成FactoryBean的相關處理
//注意：BeanFactory是管理容器中Bean的工廠，而FactoryBean是
//建立建立物件的工廠Bean，兩者之間有區別
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {//快取沒有正在建立的單例模式Bean
//快取中已經有已經建立的原型模式Bean，但是由於迴圈引用的問題導致實
//例化物件失敗
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//對IoC容器中是否存在指定名稱的BeanDefinition進行檢查，首先檢查是否
//能在當前的BeanFactory中獲取的所需要的Bean，如果不能則委託當前容器
//的父級容器去查詢，如果還是找不到則沿著容器的繼承體系向父級容器查詢
BeanFactory parentBeanFactory = getParentBeanFactory();
//當前容器的父級容器存在，且當前容器中不存在指定名稱的Bean
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
//解析指定Bean名稱的原始名稱
String nameToLookup = originalBeanName(name);
if (args != null) {
//委派父級容器根據指定名稱和顯式的引數查詢
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
//委派父級容器根據指定名稱和型別查詢
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
//建立的Bean是否需要進行型別驗證，一般不需要
if (!typeCheckOnly) {
//向容器標記指定的Bean已經被建立
markBeanAsCreated(beanName);
}
//根據指定Bean名稱獲取其父級的Bean定義，主要解決Bean繼承時子類
//合併父類公共屬性問題
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
//獲取當前Bean所有依賴Bean的名稱
String[] dependsOn = mbd.getDependsOn();
//如果當前Bean有依賴Bean
if (dependsOn != null) {
for (String dependsOnBean : dependsOn) {
//遞迴呼叫getBean方法，獲取當前Bean的依賴Bean
getBean(dependsOnBean);
//把被依賴Bean註冊給當前依賴的Bean
registerDependentBean(dependsOnBean, beanName);
}
}
//建立單例模式Bean的例項物件
if (mbd.isSingleton()) {
//這裡使用了一個匿名內部類，建立Bean例項物件，並且註冊給所依賴的物件
sharedInstance = getSingleton(beanName, new ObjectFactory() {
public Object getObject() throws BeansException {
try {
//建立一個指定Bean例項物件，如果有父級繼承，則合併子//類和父類的定義
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
//顯式地從容器單例模式Bean快取中清除例項物件
destroySingleton(beanName);
throw ex;
}
}
});
//獲取給定Bean的例項物件
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//IoC容器建立原型模式Bean例項物件
else if (mbd.isPrototype()) {
//原型模式(Prototype)是每次都會建立一個新的物件
Object prototypeInstance = null;
try {
//回撥beforePrototypeCreation方法，預設的功能是註冊當前創//建的原型物件
beforePrototypeCreation(beanName);
//建立指定Bean物件例項
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
//回撥afterPrototypeCreation方法，預設的功能告訴IoC容器指//定Bean的原型物件不再建立了
afterPrototypeCreation(beanName);
}
//獲取給定Bean的例項物件
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//要建立的Bean既不是單例模式，也不是原型模式，則根據Bean定義資源中
//配置的生命週期範圍，選擇例項化Bean的合適方法，這種在Web應用程式中
//比較常用，如：request、session、application等生命週期
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
//Bean定義資源中沒有配置生命週期範圍，則Bean定義不合法
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
}
try {
//這裡又使用了一個匿名內部類，獲取一個指定生命週期範圍的例項
Object scopedInstance = scope.get(beanName, new ObjectFactory() {
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
}
});
//獲取給定Bean的例項物件
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; " +
"consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
//對建立的Bean例項物件進行型別檢查
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return (T) bean;
}
通過上面對向IoC容器獲取Bean方法的分析，我們可以看到在Spring中，如果Bean定義的單例模式(Singleton)，則容器在建立之前先從快取中查詢，以確保整個容器中只存在一個例項物件。如果Bean定義的是原型模式(Prototype)，則容器每次都會建立一個新的例項物件。除此之外，Bean定義還可以擴充套件為指定其生命週期範圍。
上面的原始碼只是定義了根據Bean定義的模式，採取的不同建立Bean例項物件的策略，具體的Bean例項物件的建立過程由實現了ObejctFactory介面的匿名內部類的createBean方法完成，ObejctFactory使用委派模式，具體的Bean例項建立過程交由其實現類AbstractAutowireCapableBeanFactory完成，我們繼續分析AbstractAutowireCapableBeanFactory的createBean方法的原始碼，理解其建立Bean例項的具體實現過程。
- AbstractAutowireCapableBeanFactory建立Bean例項物件。
AbstractAutowireCapableBeanFactory類實現了ObejctFactory介面，建立容器指定的Bean例項物件，同時還對建立的Bean例項物件進行初始化處理。其建立Bean例項物件的方法原始碼如下：
//建立Bean例項物件
protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
//判斷需要建立的Bean是否可以例項化，即是否可以通過當前的類載入器載入
resolveBeanClass(mbd, beanName);
//校驗和準備Bean中的方法覆蓋
try {
mbd.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
//如果Bean配置了初始化前和初始化後的處理器，則試圖返回一個需要建立//Bean的代理物件
Object bean = resolveBeforeInstantiation(beanName, mbd);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
//建立Bean的入口
Object beanInstance = doCreateBean(beanName, mbd, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
//真正建立Bean的方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
//封裝被建立的Bean物件
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()){//單例模式的Bean，先從容器中快取中獲取同名Bean
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//建立例項物件
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
//獲取例項化物件的型別
Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
//呼叫PostProcessor後置處理器
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
//向容器中快取單例模式的Bean物件，以防迴圈引用
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references"
相關推薦
Spring IoC容器設計原理及高階特性
文章目錄
Spring IoC容器概述
IoC容器系列的設計與實現：BeanFactory和ApplicationContext
BeanFactory
BeanFactory容器的設計原理
Applicatio
Spring IoC 容器的設計與實現原理
上一篇文章講解的是IOC的原理，這一篇文章主要講解Spring IoC 容器的設計與實現原理
1.spring的IOC容器
在 Spring IoC 容器的設計中，容器有兩個系列，可以看成是容器的具體表現形式：
BeanFactory 簡單容器：實現了容器的基本
Spring原始碼解析--《SPRING技術內幕:深入解析Spring架構與設計原理》讀書筆記（一）：IOC容器初始化過程
通過閱讀相關章節內容，Spring中IOC容器的載入中，我們需要了解下列幾個概念：
Resource：是一個定位、訪問資源的抽象介面，包含了多種資源操作的基礎方法定義，如getInputStream()、exists()、isOpen()、getD
Spring學習--IOC容器的概念及一個簡單IOC容器使用案例
IOC容器的概念： IOC容器就是具有依賴注入功能的容器，IOC容器負者例項化、定位、配置應用程式中的物件及監理這些物件間的依賴，應用程式無需直接在物件中new物件，而是由IOC容器進行組裝。在Spring中BeanFactory是IOC容器的實際代表。 Spring IoC容器如何知道
Spring IOC容器啟動流程原始碼解析(一)——容器概念詳解及原始碼初探
目錄
1. 前言
1.1 IOC容器到底是什麼
IOC和AOP是Spring框架的核心功能,而IOC又是AOP實現的基礎,因而可以說IOC是整個Spring框架的基石。那麼什麼是IOC？IOC即控制反轉,通俗的說就是讓Spring框架來幫助我們完成物件的依賴管理和生命週期控制等等工作。從面向物件的角度來說,
三條路線告訴你如何掌握Spring IoC容器的核心原理
前幾篇：一、前言前三篇已經從歷史的角度和大家一起探討了為什麼會有Spring，Spring的兩個
Spring原始碼學習之IOC容器實現原理（一）-DefaultListableBeanFactory
從這個繼承體系結構圖來看，我們可以發現DefaultListableBeanFactory是第一個非抽象類，非介面類。實際IOC容器。所以這篇部落格以DefaultListableBeanFactoryIOC容器為基準進行IOC原理解析。 一.兩個重要介面 前面已經分析了BeanFactor，它的三個直接子
Spring IoC容器與應用上下文的設計與實現
一、前言
寫這篇博文的主要目的如下：
通過相關類和介面分析IoC容器到底長什麼樣。
闡述筆者對Spring上下文和容器的理解。
介紹重要的類輔助理解SpringBoot的啟動流程。
二、Spring IoC容器的設計
看看下面這張圖（摘自《Spring技術內幕》），
spring IoC容器的實現。
管理 體系 控制 我們 管理系 content 具體實現 抽象 目的 控制反轉是spring的重要概念。而實現控制反轉的IoC容器具體又是如何實現呢。
IoC容器的目的是能夠管理系統中各個對象之間的關系和依賴，為了實現這個功能，spring框架對Bean做了進一步抽象 Be
Spring IoC容器管理Action
framework 實現類 ces 攔截 ons servlet 需要 所有 使用 Spring IoC容器管理Action有兩種方式：DelegatingRequestProcessor、DelegatingActionProxy
不管采用哪一種方式，都需要隨應用啟動時創
Spring IOC容器的初始化-（三）BeanDefinition的註冊
store erro pan customize 註冊 failed mono def override ---恢復內容開始---
前言
在上一篇中有一處代碼是BeanDefiniton註冊的入口，我們回顧一下。
1.BeanDefiniton在IOC容器註冊
首先我
Spring IOC容器的基本應用
信息 ioc容器 ans control gpo getbean 配置文件 如何工作 簡單 Spring IOC概述
IOC全稱Inversion of Control，被譯為控制反轉，是指程序中對象的獲取方式發生反轉，由最初的new方式創建，轉變為由第三方框架創
Spring IOC 容器源碼分析 - 創建單例 bean 的過程
event version trac 方法 del lB ctu prepare 先來 1. 簡介
在上一篇文章中，我比較詳細的分析了獲取 bean 的方法，也就是getBean(String)的實現邏輯。對於已實例化好的單例 bean，getBean(String) 方法
Spring IOC 容器源碼分析 - 創建原始 bean 對象
設置 assign 循環 處理器 from index boolean sar 興趣 1. 簡介
本篇文章是上一篇文章（創建單例 bean 的過程）的延續。在上一篇文章中，我們從戰略層面上領略了doCreateBean方法的全過程。本篇文章，我們就從戰術的層面上，詳細分析d
Spring IOC 容器源碼分析 - 填充屬性到 bean 原始對象
interface let 源碼分析 添加 eat object determine 方法調用 集合類 1. 簡介
本篇文章，我們來一起了解一下 Spring 是如何將配置文件中的屬性值填充到 bean 對象中的。我在前面幾篇文章中介紹過 Spring 創建 bean 的流
spring IOC容器的擴展
ESS 需要 getenv 級別 efault 監聽 roc val enc 在此之前已經完成了IOC對xml的解析和實例化工作，接下來需要分析Spring的高級版本對IOC容器的功能擴展：
代碼分析如下：
synchronized (this.startupShutdo
03.Spring IoC 容器 - 初始化
itl ret num servlet fontsize eat 圖片 number sources 基本概念
Spring IoC 容器的初始化過程在監聽器 ContextLoaderListener 類中定義。
具體由該類的的 configureAndRefreshWe
Spring IoC容器實現
127.0.0.1 兩種 [] 作用 隱式調用 ini 告訴 而是 lee 1,Spring的兩種IoC容器
BeanFactory
基礎類型的IoC容器；
采用延遲初始化策略（容器初始化完成後並不會創建bean的對象，只有當收到初始化請求時才進行初始化）；
由於延遲初
關於Spring IOC容器
版權 spm size align cto ccf 文件絕對路徑 推薦 sse 註：都是從net的各個角落找到的，如涉及到版權請聯系我，君並無意冒犯。
1，spring容器的三種加載方式：
（1）FileSystemXmlApplicationContext這個方法是從文件
1.3淺談Spring(IOC容器的實現)
tap 就是 parser pojo file abstract throw cdd moni 這一節我們來討論IOC容器到底做了什麽。
還是借用之前的那段代碼
ClassPathXmlApplicationContext app = new ClassPathXmlAp