完全搞懂依賴注入(一)Bean實例建立過程

時間 2021-08-12

標籤 php java web spring 緩存安全 session app ide post 欄目設計模式简体版

原文原文鏈接

上一章介紹了Bean的加載過程(IOC初始化過程)，加載完成後，緊接着就要用到它的依賴注入(IOC 依賴注入)。php

那什麼是依賴注入呢?java

所謂依賴注入，就是由IOC容器在運行期間，動態地將某種依賴關係注入到對象之中。再完成IOC容器初始化以後，也就是所謂的Bean加載完成後，咱們須要對這些Bean進行調用和獲取，這個過程就叫依賴注入。web

那何時會觸發依賴注入呢?spring

經過getBean()方法獲取Bean對象。緩存
給Bean配置了懶加載，ApplicationContext啓動完成後調用getBean()來實例化對象。安全

如今計算機性能已經足夠，不是特殊要求下儘可能別作懶加載，這樣的話能夠減小web運行時的調用時間開銷。session

好了，介紹完這些就開始咱們的DI之旅。app

1. BeanFactory

經過Spring獲取Bean的最根本的接口。ide

// 若是myJndiObject時FactoryBean，則 &myJndiObject 將返回工廠而不是返回實例。post
String FACTORY_BEAN_PREFIX = "&";
// 獲取bean實例
Object getBean(String name) throws BeansException;
// 判斷一個bean是否時單例
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
// 判斷一個bean是不是原型
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
// 檢查bean的name和type是否匹配
boolean isTypeMatch(String name, Class targetType) throws NoSuchBeanDefinitionException;
// 獲取bean類型
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
// 獲取bean別名
String[] getAliases(String name);

getBean()方法有不少重載方法，上面只總結了一個。這個方法是DI的入口方法，接下來會從這個方法開始往下研究。

2. AbstractBeanFactory

從名字也能看出，這是BeanFactory的抽象實現類。

public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}

doGetBean()方法也是該類中的方法。

// 依賴注入從這裏開始發生
private <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;
// Eagerly check singleton cache for manually registered singletons.
// 先從緩存中取單例 bean
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
// 若是有，則直接返回該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 的實例對象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
// 若是不是單例對象，並且緩存中有原型模式bean，就拋異常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 檢查 BeanDefinition 是否再當前的factory中，若是不在則委託父類容器取查找
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (args != null) {
// Delegation to parent with explicit args.
// 委託父類容器取找(名字+參數)
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// 委託父類容器取找(名稱+類型)
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
// 標記 bean 被建立
markBeanAsCreated(beanName);
}
// 根據bean名稱獲取父類的 beanDefinition，合併繼承公共屬性
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 獲取當前bean 全部依賴Bean 的集合
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dependsOnBean : dependsOn) {
// 遞歸調用，獲取當前Bean的依賴Bean
getBean(dependsOnBean);
// 把依賴Bean註冊給當前的Bean
registerDependentBean(dependsOnBean, beanName);
}
}
// Create bean instance.
// 建立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) {
// 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.
// 清除該單例
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 若是建立的bean 不是單例也不是原型，則根據聲明週期選擇實例化bean的方法
// 如 request session 等不一樣範圍的實例
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
// 若是 scope 是空，則拋異常
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
}
// 不然
try {
// 獲取一個指定了scope的bean實例
Object scopedInstance = scope.get(beanName, new ObjectFactory() {
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
}
});
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);
}
}
}
// Check if required type matches the type of the actual bean instance.
// 檢查是否須要類型檢測
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return (T) bean;
}

總結如下它都作了什麼事情:

一、根據傳來的 bean的 name(有多是別名)來獲取真正的 bean名稱: beanName。

二、根據 beanName獲取單例實例，若是有直接獲取到 bean實例並返回，DI完成。

三、若是根據 beanName沒有得到到單例實例：

3.1 判斷是否是原型實例，若是是，則拋出建立失敗異常，若是不是，下一步。

3.2 檢查 BeanDefinition 是否在當前的容器中，若是不在那可能在父類容器中，因此委託父類容器查找，若是尚未，則再上一級容器...遞歸查找。

3.3 檢查這個實例是不是爲了類型檢查而獲取，而不是用來使用，若是是，標記這個bean已經被建立，若是不是，下一步。

3.4 根據 beanName獲取 父類的BeanDefinition，並檢查該對象類類型，好比不能是抽象類等。

3.5 根據 beanName獲取全部該 bean依賴的 Bean集合，若是該集合有值，則遍歷DI(遞歸調用 getBean())該 bean集合裏的bean，並把bean註冊給當前的bean(維護了一個 map來存放關係)。

3.6 若是3.4中獲取的 BeanDefinition是單例，則根據該單例對象和 beanName和 args建立一個實例對象；不然，判斷 BeanDefinition是不是原型，若是是則根據 beanName,該對象, args建立一個實例；不然拿到3.4獲取的 BeanDefinition對象的生命週期 Scope,而後根據 scope來建立實例對象，參數 (beanName,bd,args)。

3.7 檢查是否須要類型檢測
3.8 返回`3.1-3.7 `生成的實例。

而後咱們再看看 createBean()方法的實現。

protected abstract Object createBean(String beanName, RootBeanDefinition mbd, Object[] args)
throws BeanCreationException;

3. AbstractAutowireCapableBeanFactory.java

// 建立bean 實例
@Override
protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
// Make sure bean class is actually resolved at this point.
// 解析和肯定 bean 能夠實例化
resolveBeanClass(mbd, beanName);
// Prepare method overrides.
// 準備方法覆蓋
try {
mbd.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 給 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);
}
Object beanInstance = doCreateBean(beanName, mbd, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}

總結如下它都作了什麼:

肯定 beanName和 RootBeanDefinition能夠被實例化。
執行方法覆蓋
看 BeanPostProcessors可否再解析以前獲取到bean，若是能則直接返回，不然下一步。
調用 doCreateBean()方法，獲取 bean實例.

doCreateBean()方法也是該類中的。

// 真正建立bean實例
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
// Instantiat|e the bean.
// 封裝bean
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 若是是單例模式的bean，從容器中獲取同名bean
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
// 若是沒有同名bean，則建立bean實例
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 若是有同名bean，則獲取到封裝實例
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
// 獲取實例化對象類型
Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
// Allow post-processors to modify the merged bean definition.
// 調用後置處理器
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
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");
}
addSingletonFactory(beanName, new ObjectFactory() {
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// Initialize the bean instance.
// bean對象初始化，依賴注入開始，exposedObject就是完成後的bean
Object exposedObject = bean;
try {
// 將bean 實例封裝，而且 bean 定義中配置的屬性值賦值給實例對象
populateBean(beanName, mbd, instanceWrapper);
// 初始化 bean對象
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);
}
}
// 若是指定名稱bean已經註冊單例模式
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
// 若是兩個對象相等， bean初始化完成
exposedObject = earlySingletonReference;
}
// 若是不相等，則找出當前bean的依賴bean
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
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.");
}
}
}
}
// Register bean as disposable.
// 註冊完成依賴注入的bean
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}

一樣，總結如下它乾的事情：

根據 beanName獲取 beanWrapper對象。若是 beanWrapper對象是空，則調用 createBeanInstance()方法建立 bean實例。不然，下一步
經過 beanWrapper對象獲取bean實例和 class類型。
容許 postProcessors 調整組合 BeanDefinition。
若是 RootBeanDefinition是單例而且容許循環引用而且 beanName正在進行單例建立，將 beanName添加到單例工廠。
調用 populateBean()方法給bean的屬性值賦值，而後初始化bean對象並返回建立的bean實例，若是拋異常，則下一步。
若是該 beanName對象已經註冊單例模式，則從單例中獲取，並判斷獲取到的bean實例( B)與 BeanWrapper中的bean實例( A)是同一個實例，若是是，則返回 A或者 B，若是不是，則遞歸找出它的依賴 bean。
返回 1-6產生的 bean實例。

咱們首次獲取bean實例的時候，bean工廠是確定沒有的，因此咱們首次獲取到的BeanWrapper應該是空對象，可是它調用了 createBeanInstance()方法後，能夠看到spring是很肯定它能拿到對象，那麼咱們看看這個方法的實現。它仍然是這個類中的方法。

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
// Make sure bean class is actually resolved at this point.
// 確保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());
}
if (mbd.getFactoryMethodName() != null) {
// 經過工廠方法實例化
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
// 是否有構造器
if (mbd.resolvedConstructorOrFactoryMethod != null && args == null) {
if (mbd.constructorArgumentsResolved) {
return autowireConstructor(beanName, mbd, null, null);
}
else {
return instantiateBean(beanName, mbd);
}
}
// Need to determine the constructor...
// 須要確認構造器
Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
// 自動裝配，調用匹配的構造方法進行實例化
return autowireConstructor(beanName, mbd, ctors, args);
}
// No special handling: simply use no-arg constructor.
// 使用默認無參構造
return instantiateBean(beanName, mbd);
}

這個類用來建立 Bean實例，而後返回 BeanWrapper對象。註釋寫的很詳細了。其中有個 instantiateBean()方法，當沒有參數和構造方法的時候，就會調用該方法來實例化bean。

// 使用默認無參構造方法實例化bean
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
// 獲取JDK安全管理
if (System.getSecurityManager() != null) {
// 根據實例化策略實例化對象
beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
return getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
}, getAccessControlContext());
}
else {
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
// 對實例化對象進行封裝
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}

這個方法是使用默認無參構造方法實例化bean的，它的核心代碼是 getInstantiationStrategy().instantiate(mbd,beanName,parent);,由於它，咱們能夠獲得一個bean實例對象，而後封裝成 BeanWrapper並返回。

4. SimpleInstantiationStrategy.java

用於BeanFactory的簡單對象實例化策略。不支持方法注入，儘管它提供了子類的hook來覆蓋以添加方法注入支持，例如經過重寫方法。

// 使用初始化策略實例化bean
public Object instantiate(
RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
// Don't override the class with CGLIB if no overrides.
// 若是beanDefinition 中沒有方法覆蓋，就用jdk，不然用cglib
if (beanDefinition.getMethodOverrides().isEmpty()) {
// 獲取對象的構造方法和工廠方法
Constructor constructorToUse = (Constructor) beanDefinition.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
// 若是沒有構造方法和工廠方法，使用JDK反射，判斷實例化的bean是否是接口
final Class clazz = beanDefinition.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
// 使用反射獲取bean構造方法
constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor>() {
public Constructor run() throws Exception {
return clazz.getDeclaredConstructor((Class[]) null);
}
});
} else {
constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
}
beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Exception ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
// 使用beanUtils實例化構造方法.newInstance(arg) 來實例化
return BeanUtils.instantiateClass(constructorToUse);
}
else {
//若是有覆蓋或者重寫，則用CGLIB來實例化對象
// Must generate CGLIB subclass.
return instantiateWithMethodInjection(beanDefinition, beanName, owner);
}
}

總結它的步驟：

若是BeanDefinition的覆蓋方法不爲空，則交給CGLIB來實例化對象，不然獲取構造方法和工廠方法，下一步。
若是沒有構造方法和工廠方法，則使用JDK反射，判斷實例化的bean是否是接口，若是是，拋出異常，若是不是，則使用反射來獲取bean的構造方法，最後，用 構造器.newInstance()的方法( BeanUtils.instantiateClass()方法底層實現)來實例化並返回。

那cglib是如何實例化呢，咱們來看下 instantiateWithMethodInjection(beanDefinition,beanName,owner);方法源碼：

@Override
protected Object instantiateWithMethodInjection(
RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
// Must generate CGLIB subclass.
return new CglibSubclassCreator(beanDefinition, owner).instantiate(null, null);
}