概念
DI(Dependency Injection)依賴注入：依賴注入是指在程序運行期間,由外部容器動態地將依賴對象注入到組件中如：一般，通過構造函數注入、Setter注入、註解注入。
Setter注入與註解注入類似，區別在於：Setter 注入是通過 Set 方法對屬性進行賦值，而註解注入是通過反射爲屬性賦值。
時機
當 Spring IOC 容器完成了 Bean 定義資源的定位、載入、解析和註冊以後，IOC 容器中已經管理類 BeanDefinition 的相關數據，但是此時 IOC 容器還沒有對所管理的 Bean 進行依賴注入，依賴注入在以下兩種情況發生：
- 對應 Bean 對象未配置成懶加載的方式即 @Lazy(value = false) 或未使用該註解，則會在初始化 IOC 容器完成之後對非懶加載 BeanDefinition 進行實例化和依賴注入。
- 懶加載 Bean 對象在用戶第一次調用 getBean()方法時，IOC 容器觸發 Bean 的實例化和依賴注入。
原理
入口
我們第一種情況進行分析，在 IOC 完成後觸發的實例化和依賴注入。從上一篇文章 Spring 之 IOC 詳解（基於註解方式）
說到的 AbstractApplicationContext.refresh() 繼續進行分析：
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
// 調用容器準備刷新的方法，獲取容器的當前時間，同時給容器設置同步標識
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
// 從資源路徑獲取bean信息並封裝成beanDefinition註冊到beanFactory的beanDefinitionMap中
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
// beanFactory的預準備工作，對beanFactory配置容器特性，例如類加載器、事件處理器等
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
//beanFactory準備工作完成之後要進行的後置處理工作，留給子類擴展使用
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
// 執行BeanFactory的後置處理器，在BeanFactory標準初始化之後執行的
// 調用所有註冊的BeanFactoryPostProcessor的postProcessBeanFactory方法
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
// 爲BeanFactory註冊Post事件處理器，BeanPostProcessor是Bean的後置處理器，用於監聽容器觸發的事件
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
//初始化MessageSource信息源，即國際化處理、消息綁定、消息解析
initMessageSource();
// Initialize event multicaster for this context.
//初始化容器事件廣播器，並放入applicationEventMulticaster bean中
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
//留給子類來初始化其他的bean
onRefresh();
// Check for listener beans and register them.
//在所有註冊的bean中查找ApplicationListener，爲事件廣播器註冊事件監聽器
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
//初始化所有剩下的非懶加載單實例bean
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
//完成刷新過程，初始化容器的生命週期事件處理器，併發布容器的生命週期事件
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
// 銷燬已經創建的Bean
destroyBeans();
// Reset 'active' flag.
// 取消刷新操作，重置容器的同步標識
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
// 重置公共緩存
resetCommonCaches();
}
}
}
我們可以看到 finishBeanFactoryInitialization 方法明確是實例化所有非懶加載方式的 Bean 對象，源碼如下：
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
//爲了使類型匹配，停止使用臨時的類加載器
beanFactory.setTempClassLoader(null);
//緩存容器中所有註冊的BeanDefinition元數據，以防被修改
beanFactory.freezeConfiguration();
//對配置了lazy-init屬性爲false的單例模式的Bean進行預實例化處理
beanFactory.preInstantiateSingletons();
}
繼續跟進跳轉到 DefaultListableBeanFactory.preInstantiateSingletons() 方法，源碼如下：
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
//獲取容器中的所有bean，依次進行初始化和創建對象
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 對非懶加載的單例bean進行初始化
for (String beanName : beanNames) {
//獲取bean的定義信息
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//bean不是抽象的、是單實例的、是非懶加載的
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//判斷是否是FactoryBean，是否是實現FactoryBean接口的bean
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
//不是工廠Bean,利用getBean創建對象
getBean(beanName);
}
}
}
// 觸發所有適用bean的初始化後回調...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
在這裏我們需要先了解一下 FactoryBean 是什麼？看起來和 BeanFactory 很像，但不是一個東西。
BeanFactory是個Factory，也就是IOC容器或對象工廠，在Spring中，所有的Bean都是由BeanFactory(也就是IOC容器)來進行管理的，提供了實例化對象和拿對象的功能。使用場景：
- 從Ioc容器中獲取Bean(byName or byType)
- 檢索Ioc容器中是否包含指定的Bean
- 判斷Bean是否爲單例
FactoryBean是個Bean，這個Bean不是簡單的Bean，而是一個能生產或者修飾對象生成的工廠Bean,它的實現與設計模式中的工廠模式和修飾器模式類似。使用場景：
- 實時生成自定義 Bean 對象
接來下看具體 getBean 方法是如何實現的，跳轉到 AbstractBeanFactory.getBean() 方法。
//獲取 IOC 容器中指定名稱的 Bean
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
//獲取 IOC 容器中指定名稱和類型的 Bean
@Override
public <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
//獲取 IOC 容器中指定名稱和參數的 Bean
@Override
public Object getBean(String name, Object... args) throws BeansException {
return doGetBean(name, null, args, false);
}
//獲取 IOC 容器中指定名稱、類型和參數的 Bean
public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args)
throws BeansException {
return doGetBean(name, requiredType, args, false);
}
從這裏可以看到 AbstractBeanFactory 提供了多種獲取 Bean 的方式，懶加載的 Bean 對象在用戶第一次時一樣是通過這幾個方法。 doGetBean 方法纔是真正向 IOC 容器獲取被管理 Bean 的過程，源碼如下：
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable 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.isTraceEnabled()) {
//如果單例模式的Bean被創建，則直接返回
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("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)) {
// Not found -> check parent.
//解析指定Bean名稱的原始名稱
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
//遞歸到beanFactory中尋找
else if (args != null) {
//委派父容器根據指定名稱和顯式的參數查找
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
//委派父容器根據指定名稱和類型查找
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
//委派父容器根據指定名稱查找
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
//創建的Bean是否需要進行類型驗證
if (!typeCheckOnly) {
//向容器標記指定的Bean已經被創建
markBeanAsCreated(beanName);
}
try {
//根據指定Bean名稱獲取其父級Bean定義，主要解決Bean繼承時子類和父類公共屬性問題
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//判斷父級BeanDefinition是否是抽象的
checkMergedBeanDefinition(mbd, beanName, args);
//獲取當前bean所有屬性對應的依賴Bean名稱
String[] dependsOn = mbd.getDependsOn();
//如果當前Bean有依賴
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
//註冊當前bean和依賴bean關聯關係
registerDependentBean(dep, beanName);
try {
//遞歸調用，獲取依賴Bean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
//創建單例模式的Bean的實例對象
if (mbd.isSingleton()) {
//調用匿名內部類創建Bean實例對象，創建Bean實例對象，並且註冊給所依賴的對象
sharedInstance = getSingleton(beanName, () -> {
try {
//創建一個指定Bean實例對象，如果有父級繼承，則合併子類和父類的定義
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
//從單例模式的Bean緩存中清除實例對象
destroySingleton(beanName);
throw ex;
}
});
//獲取給定Bean的實例對象，主要完成FactoryBean獲取實例化對象過程
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//IOC容器創建原型模式的Bean實例對象
else if (mbd.isPrototype()) {
//原型模式每次都會創建一個新的對象
Object prototypeInstance = null;
try {
//創建的原型對象之前進行回調
beforePrototypeCreation(beanName);
//創建指定Bean的對象實例
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
//回調方法，告訴IOC容器不再創建指定Bean的原型對象
afterPrototypeCreation(beanName);
}
//獲取給定Bean的實例對象，主要完成FactoryBean獲取實例化對象過程
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
//創建的Bean既不是單例模式也不是原型模式，創建其他生命週期的Bean
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
//如果Bean定義資源中沒有配置生命週期範圍，則Bean定義不合法
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
//調用匿名內部類，獲取一個指定生命週期範圍的實例
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
//獲取給定Bean的實例對象，主要完成FactoryBean獲取實例化對象過程
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);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
這裏會設計到一個高頻面試題-循環依賴，在後續文章中我將單獨拉出來進行講解，在這裏就不做過多討論。
上述方法主要完成了
- 從緩存中獲取單例 Bean
- 從緩存中取到，則調用 getObjectForBeanInstance 獲取實例對象並返回
- 如果沒有則從父級 RootBeanDefinition 中查找
- 都沒有找到的情況下，創建指定生命週期的 Bean 實例
如果從單例緩存中獲取到了對應的單例 Bean， getObjectForBeanInstance 方法：獲取給定 Bean 的實例對象，主要是完成FactoryBean的相關處理。
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
//容器已經得到了Bean實例對象，這個實例對象可能是一個普通的Bean，
//也可能是一個工廠Bean，如果是一個工廠Bean，則使用它創建一個Bean實例對象，
//如果調用本身就想獲得一個容器的引用，則指定返回這個工廠Bean實例對象
//如果指定的名稱是容器的解引用(dereference，即是對象本身而非內存地址)，且Bean實例也不是創建Bean實例對象的FactoryBean
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
//如果Bean實例不是工廠Bean或者是指定名稱的FactoryBean則直接返回，
//調用者向獲取對容器的引用，則直接返回當前的Bean實例
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
//處理指定名稱不是容器的解引用，或者根據名稱獲取的Bean實例對象是一個工廠Bean
//使用工廠Bean創建一個Bean的實例對象
Object object = null;
if (mbd == null) {
//從Bean工廠緩存中獲取給定名稱的Bean實例對象
object = getCachedObjectForFactoryBean(beanName);
}
//讓Bean工廠生產給定名稱的Bean對象實例
if (object == null) {
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
//如果從BeanFactory生產的Bean是單態模式的，則緩存
if (mbd == null && containsBeanDefinition(beanName)) {
//從容器中獲取指定名稱的Bean定義，如果繼承基類，則合併基類相關屬性
mbd = getMergedLocalBeanDefinition(beanName);
}
//如果從容器得到Bean定義信息，並且Bean定義信息不是虛構的，
//則讓工廠Bean生產Bean實例對象
boolean synthetic = (mbd != null && mbd.isSynthetic());
//實現工廠Bean生產Bean對象實例的過程
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
不同生命週期的都通過 create() 方法進行實例化和依賴注入，跳轉到AbstractAutowireCapableBeanFactory.create() 方法。
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// 判斷需要創建的Bean是否可以實例化，即是否可以通過當前的類加載器加載
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
//驗證及準備覆蓋的方法
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// 如果Bean配置了初始化後的處理器，則返回一個需要創建Bean的代理對象
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
//創建bean的入口
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
繼續跟進 doCreateBean 方法，這個方法纔是真正完成 Bean 實例化和依賴注入。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
//封裝被創建的Bean對象
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//根據指定bean使用對應的策略創建實例對象，如：指定的工廠方法、根據參數選擇構造函數、默認無參構造方法
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
//獲取實例化對象的類型
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
//允許後處理器修改合併的bean定義。
//調用MergedBeanDefinitionPostProcessor後置處理器
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// 向容器中緩存單例模式的Bean對象，以防止循環引用
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//爲避免後期循環依賴，儘早持有對象的引用
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
//Bean對象的初始化，依賴注入在此觸發，這個對象在初始化完成之後返回依賴注入完成後的Bean
Object exposedObject = bean;
try {
//將Bean實例對象封裝，並且將Bean定義中配置的屬性值賦給實例對象
populateBean(beanName, mbd, instanceWrapper);
//初始化Bean對象,Bean實例對象的依賴注入完成之後，爲Bean實例對象應用BeanPostProcessor後置處理器
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
//獲取指定名稱的已註冊的單例模式的Bean對象
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
//根據名稱獲取已註冊的Bean和正在實例化的Bean是同一個
if (exposedObject == bean) {
//當前實例化的Bean初始化完成
exposedObject = earlySingletonReference;
}
//當前Bean依賴其他Bean已經注入完成並且當發生循環引用時不允許創建新的實例對象
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
//獲取依賴於指定bean的所有bean的名稱
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
//遍歷當前Bean所依賴的其他Bean
for (String dependentBean : dependentBeans) {
//對依賴Bean進行類型檢查，判斷是否已經創建過
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// 註冊完成依賴注入的Bean
try {
//註冊destroy方法在工廠關閉時調用
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
這裏主要通過三個方法組成：
- 調用 createBeanInstance 方法進行實例化對象
- 調用 populateBean 方法進行依賴注入
- 調用 initializeBean 方法執行 BeanPostProcessor 後置處理器
實例化
我們依次進行查看，先來看 createBeanInstance 方法：
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 確認Bean是可實例化的
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// 判斷bean的訪問是否是public級別
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
}
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
//調用工廠方法進行實例化
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// 使用容器的自動裝配方法進行實例化
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
//一個類有多個構造函數，每個構造函數都會不同的參數，所以調用前需要先根據參數縮影構造函數和對應的工廠方法
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
if (autowireNecessary) {
//配置了自動裝配屬性，使用容器的自動裝配進行實例化，容器的自動裝配根據參數類型匹配Bean的構造方法
return autowireConstructor(beanName, mbd, null, null);
}
else {
//使用默認構造函數構造
return instantiateBean(beanName, mbd);
}
}
// 使用Bean的構造方法進行實例化
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
//使用容器的自動裝配特性，調用匹配的構造方法進行實例化
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction?
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
//使用默認構造函數構造
return instantiateBean(beanName, mbd);
}
可以看到這裏分別調用自動注入構造方法 autowireConstructor 和默認無參構造方法 instantiateBean 進行實例化 Bean 對象。
具體實例化過程就不做展開，代碼確實有點多容易暈。如果確實有人想要了解的話可以在底下留言，博主後期再進行補充。
依賴注入
接着我們來看依賴注入的 populateBean 方法，
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
if (bw == null) {
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
return;
}
}
// 在設置屬性之前，給所有InstantiationAwareBeanPostProcessor機會修改bean的狀態。例如，它可以用於支持字段注入的樣式。
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
//獲取容器在解析Bean定義資源時爲BeanDefinition設置的屬性值
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
//對依賴注入處理，首先處理autowiring自動裝配的依賴注入（此處的自動裝配的依賴注入針對的是 XML 配置文件中的<Bean>下面的屬性配置）
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
//根據Bean名稱進行autowiring自動裝配處理
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
//根據Bean類型進行autowiring自動裝配處理
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
//獲取autowiring自動裝配後的屬性值，繼續注入其他屬性
pvs = newPvs;
}
//對非autowiring的屬性進行依賴注入處理
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//@Autowired、@Value、@Inject等注入註解就是在此處進入進行實現(AutowiredAnnotationBeanPostProcessor)
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
checkDependencies(beanName, mbd, filteredPds, pvs);
}
if (pvs != null) {
//對屬性進行注入
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
此處有關於@Autowried 註解的原理就不做展示，同樣在後面的問題單獨拎出來分析實現原理。
該方法統一將自動依賴注入和其他屬性收集到 PropertyValues 對象中，最後統一進行賦值。
我們來看下自動裝配的依賴注入是如何完成的，先來看通過 Bean 名稱進行自動裝配處理的 autowireByName 方法。
protected void autowireByName(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
//對Bean對象中非簡單屬性(不是簡單繼承的對象，如原始類型，字符串，URL等都是簡單屬性)進行處理
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
//如果Spring IOC容器中包含指定名稱的Bean
if (containsBean(propertyName)) {
//調用getBean方法向IOC容器索取指定名稱的Bean實例，迭代觸發屬性的初始化和依賴注入
Object bean = getBean(propertyName);
//爲指定名稱的屬性賦予屬性值
pvs.add(propertyName, bean);
//指定名稱屬性註冊依賴Bean名稱，進行屬性依賴注入
registerDependentBean(propertyName, beanName);
if (logger.isTraceEnabled()) {
logger.trace("Added autowiring by name from bean name '" + beanName +
"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
"' by name: no matching bean found");
}
}
}
}
根據類型進行自動依賴的方法 autowireByType，源碼如下：
protected void autowireByType(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
//獲取用戶定義的類型轉換器
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
//存放解析的要注入的屬性
Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
//對Bean對象中非簡單屬性(不是簡單繼承的對象，如原始類型，字符，URL等都是簡單屬性)進行處理
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
try {
//獲取指定屬性名稱的屬性描述器
PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
//不對Object類型的屬性進行按類型自動依賴注入
if (Object.class != pd.getPropertyType()) {
//獲取屬性的setter方法
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
//檢查指定類型是否可以被轉換爲目標對象的類型
boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
//創建一個要被注入的依賴描述
DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
//根據容器的Bean定義解析依賴關係，返回所有要被注入的Bean對象
Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
if (autowiredArgument != null) {
//爲屬性賦值所引用的對象
pvs.add(propertyName, autowiredArgument);
}
for (String autowiredBeanName : autowiredBeanNames) {
//指定名稱屬性註冊依賴Bean名稱，進行屬性依賴注入
registerDependentBean(autowiredBeanName, beanName);
if (logger.isTraceEnabled()) {
logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +
propertyName + "' to bean named '" + autowiredBeanName + "'");
}
}
//釋放已自動注入的屬性
autowiredBeanNames.clear();
}
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
}
}
我們來看下最後是如何完成屬性注入的
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
if (pvs.isEmpty()) {
return;
}
if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
//設置安全上下文
((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
}
//封裝屬性值
MutablePropertyValues mpvs = null;
List<PropertyValue> original;
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
//屬性值已經轉換
if (mpvs.isConverted()) {
try {
//爲實例化對象設置屬性值
bw.setPropertyValues(mpvs);
return;
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
//獲取屬性值對象的原始類型值
original = mpvs.getPropertyValueList();
}
else {
original = Arrays.asList(pvs.getPropertyValues());
}
//獲取用戶自定義的類型轉換
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
//創建一個Bean定義屬性值解析器，將Bean定義中的屬性值解析爲Bean實例對象的實際值
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
// Create a deep copy, resolving any references for values.
//爲屬性的解析值創建一個副本，將副本的數據注入實例對象
List<PropertyValue> deepCopy = new ArrayList<>(original.size());
boolean resolveNecessary = false;
for (PropertyValue pv : original) {
//屬性值不需要轉換
if (pv.isConverted()) {
deepCopy.add(pv);
}
//屬性值需要轉換
else {
String propertyName = pv.getName();
//原始的屬性值，即轉換之前的屬性值
Object originalValue = pv.getValue();
//轉換後的屬性值
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
Object convertedValue = resolvedValue;
//屬性值是否可以轉換
boolean convertible = bw.isWritableProperty(propertyName) &&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) {
//使用用戶自定義的類型轉換器轉換屬性值
convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
}
//存儲轉換後的屬性值，避免每次屬性注入時的轉換工作
if (resolvedValue == originalValue) {
if (convertible) {
//設置屬性轉換之後的值
pv.setConvertedValue(convertedValue);
}
deepCopy.add(pv);
}
//屬性是可轉換的，且屬性原始值是字符串類，屬性的原始類型值不是動態生成的字符串，屬性的原始值不是集合或者數組類型的
else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() &&
!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
pv.setConvertedValue(convertedValue);
//重新封裝屬性值
deepCopy.add(pv);
}
else {
resolveNecessary = true;
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
if (mpvs != null && !resolveNecessary) {
//標記屬性值已經轉換過
mpvs.setConverted();
}
// Set our (possibly massaged) deep copy.
//進行屬性的依賴注入
try {
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
實際上就是通過反射完成屬性注入的，具體就不做展開。
執行後置處理器
在完成了實例化和依賴注入後，我們接着來看看是如何調用 BeanPostProcessor 後置處理器的。看方法 initializeBean 源碼：
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
//JDK的安全機制驗證權限
if (System.getSecurityManager() != null) {
//通過匿名內部類根據實例化策略創建實例對象
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
//將實例化的對象信息封裝起來，如bean名稱，類加載器，所屬容器等信息
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
//調用BeanPostProcessor後置處理器的回調方法，在Bean實例初始化前做一些處理
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
//通過反射調用Bean實例的初始化方法，這個初始化方法是在init-method指定的
try {
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
//調用BeanPostProcessor後置處理器的回調方法，在Bean實例初始化之後做一些處理
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
可以看到 BeanPostProcessor 的 postProcessBeforeInitialization 和postProcessAfterInitialization 方法就是在初始化方法前後完成循環調用的。循環代碼如下：
//調用BeanPostProcessor後置處理器實例初始化之前的處理方法
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
//遍歷容器爲所創建的Bean添加所有BeanPortProcessor後置處理器
for (BeanPostProcessor processor : getBeanPostProcessors()) {
//調用Bean實例所有後置處理中初始化前的處理方法，爲Bean實例對象在初始化之前做一些自定義的處理
Object current = processor.postProcessBeforeInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
//調用BeanPostProcessor後置處理器實例初始化之後的處理方法
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
//遍歷容器爲所創建的Bean添加所有BeanPostProcessor後置處理器
for (BeanPostProcessor processor : getBeanPostProcessors()) {
//調用Bean實例所有的後置處理中初始化後的處理方法，爲Bean實例對象在初始化之後做一些自定義的處理
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
至此我們自己完成了實例化、依賴注入和執行後置處理器的整體流程，得到了一個可用的 Bean 對象。
總結
我們可以知道 Bean 的完整生命週期
（1）實例化Bean：
對於BeanFactory容器，當客戶向容器請求一個尚未初始化的bean時，或初始化bean的時候需要注入另一個尚未初始化的依賴時，容器就會調用createBean進行實例化。對於ApplicationContext 容器，當容器啓動結束後，通過獲取BeanDefinition對象中的信息，實例化所有的bean。
（2）設置對象屬性（依賴注入）：
實例化後的對象被封裝在BeanWrapper對象中，緊接着，Spring根據BeanDefinition中的信息 以及通過BeanWrapper提供的設置屬性的接口完成依賴注入。
（3）處理Aware接口：
Spring會檢測該對象是否實現了xxxAware接口，並將相關的xxxAware實例注入給Bean：
①如果這個Bean已經實現了BeanNameAware接口，會調用它實現的setBeanName(String beanId)方法，此處傳遞的就是Spring配置文件中Bean的id值；
②如果這個Bean已經實現了BeanFactoryAware接口，會調用它實現的setBeanFactory()方法，傳遞的是Spring工廠自身。
③如果這個Bean已經實現了ApplicationContextAware接口，會調用setApplicationContext(ApplicationContext)方法，傳入Spring上下文；
（4）BeanPostProcessor：
如果想對Bean進行一些自定義的處理，那麼可以讓Bean實現了BeanPostProcessor接口，那將會調用postProcessBeforeInitialization(Object obj, String s)方法。
（5）InitializingBean 與 init-method：
如果Bean實現InitializingBean接口，則直接調用afterPropertiesSet方法。例如執行自定義初始化或僅檢查所有必需屬性是否已設置。
如果Bean在Spring配置文件中配置了 init-method 屬性，則會自動調用其配置的初始化方法。
（6）如果這個Bean實現了BeanPostProcessor接口，將會調用postProcessAfterInitialization(Object obj, String s)方法；由於這個方法是在Bean初始化結束時調用的，所以可以被應用於內存或緩存技術；
以上幾個步驟完成後，Bean就已經被正確創建了，之後就可以使用這個Bean了。
（7）DisposableBean：
當Bean不再需要時，會經過清理階段，如果Bean實現了DisposableBean這個接口，會調用其實現的destroy()方法；
（8）destroy-method：
最後，如果這個Bean的Spring配置中配置了destroy-method屬性，會自動調用其配置的銷燬方法。