@TOC# Spring系列
記錄在程式走的每一步___auth:huf
回復:
在文章的前面會 回復一些同學的疑問 注意 在使用InstantiationAwareBeanPostProcessor 的時候 如果return 回傳值 不寫; 此時正在創建物件程序當中; 這時候 會導致 該物件里面的@Autowired 注入失敗; 物件不完整; 這時候請注意 InstantiationAwareBeanPostProcessor 的寫法; 因為此時你 正在介入Bean的 實體化;
Spring 依賴注入
此處作為一個Spring的一個新的篇章; Bean的生命周期已經在上面的篇幅已經陳述完了 ; 現在進入新的篇章 Spring 依賴注入;
首先來一個 二連問:
第一問: 依賴注入有幾種方式?
在面試中; 該問題不會經常被問到; 但是如果問這個問題的人 可以看出 該面試官 對Spring 肯定是有一定理解的; 你怎么答這個問題才能體現自己對Spring的理解?
Spring中 分兩種 依賴注入的方式:
1 手動注入
為什么會談先手動注入; 在很久很久以前; 我們再Spring中寫注入的時候; 我們是再XML檔案里面寫注入的;我當時在一家跟政府合作的企業中進行開發; 那里的組態檔 體量非常非常大 一個檔案少說有幾千行配置在里面; 里面用的方式 就是XML 注入方式;手動注入; 當時也遇到了人生中的第一位導師~而且是女導師 偏了… 繼續~
1:通過set的方式注入;
<bean name="studentService" class="com.huf.service.impl.StudentServiceImpl">
<property name="studentMapper" ref="studentMapper"/>
</bean>
2:通過構造方法方式注入;
<bean name="studentService" class="com.huf.service.impl.StudentServiceImpl">
<constructor‐arg index="0" ref="studentMapper"/>
</bean>
所以手動注入的方式 再分兩種 : 一: 通過set方式注入; 二:通過構造方式注入;
2 自動注入
1: XML的 autowire 自動注入;
在XML的bean標簽中 有一個屬性; 是autowire 里面有幾個引數 :
1). byType 2). byName 3). constructor 4). default 5). no
<bean name="studentService" class="com.huf.service.impl.StudentServiceImpl" autowire = "byType">
</bean>
這么寫，表示Spring會自動的給userService中所有的屬性自動賦值（不需要這個屬性上有 @Autowired注解，但需要這個屬性有對應的set方法）
以上這些方式 感興趣的朋友可以一個一個去嘗試; 該篇文章 比較長; 這里就不做過多的演示;
原始碼: 在創建Bean的程序當中 在填充屬性的時候.Spring會去決議當前這個類的所有方法;在決議的程序當中 Spring會得到 PropertyDescriptor 叫做屬性描述器的類 這個類的作用 就是描述 某個屬性的 get 與 set 方法; PropertyDescriptor 是java.bean 的一個類; 有喜歡的小伙伴 可以自己去查看以下; 這個類挺方便的; 以下就是我自己個人 使用這個類的一個簡單實體:
通過屬性名字 以及 類class 創建PropertyDescriptor
PropertyDescriptor pd = new PropertyDescriptor(declaredField.getName(), clazz);
通過這個類可以得到Method方法; 這是讀方法 也就是get
Method method = pd.getReadMethod();
Object invoke = method.invoke(obj);
String v = execute((String) invoke, maskStr, staNumber, endNumber);
這是寫方法 也就是set;
pd.getWriteMethod().invoke(obj, v);
重點
2:@Autowired注解的自動注入; 我們重點關注的Autowired
Essentially, the @Autowired annotation provides the same
capabilities as described in Autowiring Collaborators but with more
fine‐grained control and wider applicability
先看這一段 本質上 @Autowired 提供了相同的功能; 但是擁有更細粒度的控 制和更廣泛的適用性;
@Autowired 作用更細粒度;
XML中的autowire控制的是整個bean的所有屬性，而@Autowired注解是直接寫在某個屬性、某個 set方法、某個構造方法上的; @Autowired 是Xml當中 ByType 與 ByName的結合
先根據屬性型別去找Bean，如果找到多個再根據屬性名確定一個
@Autowired
private StudentMapper studentMapper;
先根據方法引數型別去找Bean，如果找到多個再根據引數名確定一個
@Autowired
public void setStudentMapper (StudentMapper studentMapper){
}
先根據方法引數型別去找Bean，如果找到多個再根據引數名確定一個
@Autowired
public StudentServiceImpl(StudentMapper studentMapper) {
}
- 屬性注入
- set方法注入
- 構造方法注入
以上就是 我們的理論知識點;
第二問 @Autowired 是怎么注入進來的?
我們在第一問講了 是根據型別先找 然后再根據名字選出; 那么 是怎么找的? 我們帶著疑問 一起來一探究竟
以上 就是簡簡單單的一個注入; 在我們Spring進行生命周期的時候 會通過RootBeanDefinition 以及 非常多的BeanPostProcessor 實體化 以及 初始化這個類; 實體化就是創建這個Bean 在創建完成之后 經過初始化; 完成整個Bean的 構建 最后保存在單例池里 這里 就是Bean創建完成之后的代碼 也就是 屬性注入;
以下原始碼中穿插自己對原始碼的見解; 原始碼是Spring 5.3.5 版本的;
現在我們以Debug的方式 進行依賴注入代碼追蹤;
前面的省… 在 AbstractBeanFactory 在這個類中: doGetBean方法中 我們可以體會到整個Bean的創建流程; 上一章節我們在 該原始碼中說道 有興趣的 調到上面一個章節 直接搜索 doCreateBean 里面寫到;
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
開始實體化Bean
BeanWrapper instanceWrapper = null;
判斷Bean是不是單例的 如果是
if (mbd.isSingleton()) {
先從Factory 洗掉Bean; 這里 就是個ConcurrentMap 也就是洗掉正在創建的Bean的包裝物件;
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
洗掉了之后 是不是null; 然后開始createBeanInstance
if (instanceWrapper == null) {
開始進入createBeanInstance
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
以下原始碼暫時不決議; 在之后的篇章會詳細說的; 目前就到這里可以了
-----------------------------------------------------------------------------
這里接上之前的原始碼 把該方法原始碼全部展示完:
獲取 實體化完成的Bean 這時候 Bean里面的屬性是空的
Object bean = instanceWrapper.getWrappedInstance();
獲取了 正在創建的Bean class檔案;
Class<?> beanType = instanceWrapper.getWrappedClass();
這里不用多說也應該可以看明白;
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
這里就是執行我們后置MergedBeanDefinitionPostProcessors 后置處理器的調度方法;
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;
}
}
快取單例，以便能夠決議回圈參考
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的屬性注入;
Object exposedObject = bean;
try {
這個方法 是主要方法;
populateBean(beanName, mbd, instanceWrapper);
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
以下原始碼全部省去; 進入populateBean里面去看看;
}
進入 populateBean
@SuppressWarnings("deprecation")
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
按照慣例 先隱藏前面代碼; 方便閱讀;
前面有說道 會先去拿它的PropertyDescriptor 這個東西是什么作用的 自己去看上面的我寫的案例;
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
回圈當前Bean的 BeanPostProcessor BP
在5.3.5 版本有6個 其他版本可能個數會不一樣
主要的一個BP 是 : AutowiredAnnotationBeanPostProcessor
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
隱藏后面代碼
這個for回圈這個List給你們列印出來
在通過了這個bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
會往BeanWrapper.getWrappedInstance() 這里 保存的值 的記憶體參考 就是單例池里面的相對應需要注入的哪個Bean. 所以 這里將他注入; 那么外面哪個Bean里面就有值了;
AutowiredAnnotationBeanPostProcessor
postProcessProperties
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
顧名思義; 應該可以知道這個方法里面是在做些什么事情;
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
依賴注入核心方法;
metadata.inject(bean, beanName, pvs);
}
catch (BeanCreationException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
return pvs;
}
inject
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
這個原始碼熟吧? 里面的InjectedElement 放著就是 你依賴注入的每一個屬性;
Collection<InjectedElement> checkedElements = this.checkedElements;
Collection<InjectedElement> elementsToIterate =
(checkedElements != null ? checkedElements : this.injectedElements);
if (!elementsToIterate.isEmpty()) {
for (InjectedElement element : elementsToIterate) {
element.inject(target, beanName, pvs);
}
}
}
inject2 進入這個inject的時候要注意; 是這個;
@Override
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
filed就是我們要注入的屬性;
Field field = (Field) this.member;
Object value;
檢查快取
if (this.cached) {
try {
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
}
catch (NoSuchBeanDefinitionException ex) {
value = resolveFieldValue(field, bean, beanName);
}
}
else {
如果沒有快取的情況下 走resolveFieldValue
value = resolveFieldValue(field, bean, beanName);
}
if (value != null) {
ReflectionUtils.makeAccessible(field);
field.set(bean, value);
}
}
resolveFieldValue
最后在上面那個方法中的最后 注入這個屬性;
@Nullable
private Object resolveFieldValue(Field field, Object bean, @Nullable String beanName) {
傳入之后 先看你的required 是否為false;
在Autowired 里面的那個required 表示是否一定要注入;默認為true
DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
desc.setContainingClass(bean.getClass());
Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
Assert.state(beanFactory != null, "No BeanFactory available");
TypeConverter typeConverter = beanFactory.getTypeConverter();
Object value;
try {
通過這個步驟找到了 value
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
}
------省掉部分代碼
回傳這個value;
return value;
}
}
總結
尋找注入點:
在創建一個Bean的程序中，Spring會利用AutowiredAnnotationBeanPostProcessor的 **postProcessMergedBeanDefinition()**找出注入點并快取，找注入點的流程為：
- 遍歷當前類的所有的屬性欄位Field
- 查看欄位上是否存在@Autowired、@Value、@Inject中的其中任意一個，存在則認為該欄位 是一個注入點
- 如果欄位是static的，則不進行注入
- 獲取@Autowired中的required屬性的值
- 將欄位資訊構造成一個AutowiredFieldElement物件，作為一個注入點物件添加到 currElements集合中，
- 遍歷當前類的所有方法Method
- 判斷當前Method是否是橋接方法，如果是找到原方法
- 查看方法上是否存在@Autowired、@Value、@Inject中的其中任意一個，存在則認為該方法 是一個注入點
- 如果方法是static的，則不進行注入
- 獲取@Autowired中的required屬性的值
- 將方法資訊構造成一個AutowiredMethodElement物件，作為一個注入點物件添加到 currElements集合中，
- 遍歷完當前類的欄位和方法后，將遍歷父類的，直到沒有父類
- 最后將currElements集合封裝成一個InjectionMetadata物件，作為當前Bean對于的注入點集合 物件，并快取，
static的欄位或方法為什么不支持
我們假設:
在屬性中 我們的Bean是原型Bean 也就是多例的 那么 他屬性如果用了static會怎么樣? 這個問題如果想明白了 就知道為什么不支持了.
在static修飾的方法中 其字節碼檔案會生成兩個同樣的方法 其中一個方法帶有 synthetic bridge 并且都是存在@Autowired注解的 所以在Spring中需要處理這種情況，當遍歷到橋接方法時，得找到原方法
注入點進行注入
Spring在AutowiredAnnotationBeanPostProcessor的**postProcessProperties()**方法中，會遍 歷所找到的注入點依次進行注入，
欄位注入
- 遍歷所有的AutowiredFieldElement物件
- 將對應的欄位封裝為DependencyDescriptor物件
- 呼叫BeanFactory的resolveDependency()方法，傳入DependencyDescriptor物件，進行依 賴查找，找到當前欄位所匹配的Bean物件，
- 將DependencyDescriptor物件和所找到的結果物件beanName封裝成一個 ShortcutDependencyDescriptor物件作為快取，比如如果當前Bean是原型Bean，那么下次 再來創建該Bean時，就可以直接拿快取的結果物件beanName去BeanFactory中去那bean物件 了，不用再次進行查找了
- 利用反射將結果物件賦值給欄位，
Set方法注入
- 遍歷所有的AutowiredMethodElement物件
- 遍歷將對應的方法的引數，將每個引數封裝成MethodParameter物件
- 將MethodParameter物件封裝為DependencyDescriptor物件
- 呼叫BeanFactory的resolveDependency()方法，傳入DependencyDescriptor物件，進行依 賴查找，找到當前方法引數所匹配的Bean物件，
- 將DependencyDescriptor物件和所找到的結果物件beanName封裝成一個 ShortcutDependencyDescriptor物件作為快取，比如如果當前Bean是原型Bean，那么下次 再來創建該Bean時，就可以直接拿快取的結果物件beanName去BeanFactory中去那bean物件 了，不用再次進行查找了
- 利用反射將找到的所有結果物件傳給當前方法，并執行，
本章節的重點已經全部陳述完成; 如果想聽其他注解的原始碼 可以留言; 如果有時間的話 我會逐一給給同學們解釋清楚;
SEE YOU
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/301953.html
標籤：java