Also supports JSR-330's {@link javax.inject.Inject @Inject} annotation, * if available. */ @SuppressWarnings("unchecked") public AutowiredAnnotationBeanPostProcessor() { this.autowiredAnnotationTypes.add(Autowired.class); this.autowiredAnnotationTypes.add(Value.class); try { this.autowiredAnnotationTypes.add((Class) ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader())); logger.trace("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring"); } catch (ClassNotFoundException ex) { // JSR-330 API not available - simply skip. } } } ``` 可以看到會新增 `@Autowired` 和 `@Value` 兩個註解，如果存在 JSR-330 的 `javax.inject.Inject` 註解，也是支援的 #### postProcessMergedBeanDefinition 方法 `postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class beanType, String beanName)` 方法，找到 `@Autowired` 和 `@Value` 註解標註的欄位（或方法）的元資訊，如下： ```java @Override public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class beanType, String beanName) { // 找到這個 Bean 所有需要注入的屬性（@Autowired 或者 @Value 註解） InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null); metadata.checkConfigMembers(beanDefinition); } ``` 直接呼叫 `findAutowiringMetadata(...)` 方法獲取這個 Bean 的**注入元資訊物件** ##### 1. findAutowiringMetadata 方法 ```java private InjectionMetadata findAutowiringMetadata(String beanName, Class clazz, @Nullable PropertyValues pvs) { // Fall back to class name as cache key, for backwards compatibility with custom callers. // 生成一個快取 Key String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName()); // Quick check on the concurrent map first, with minimal locking. // 先嚐試從快取中獲取 InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey); if (InjectionMetadata.needsRefresh(metadata, clazz)) { // 是否需要重新整理，也就是判斷快取是否命中 synchronized (this.injectionMetadataCache) { metadata = this.injectionMetadataCache.get(cacheKey); if (InjectionMetadata.needsRefresh(metadata, clazz)) { // 加鎖，再判斷一次 if (metadata != null) { metadata.clear(pvs); } // 構建一個需要注入的元資訊物件 metadata = buildAutowiringMetadata(clazz); this.injectionMetadataCache.put(cacheKey, metadata); } } } return metadata; } ``` 首先嚐試從快取中獲取這個 Bean 對應的**注入元資訊物件**，沒有找到的話則呼叫 `buildAutowiringMetadata(final Class clazz)` 構建一個，然後再放入快取中 ##### 2. buildAutowiringMetadata 方法 ```java private InjectionMetadata buildAutowiringMetadata(final Class clazz) { List elements = new ArrayList<>(); Class targetClass = clazz; do { // <1> 建立 `currElements` 集合，用於儲存 @Autowired、@Value 註解標註的欄位 final List currElements = new ArrayList<>(); // <2> 遍歷這個 Class 物件的所有欄位 ReflectionUtils.doWithLocalFields(targetClass, field -> { // <2.1> 找到該欄位的 @Autowired 或者 @Value 註解，返回 `ann` 物件，沒有的話返回空物件，則直接跳過不進行下面的操作 AnnotationAttributes ann = findAutowiredAnnotation(field); if (ann != null) { // <2.2> 進行過濾，static 修飾的欄位不進行注入 if (Modifier.isStatic(field.getModifiers())) { if (logger.isInfoEnabled()) { logger.info("Autowired annotation is not supported on static fields: " + field); } return; } // <2.3> 獲取註解中的 `required` 配置 boolean required = determineRequiredStatus(ann); // <2.4> 根據該欄位和 `required` 構建一個 AutowiredFieldElement 物件，新增至 `currElements` currElements.add(new AutowiredFieldElement(field, required)); } }); // <3> 遍歷這個 Class 物件的所有方法 ReflectionUtils.doWithLocalMethods(targetClass, method -> { // <3.1> 嘗試找到這個方法的橋接方法，沒有的話就是本身這個方法 Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method); // <3.2> 如果是橋接方法則直接跳過 if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) { return; } // <3.3> 找到該方法的 @Autowired 或者 @Value 註解，返回 `ann` 物件，沒有的話返回空物件，則直接跳過不進行下面的操作 AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod); if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) { // <3.4> 進行過濾，static 修飾的方法不進行注入 if (Modifier.isStatic(method.getModifiers())) { if (logger.isInfoEnabled()) { logger.info("Autowired annotation is not supported on static methods: " + method); } return; } if (method.getParameterCount() == 0) { if (logger.isInfoEnabled()) { logger.info("Autowired annotation should only be used on methods with parameters: " + method); } } // <3.5> 獲取註解中的 `required` 配置 boolean required = determineRequiredStatus(ann); PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz); // <3.6> 構建一個 AutowiredMethodElement 物件，新增至 `currElements` currElements.add(new AutowiredMethodElement(method, required, pd)); } }); elements.addAll(0, currElements); // <4> 找到父類，迴圈遍歷 targetClass = targetClass.getSuperclass(); } while (targetClass != null && targetClass != Object.class); // <5> 根據從這個 Bean 解析出來的所有 InjectedElement 物件生成一個 InjectionMetadata 注入元資訊物件，並返回 return new InjectionMetadata(clazz, elements); } ``` 過程如下： 1. 建立 `currElements` 集合，用於儲存 `@Autowired`、`@Value` 註解標註的欄位 2. 遍歷這個 Class 物件的所有欄位 1. 找到該欄位的 `@Autowired` 或者 `@Value` 註解，返回 `ann` 物件，沒有的話返回空物件，則直接跳過不進行下面的操作 2. 進行過濾，static 修飾的欄位不進行注入 3. 獲取註解中的 `required` 配置 4. 根據該欄位和 `required` 構建一個 AutowiredFieldElement 物件，新增至 `currElements` 3. 遍歷這個 Class 物件的所有方法 1. 嘗試找到這個方法的橋接方法，沒有的話就是本身這個方法 2. 如果是橋接方法則直接跳過 3. 找到該方法的 `@Autowired` 或者 `@Value` 註解，返回 `ann` 物件，沒有的話返回空物件，則直接跳過不進行下面的操作 4. 進行過濾，static 修飾的方法不進行注入 5. 獲取註解中的 `required` 配置 6. 構建一個 AutowiredMethodElement 物件，新增至 `currElements` 4. 找到父類，迴圈遍歷 5. 根據從這個 Bean 解析出來的所有 InjectedElement 物件生成一個 InjectionMetadata 注入元資訊物件，並返回 整個過程很簡單，就是解析出所有 `@Autowired` 或者 `@Value` 註解標註的方法或者欄位，然後構建一個 InjectionMetadata 注入元資訊物件 #### postProcessProperties 方法 `postProcessProperties(PropertyValues pvs, Object bean, String beanName)` 方法，根據 `@Autowired` 和 `@Value` 註解標註的欄位（或方法）的元資訊進行**依賴注入**，如下： ```java @Override public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) { // 找到這個 Bean 的注入元資訊物件 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; } ``` 先找到這個 Bean 的注入元資訊物件，上面已經講過了，然後呼叫其 `inject(...)` 方法，這裡先來看到 `InjectionMetadata` 這個物件 ### InjectionMetadata 注入元資訊物件 `org.springframework.beans.factory.annotation.InjectionMetadata`，某個 Bean 的注入元資訊物件 ```java public class InjectionMetadata { private static final Log logger = LogFactory.getLog(InjectionMetadata.class); private final Class targetClass; /** * 需要注入的欄位（或方法）的元資訊 */ private final Collection injectedElements; @Nullable private volatile Set checkedElements; public InjectionMetadata(Class targetClass, Collection elements) { this.targetClass = targetClass; this.injectedElements = elements; } public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable { Collection checkedElements = this.checkedElements; Collection elementsToIterate = (checkedElements != null ? checkedElements : this.injectedElements); if (!elementsToIterate.isEmpty()) { for (InjectedElement element : elementsToIterate) { if (logger.isTraceEnabled()) { logger.trace("Processing injected element of bean '" + beanName + "': " + element); } element.inject(target, beanName, pvs); } } } } ``` 可以看到注入方法非常簡單，就是遍歷所有的 InjectedElement 物件，呼叫他們的 `inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs)` 方法 ### AutowiredFieldElement AutowiredAnnotationBeanPostProcessor 的私有內部類，注入欄位物件，如下： ```java private class AutowiredFieldElement extends InjectionMetadata.InjectedElement { /** 是否必須 */ private final boolean required; /** 是否快取起來了 */ private volatile boolean cached = false; /** 快取的物件 */ @Nullable private volatile Object cachedFieldValue; public AutowiredFieldElement(Field field, boolean required) { super(field, null); this.required = required; } @Override protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable { // <1> 獲取 `field` 欄位 Field field = (Field) this.member; Object value; // <2> 如果進行快取了，則嘗試從快取中獲取 if (this.cached) { value = resolvedCachedArgument(beanName, this.cachedFieldValue); } // <3> 否則，開始進行解析 else { // <3.1> 建立一個依賴注入描述器 `desc` DependencyDescriptor desc = new DependencyDescriptor(field, this.required); desc.setContainingClass(bean.getClass()); Set autowiredBeanNames = new LinkedHashSet<>(1); Assert.state(beanFactory != null, "No BeanFactory available"); TypeConverter typeConverter = beanFactory.getTypeConverter(); try { /** * <3.2> 通過 {@link org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveDependency} 方法 * 找到這個欄位對應的 Bean（們） */ value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter); } catch (BeansException ex) { throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex); } // <3.3> 和快取相關，如果有必要則將本次找到的注入物件快取起來，避免下次再進行解析 synchronized (this) { if (!this.cached) { if (value != null || this.required) { this.cachedFieldValue = desc; registerDependentBeans(beanName, autowiredBeanNames); if (autowiredBeanNames.size() == 1) { String autowiredBeanName = autowiredBeanNames.iterator().next(); if (beanFactory.containsBean(autowiredBeanName) && beanFactory.isTypeMatch(autowiredBeanName, field.getType())) { this.cachedFieldValue = new ShortcutDependencyDescriptor( desc, autowiredBeanName, field.getType()); } } } else { this.cachedFieldValue = null; } this.cached = true; } } } // <4> 如果獲取到該欄位對應的物件，則進行屬性賦值（依賴注入） if (value != null) { ReflectionUtils.makeAccessible(field); field.set(bean, value); } } } ``` 直接看到 `inject(...)` 方法，注入的過程如下： 1. 獲取 `field` 欄位 2. 如果進行快取了，則嘗試從快取中獲取 3. 否則，開始進行解析 1. 建立一個依賴注入描述器 `desc` 2. **【核心】**通過 `DefaultListableBeanFactory#resolveDependency(...)` 方法，找到這個欄位對應的 Bean（們） 3. 和快取相關，如果有必要則將本次找到的注入物件快取起來，避免下次再進行解析 4. 如果獲取到該欄位對應的物件，則進行屬性賦值（**依賴注入**），底層就是通過反射機制為該欄位賦值 可以看到整個的**核心**在於通過 `DefaultListableBeanFactory#resolveDependency(...)` 方法找到欄位對應的 Bean，這裡也許是一個集合物件，所以也可能找到的是多個 Bean，該方法在後面進行分析 ### AutowiredMethodElement AutowiredAnnotationBeanPostProcessor 的私有內部類，注入方法物件，如下： ```java private class AutowiredMethodElement extends InjectionMetadata.InjectedElement { /** 是否必須 */ private final boolean required; /** 是否快取起來了 */ private volatile boolean cached = false; /** 快取的方法引數物件 */ @Nullable private volatile Object[] cachedMethodArguments; public AutowiredMethodElement(Method method, boolean required, @Nullable PropertyDescriptor pd) { super(method, pd); this.required = required; } @Override protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable { if (checkPropertySkipping(pvs)) { return; } // <1> 獲取 `method` 方法 Method method = (Method) this.member; // <2> 如果進行快取了，則嘗試從快取中獲取方法引數物件 Object[] arguments; if (this.cached) { // Shortcut for avoiding synchronization... arguments = resolveCachedArguments(beanName); } // <3> 否則，開始進行解析 else { // <3.1> 獲取方法的引數型別集合 `paramTypes`，根據引數位置確定引數 Class[] paramTypes = method.getParameterTypes(); arguments = new Object[paramTypes.length]; // <3.2> 構建一個依賴注入描述器陣列 `descriptors`，用於儲存後續建立的物件 DependencyDescriptor[] descriptors = new DependencyDescriptor[paramTypes.length]; Set autowiredBeans = new LinkedHashSet<>(paramTypes.length); Assert.state(beanFactory != null, "No BeanFactory available"); TypeConverter typeConverter = beanFactory.getTypeConverter(); // <3.3> 根據引數順序遍歷該方法的引數 for (int i = 0; i < arguments.length; i++) { // <3.3.1> 為第 `i` 個方法引數建立一個 MethodParameter 物件 MethodParameter methodParam = new MethodParameter(method, i); // <3.3.2> 建立依賴描述器 `currDesc`，並新增至 `descriptors` 陣列 DependencyDescriptor currDesc = new DependencyDescriptor(methodParam, this.required); currDesc.setContainingClass(bean.getClass()); descriptors[i] = currDesc; try { /** * <3.3.3> 通過 {@link org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveDependency} 方法 * 找到這個方法引數對應的 Bean（們） */ Object arg = beanFactory.resolveDependency(currDesc, beanName, autowiredBeans, typeConverter); if (arg == null && !this.required) { arguments = null; break; } arguments[i] = arg; } catch (BeansException ex) { throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(methodParam), ex); } } // <3.4> 和快取相關，如果有必要則將本次找到的方法引數物件快取起來，避免下次再進行解析 synchronized (this) { if (!this.cached) { if (arguments != null) { Object[] cachedMethodArguments = new Object[paramTypes.length]; System.arraycopy(descriptors, 0, cachedMethodArguments, 0, arguments.length); registerDependentBeans(beanName, autowiredBeans); if (autowiredBeans.size() == paramTypes.length) { Iterator it = autowiredBeans.iterator(); for (int i = 0; i < paramTypes.length; i++) { String autowiredBeanName = it.next(); if (beanFactory.containsBean(autowiredBeanName) && beanFactory.isTypeMatch(autowiredBeanName, paramTypes[i])) { cachedMethodArguments[i] = new ShortcutDependencyDescriptor( descriptors[i], autowiredBeanName, paramTypes[i]); } } } this.cachedMethodArguments = cachedMethodArguments; } else { this.cachedMethodArguments = null; } this.cached = true; } } } // <4> 如果找到該方法的引數（們），則進行屬性賦值（依賴注入） if (arguments != null) { try { ReflectionUtils.makeAccessible(method); // 通過反射機制呼叫該方法 method.invoke(bean, arguments); } catch (InvocationTargetException ex) { throw ex.getTargetException(); } } } } ``` 直接看到 `inject(...)` 方法，注入的過程如下： 1. 獲取 `method` 方法 2. 如果進行快取了，則嘗試從快取中獲取方法引數物件 3. 否則，開始進行解析 1. 獲取方法的引數型別集合 `paramTypes`，根據引數位置確定引數 2. 構建一個依賴注入描述器陣列 `descriptors`，用於儲存後續建立的物件 3. 根據引數順序遍歷該方法的引數 1. 為第 `i` 個方法引數建立一個 MethodParameter 物件 2. 建立依賴描述器 `currDesc`，並新增至 `descriptors` 陣列 3. **【核心】**通過 `DefaultListableBeanFactory#resolveDependency(...)` 方法，找到這個方法引數對應的 Bean（們） 4. 和快取相關，如果有必要則將本次找到的方法引數物件快取起來，避免下次再進行解析 4. 如果找到該方法的引數（們），則進行屬性賦值（**依賴注入**），底層就是通過反射機制呼叫該方法 可以看到整個的**核心**也是通過 `DefaultListableBeanFactory#resolveDependency(...)` 方法找到方法引數對應的 Bean，該方法在後面進行分析 ### CommonAnnotationBeanPostProcessor `org.springframework.context.annotation.CommonAnnotationBeanPostProcessor`，主要處理 `@Resource` 註解進行依賴注入，以及 `@PostConstruct` 和 `@PreDestroy` 生命週期註解的處理 #### 體系結構