上一篇文章已经说到在第六次回调时，CommonAnnotationBeanPostProcessor#postProcessProperties 处理 Resource 注解。 AutowiredAnnotationBeanPostProcessor#postProcessProperties 处理 Autowired Inject注解。这篇文章就详细了解Spring如何完成依赖的注入。
// CommonAnnotationBeanPostProcessor#postProcessProperties
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
// 从缓存中获取了所有的 @Resource 注解的属性
InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
try {
// @Resource返回的Metadata是CommonAnnotationBeanPostProcessor$ResourceElement
// InjectionMetadata#inject
metadata.inject(bean, beanName, pvs);
} catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);
}
return pvs;
}
// InjectionMetadata#inject
public void inject(Object target, String beanName, PropertyValues pvs) throws Throwable {
Collection<InjectedElement> checkedElements = this.checkedElements;
Collection<InjectedElement> elementsToIterate =
(checkedElements != null ? checkedElements : this.injectedElements);
// 如果不存在依赖信息，那么直接跳过这里，不进行注入
if (!elementsToIterate.isEmpty()) {
for (InjectedElement element : elementsToIterate) {
// 不同的InjectedElement实现类调用不同的inject方法
// CommonAnnotationBeanPostProcessor$ResourceElement#inject
// InjectionMetadata$InjectedElement#inject
// AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement#inject 方法
// AutowiredAnnotationBeanPostProcessor$AutowiredMethodElement#inject 方法
element.inject(target, beanName, pvs);
}
}
}
InjectedElement：
- @Resource CommonAnnotationBeanPostProcessor$ResourceElement
- @Inject InjectionMetadata$InjectedElement
- @Autowired AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement
- AutowiredAnnotationBeanPostProcessor$AutowiredMethodElement
- @Lookup CommonAnnotationBeanPostProcessor.LookupElement
// CommonAnnotationBeanPostProcessor$ResourceElement#inject 会直接调用父类的父类InjectedElement#inject
protected void inject(Object target, String requestingBeanName, PropertyValues pvs) {
// 设置属性值
if (this.isField) {
Field field = (Field) this.member;
ReflectionUtils.makeAccessible(field);
field.set(target, getResourceToInject(target, requestingBeanName));
}else {
if (checkPropertySkipping(pvs)) {
return;
}
try {
// 处理@Resource的方法
Method method = (Method) this.member;
ReflectionUtils.makeAccessible(method);
method.invoke(target, getResourceToInject(target, requestingBeanName));
}catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
}
获取属性值的方法getResourceToInject --> ResourceElement#getResourceToInject
protected Object getResourceToInject(Object target, String requestingBeanName) {
// lazyLookup就是@Lazy注解中的值，默认没有加注解的话这里就是false
return (this.lazyLookup ? buildLazyResourceProxy(this, requestingBeanName) :
getResource(this, requestingBeanName));
}
CommonAnnotationBeanPostProcessor#getResource
-> CommonAnnotationBeanPostProcessor#autowireResource
protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName){
String name = element.name;
if (factory instanceof AutowireCapableBeanFactory) {
AutowireCapableBeanFactory beanFactory = (AutowireCapableBeanFactory) factory;
DependencyDescriptor descriptor = element.getDependencyDescriptor();
// containsBean 去singleton和bdMap中寻找了 name
if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) {
// 找名字找不到，这里就根据类型去匹配
autowiredBeanNames = new LinkedHashSet<>();
resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);
if (resource == null) {
throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object");
}
}else {
// 根据beanName去找
resource = beanFactory.resolveBeanByName(name, descriptor);
autowiredBeanNames = Collections.singleton(name);
}
}else {
resource = factory.getBean(name, element.lookupType);
autowiredBeanNames = Collections.singleton(name);
}
// 缓存依赖关系
if (factory instanceof ConfigurableBeanFactory) {
ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) factory;
for (String autowiredBeanName : autowiredBeanNames) {
if (requestingBeanName != null && beanFactory.containsBean(autowiredBeanName)) {
// 关键代码
beanFactory.registerDependentBean(autowiredBeanName, requestingBeanName);
}
}
}
return resource;
}
调用doGetBean => getSingleton => 最终返回对象
public Object resolveBeanByName(String name, DependencyDescriptor descriptor) {
InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
try {
return getBean(name, descriptor.getDependencyType());
}finally {
ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
}
}
缓存依赖关系
public void registerDependentBean(String beanName, String dependentBeanName) {
String canonicalName = canonicalName(beanName);
synchronized (this.dependentBeanMap) {
Set<String> dependentBeans =
this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
if (!dependentBeans.add(dependentBeanName)) {
return;
}
}
// key = test2,value=test1,test3 test2依赖与test1和test3
synchronized (this.dependenciesForBeanMap) {
Set<String> dependenciesForBean =
this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
dependenciesForBean.add(canonicalName);
}
}
AutowiredAnnotationBeanPostProcessor#postProcessProperties中处理@Autowired等注解
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
// 获取缓存中的依赖信息
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
// 进行依赖注入 InjectionMetadata#inject AutowiredFieldElement/AutowiredMethodElement
metadata.inject(bean, beanName, pvs);
}
- 为属性注入
// AutowiredFieldElement#inject
protected void inject(Object bean,String beanName, PropertyValues pvs) throws Throwable {
// 仅列出核心代码
// 从容器中获取依赖
Object value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
// 通过反射调用set方法
if (value != null) {
ReflectionUtils.makeAccessible(field);
field.set(bean, value);
}
}
- 为方法注入（从容器中获取方法的参数，然后在调用方法）
protected void inject(Object bean, String beanName,PropertyValues pvs) throws Throwable {
// 从容器中获取参数列表
for (int i = 0; i < arguments.length; i++) {
Object arg = beanFactory.resolveDependency(currDesc, beanName, autowiredBeans, typeConverter);
if (arg == null && !this.required) {
arguments = null;
break;
}
arguments[i] = arg;
}
// 调用方法
if (arguments != null) {
ReflectionUtils.makeAccessible(method);
method.invoke(bean, arguments);
}
}
beanFactory.resolveDependency方法，调用了DefaultListableBeanFactory#resolveDependency方法
- 断定依赖的类型是不是Optional类型（构建NestedDependencyDescriptor，去容器中找这个类型的对象）
- 断定依赖的类型是不是ObjectFactory或者ObjectProvider类型（直接返回DependencyObjectProvider）
- 断定依赖的类型是不是java.inject.Provider类型（调用Jsr330Factory#createDependencyProvider创建Jsr330Provider对象返回）
重点看其他情况
// DefaultListableBeanFactory#resolveDependency
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
注入步骤：
根据类型去容器中find 找出这个类型的所有bean
如果找出了多个，会根据属性的名称进行筛选（@Primary、@Priority、Ordered等）
找到了依赖的bean，判断依赖的类型是不是Class类型，是class获取容器找出对应的bean对象
// DefaultListableBeanFactory#doResolveDependency
public Object doResolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {
// 根据类型去容器中find 找出所有的这个类型的bean
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
// 存在多个类型相同的bean对象
if (matchingBeans.size() > 1) {
// 根据属性名称进行筛选
autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
}else {
// We have exactly one match.
Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
autowiredBeanName = entry.getKey();
instanceCandidate = entry.getValue();
}
if (instanceCandidate instanceof Class) {
// 如果依赖是class类型
instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
}
Object result = instanceCandidate;
// 判断类型是否匹配
if (!ClassUtils.isAssignableValue(type, result)) {
throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
}
return result;
}
findAutowireCandidates是根据类型获取容器中对应的beanName
比如根据IUserService接口的类型，找出来的结果(matchingBeans)如下
matchingBeans{
{
key : userServiceImpl1,
value : 'top.gmfcj.service.impl.UserServiceImpl1'
},
{
key : userServiceImpl2,
value : 'top.gmfcj.service.impl.UserServiceImpl2'
}
}
这时，instanceCandidate的类型就是Class，就会再次去容器中根据class去找bean对象（找bean -> 不存在就创建）
public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory) {
// 根据bean名称从容器中获取 AbstractBeanFactory#doGetBean
return beanFactory.getBean(beanName);
}
自动装配流程.png
