DefaultListableBeanFactory

DefaultListableBeanFactory介绍

BeanFactory是个Factory，也就是IOC容器或对象工厂，而DefaultListableBeanFactory是Bean工厂的一个默认实现，DefaultListableBeanFactory提供了原始的BeanFactory的功能，如：对外提供getBean()方法，维护一张beanDefinitionMap表
继承关系

DefaultListableBeanFactory继承关系如下，可以看出DefaultListableBeanFactory尚有子类XmlBeanFactory

接口实现
下图列出了DefaultListableBeanFactory的接口实现和继承图，DefaultListableBeanFactory实现了BeanDefinitionRegistry接口，并且实现BeanFactory接口，提供了根本的BeanFactory功能。
BeanDefinitionRegistry是一个接口，它定义了关于BeanDefinition的注册、移除、查询等一系列的操作。
BeanFactory是IOC容器的核心接口，它的职责包罗：实例化、定位、配置应用步伐中的对象及创建这些对象间的依赖。

源码码解析

属性成员

beanDefinitionMap：DefaultListableBeanFactory作为BeanFactory默认是维护这一张beanDefinition的表。

1. /** Map of bean definition objects, keyed by bean name. */
2. private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

复制代码

getbean方法

DefaultListableBeanFactory是Bean工厂的一个默认实现，DefaultListableBeanFactory是Bean工厂的一个默认实现。截取DefaultListableBeanFactory中与getBean方法。
可以发现getBean有两种方式获取bean：

• 根据名称获取Bean，这个方法继承于AbstractBeanFactory
  
• 根据类型获取Bean，这个方法实现于DefaultListableBeanFactory，属于扩展了getBean方式
  

1.    //---------------------------------------------------------------------
2. // Implementation of remaining BeanFactory methods
3. //---------------------------------------------------------------------
4. //这个方式属于是扩展了getBean的方式，通过类型获取Bean
5. @Override
6. public <T> T getBean(Class<T> requiredType) throws BeansException {
7.         return getBean(requiredType, (Object[]) null);
8. }
10. @SuppressWarnings("unchecked")
11. @Override
12. public <T> T getBean(Class<T> requiredType, @Nullable Object... args) throws BeansException {
13.         Assert.notNull(requiredType, "Required type must not be null");
14.        //根据类型解析bean
15.         Object resolved = resolveBean(ResolvableType.forRawClass(requiredType), args, false);
16.         if (resolved == null) {
17.                 throw new NoSuchBeanDefinitionException(requiredType);
18.         }
19.         return (T) resolved;
20. }

复制代码

setAutowireCandidateResolver方法

这是一个普通的set方法，为什么我还要介绍它呢，由于这个set方法能启动扩展DefaultListableBeanFactory的功能。通过该方法给DefaultListableBeanFactory扩展主动装配的解析器。
可以通过该方法添加格外的主动装配解析器，如：QualifierAnnotationAutowireCandidateResolver提供@Qualifier注解解析的功能和@Autowire

1. /**
2. * Set a custom autowire candidate resolver for this BeanFactory to use
3. * when deciding whether a bean definition should be considered as a
4. * candidate for autowiring.
5. */
6. public void setAutowireCandidateResolver(AutowireCandidateResolver autowireCandidateResolver) {
7.         Assert.notNull(autowireCandidateResolver, "AutowireCandidateResolver must not be null");
8.         if (autowireCandidateResolver instanceof BeanFactoryAware) {
9.                 if (System.getSecurityManager() != null) {
10.                         AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
11.                                 ((BeanFactoryAware) autowireCandidateResolver).setBeanFactory(this);
12.                                 return null;
13.                         }, getAccessControlContext());
14.                 }
15.                 else {
16.                         ((BeanFactoryAware) autowireCandidateResolver).setBeanFactory(this);
17.                 }
18.         }
19.         this.autowireCandidateResolver = autowireCandidateResolver;
20. }

复制代码

resolveDependency方法

resolveDependency(DependencyDescriptor descriptor, String requestingBeanName, Set<String> autowiredBeanNames, TypeConverter typeConverter)方法，找到对应的依赖 Bean，获取 Bean 的实例对象时，构造器注入的参数也是通过该方法获取的，依赖注入底层也是通过该方法实现的，这里我们对该方法一探究竟

1. // DefaultListableBeanFactory.java
2. @Override
3. @Nullable
4. public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
5.         @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
7.     // <1> 设置参数名称探测器，例如通过它获取方法参数的名称
8.     descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
9.     // <2> 如果依赖类型为 Optional 类型
10.     if (Optional.class == descriptor.getDependencyType()) {
11.         // 调用 `createOptionalDependency(...)` 方法，先将 `descriptor` 注入表述器封装成 NestedDependencyDescriptor 对象
12.         // 底层处理和下面的 `5.2` 相同
13.         return createOptionalDependency(descriptor, requestingBeanName);
14.     }
15.     // <3> 否则，如果依赖类型为 ObjectFactory 或 ObjectProvider 类型
16.     else if (ObjectFactory.class == descriptor.getDependencyType() || ObjectProvider.class == descriptor.getDependencyType()) {
17.         // 返回一个 DependencyObjectProvider 私有内部类对象，并没有获取到实例的 Bean，需要调用其 getObject() 方法获取目标对象
18.         return new DependencyObjectProvider(descriptor, requestingBeanName);
19.     }
20.     // <4> 否则，如果依赖类型为 javax.inject.Provider 类型
21.     else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
22.         // 返回一个 Jsr330Provider 私有内部类对象，该对象也继承 DependencyObjectProvider
23.         return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
24.     }
25.     // <5> 否则，通用的处理逻辑
26.     else {
27.         // <5.1> 先通过 AutowireCandidateResolver 尝试获取一个代理对象，延迟依赖注入则会返回一个代理对象
28.         Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);
29.         // <5.2> 如果上面没有返回代理对象，则进行处理，调用 `doResolveDependency(...)` 方法
30.         if (result == null) {
31.             result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
32.         }
33.         return result;
34.     }
35. }

复制代码

doResolveDependency方法

1. // DefaultListableBeanFactory.java
2. @Nullable
3. public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
4.         @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
6.     // 设置当前线程的注入点，并返回上次的注入点，属于嵌套注入的一个保护点
7.     InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
8.     try {
9.         // <1> 针对给定的工厂给定一个快捷实现的方式，暂时忽略
10.         // 例如考虑一些预先解析的信息，在进入所有 Bean 的常规类型匹配算法之前，解析算法将首先尝试通过此方法解析快捷方式
11.         Object shortcut = descriptor.resolveShortcut(this);
12.         if (shortcut != null) {
13.             // 返回快捷的解析信息
14.             return shortcut;
15.         }
17.         // 依赖的类型
18.         Class<?> type = descriptor.getDependencyType();
19.         // <2> 获取注解中的 value 对应的值，例如 @Value、@Qualifier 注解配置的 value 属性值，注意 @Autowired 没有 value 属性配置
20.         Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
21.         if (value != null) {
22.             if (value instanceof String) {
23.                 // <2.1> 解析注解中的 value，因为可能是占位符，需要获取到相应的数据
24.                 String strVal = resolveEmbeddedValue((String) value);
25.                 BeanDefinition bd = (beanName != null && containsBean(beanName) ?
26.                         getMergedBeanDefinition(beanName) : null);
27.                 value = evaluateBeanDefinitionString(strVal, bd);
28.             }
29.             TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
30.             try {
31.                 // <2.2> 进行类型转换，并返回
32.                 return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
33.             }
34.             catch (UnsupportedOperationException ex) {
35.                 // A custom TypeConverter which does not support TypeDescriptor resolution...
36.                 return (descriptor.getField() != null ?
37.                         converter.convertIfNecessary(value, type, descriptor.getField()) :
38.                         converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
39.             }
40.         }
42.         // <3> 解析复合的依赖对象（Array、Collection、Map 类型），获取该属性元素类型的 Bean 们
43.         // 底层和第 `4` 原理一样，这里会将 `descriptor` 封装成 MultiElementDescriptor 类型
44.         Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
45.         if (multipleBeans != null) {
46.             return multipleBeans;
47.         }
49.         // <4> 查找与类型相匹配的 Bean 们
50.         // 返回结果：key -> beanName；value -> 对应的 Bean
51.         Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
52.         // <5> 如果一个都没找到
53.         if (matchingBeans.isEmpty()) {
54.             // <5.1> 如果 @Autowired 配置的 required 为 true，表示必须，则抛出异常
55.             if (isRequired(descriptor)) {
56.                 raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
57.             }
58.             // <5.2> 否则，返回一个空对象
59.             return null;
60.         }
62.         String autowiredBeanName;
63.         Object instanceCandidate;
65.         // <6> 如果匹配的 Bean 有多个，则需要找出最优先的那个
66.         if (matchingBeans.size() > 1) {
67.             // <6.1> 找到最匹配的那个 Bean，通过 @Primary 或者 @Priority 来决定，或者通过名称决定
68.             autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
69.             if (autowiredBeanName == null) {
70.                 if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
71.                     // <6.2> 如果没有找到最匹配的 Bean，则抛出 NoUniqueBeanDefinitionException 异常
72.                     return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
73.                 }
74.                 else {
75.                     // In case of an optional Collection/Map, silently ignore a non-unique case:
76.                     // possibly it was meant to be an empty collection of multiple regular beans
77.                     // (before 4.3 in particular when we didn't even look for collection beans).
78.                     return null;
79.                 }
80.             }
81.             // <6.3> 获取到最匹配的 Bean，传值引用给 `instanceCandidate`
82.             instanceCandidate = matchingBeans.get(autowiredBeanName);
83.         }
84.         // <7> 否则，只有一个 Bean，则直接使用其作为最匹配的 Bean
85.         else {
86.             // We have exactly one match.
87.             Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
88.             autowiredBeanName = entry.getKey();
89.             instanceCandidate = entry.getValue();
90.         }
92.         // <8> 将依赖注入的 Bean 的名称添加至方法入参 `autowiredBeanNames` 集合，里面保存依赖注入的 beanName
93.         if (autowiredBeanNames != null) {
94.             autowiredBeanNames.add(autowiredBeanName);
95.         }
96.         // <9> 如果匹配的 Bean 是 Class 对象，则根据其 beanName 依赖查找到对应的 Bean
97.         if (instanceCandidate instanceof Class) {
98.             instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
99.         }
100.         Object result = instanceCandidate;
101.         if (result instanceof NullBean) {
102.             if (isRequired(descriptor)) {
103.                 raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
104.             }
105.             result = null;
106.         }
107.         if (!ClassUtils.isAssignableValue(type, result)) {
108.             throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
109.         }
110.         // <10> 返回依赖注入的 Bean
111.         return result;
112.     }
113.     finally {
114.         // 设置当前线程的注入点为上一次的注入点，因为本次注入结束了
115.         ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
116.     }
117. }

复制代码

findAutowireCandidates 方法

1. // DefaultListableBeanFactory.java
2. protected Map<String, Object> findAutowireCandidates(
3.         @Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {
5.     // <1> 从当前上下文找到该类型的 Bean 们（根据类型）
6.     String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
7.             this, requiredType, true, descriptor.isEager());
8.     // <2> 定义一个 Map 对象 `result`，用于保存符合条件的 Bean
9.     Map<String, Object> result = new LinkedHashMap<>(candidateNames.length);
10.     /**
11.      * <3> 遍历 Spring 内部已处理的依赖对象集合，可以跳到 AbstractApplicationContext#prepareBeanFactory 方法中看看
12.      * 会有一下几个内置处理对象：
13.      * BeanFactory 类型 -> 返回 DefaultListableBeanFactory
14.      * ResourceLoader、ApplicationEventPublisher、ApplicationContext 类型 ->  返回 ApplicationContext 对象
15.      */
16.     for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
17.         Class<?> autowiringType = classObjectEntry.getKey();
18.         if (autowiringType.isAssignableFrom(requiredType)) {
19.             Object autowiringValue = classObjectEntry.getValue();
20.             autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
21.             if (requiredType.isInstance(autowiringValue)) {
22.                 result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
23.                 break;
24.             }
25.         }
26.     }
28.     // <4> 遍历第 `1` 步找到的 Bean 的名称们
29.     for (String candidate : candidateNames) {
30.         // <4.1> 如果满足下面两个条件，则添加至 `result` 集合中
31.         if (!isSelfReference(beanName, candidate) // 如果不是自引用（这个 Bean 不是在需要依赖它的 Bean 的内部定义的）
32.                 && isAutowireCandidate(candidate, descriptor)) { // 符合注入的条件
33.             addCandidateEntry(result, candidate, descriptor, requiredType);
34.         }
35.     }
36.     // <5> 如果没有找到符合条件的 Bean，则再尝试获取
37.     if (result.isEmpty()) {
38.         boolean multiple = indicatesMultipleBeans(requiredType);
39.         // Consider fallback matches if the first pass failed to find anything...
40.         DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
41.         // <5.1> 再次遍历第 `1` 步找到的 Bean 的名称们
42.         for (String candidate : candidateNames) {
43.             // <5.2> 如果满足下面三个条件，则添加至 `result` 集合中
44.             if (!isSelfReference(beanName, candidate) // 如果不是自引用（这个 Bean 不是在需要依赖它的 Bean 的内部定义的）
45.                     && isAutowireCandidate(candidate, fallbackDescriptor) // 符合注入的条件
46.                     && (!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) { // 不是复合类型，或者有 @Qualifier 注解
47.                 addCandidateEntry(result, candidate, descriptor, requiredType);
48.             }
49.         }
50.         // <6> 如果还没有找到符合条件的 Bean，则再尝试获取
51.         // 和上面第 `5` 步的区别在于必须是自引用（这个 Bean 不是在需要依赖它的 Bean 的内部定义的）
52.         if (result.isEmpty() && !multiple) {
53.             // Consider self references as a final pass...
54.             // but in the case of a dependency collection, not the very same bean itself.
55.             for (String candidate : candidateNames) {
56.                 if (isSelfReference(beanName, candidate)
57.                         && (!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate))
58.                         && isAutowireCandidate(candidate, fallbackDescriptor)) {
59.                     addCandidateEntry(result, candidate, descriptor, requiredType);
60.                 }
61.             }
62.         }
63.     }
64.     // <7> 返回 `result`，符合条件的 Bean
65.     return result;
66. }

复制代码

determineAutowireCandidate 方法

determineAutowireCandidate(Map<String, Object> candidates, DependencyDescriptor descriptor)方法，找到最匹配的那个依赖注入对象，如下：

1. @Nullable
2. protected String determineAutowireCandidate(Map<String, Object> candidates, DependencyDescriptor descriptor) {
3.     Class<?> requiredType = descriptor.getDependencyType();
4.     // <1> 尝试获取一个 @Primary 注解标注的 Bean，如果有找到多个则会抛出异常
5.     String primaryCandidate = determinePrimaryCandidate(candidates, requiredType);
6.     // <2> 如果第 `1` 步找到了则直接返回
7.     if (primaryCandidate != null) {
8.         return primaryCandidate;
9.     }
10.     // <3> 尝试找到 @Priority 注解优先级最高的那个 Bean，如果存在相同的优先级则会抛出异常
11.     String priorityCandidate = determineHighestPriorityCandidate(candidates, requiredType);
12.     // <4> 如果第 `3` 步找到了则直接返回
13.     if (priorityCandidate != null) {
14.         return priorityCandidate;
15.     }
16.     // Fallback
17.     // <5> 兜底方法，遍历所有的 Bean
18.     for (Map.Entry<String, Object> entry : candidates.entrySet()) {
19.         String candidateName = entry.getKey();
20.         Object beanInstance = entry.getValue();
21.         // <5.1> 如果满足下面其中一个条件则直接返回
22.         if ((beanInstance != null
23.             && this.resolvableDependencies.containsValue(beanInstance)) // 该 Bean 为 Spring 内部可处理的 Bean，例如 ApplicationContext
24.             || matchesBeanName(candidateName, descriptor.getDependencyName())) { // 名称相匹配
25.             return candidateName;
26.         }
27.     }
28.     // <6> 上面都没选出来则返回一个空对象
29.     return null;
30. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。