我要评论
Spring依赖注入@AutoWired
Spring依赖注入的形式
Spring中的依赖注入要分好几种，我这边大概说明下这几种方式，spring中现在用的最多的是两种方式，第一种是xml模式，但是现在大多数都是注解的方式，现在不是叫做spring boot零配置吗,说白了就是没有使用xml的模式，使用的是注解的方式；spring中依赖注入要分好几种。
XML的方式
手动方式：
1.构造方法注入
2.set方法注入
自动模式：
1.构造方法注入
2.set方法注入
xml的注入方式在最早的时候用的最多的，xml的注入分为手动模式和自动模式，我们先来看下手动的模式，手动模式要在xml文件中写标签来手动注入
<bean name="orderService" class="com.bml10.service.OrderService">
</bean>
<bean name="userService" class="com.bml10.service.UserService">
<property name="orderService" ref="orderService"/>
</bean>
对应的要在UserService提供set方法
public class UserService {
private OrderService orderService;
public void setOrderService(OrderService orderService) {
this.orderService = orderService;
}
public void test(){
System.out.println("orderService="+ orderService);
}
}
这样就可以注入了，我们看下这种手动模式在spring的源码中是如何处理的，在spring填充属性的方法，上一篇笔记中已经记录了，方法就是populateBean
就是这段代码和这个方法的后面的applyPropertyValues(beanName, mbd, bw, pvs);来填充的属性，这种模式就是说在spring扫描的阶段会将你配置的标签扫描成一个PropertyValue，然后最后在初始化实例化bean过后就是填充属性的这个方法applyPropertyValues会将找到的bean填充到bean的属性中，也就是注入到bean的属性中；
如果说xml的方式要通过自动注入怎么做呢？因为一个bean中如果要注入的属性太多，而且你写xml还容易出错，所以xml也提供了一个自动注入的，自动注入分为byType和byName的方式；byName就很简单了，buName就是根据你的属性的set方法，比如setUserSerivce，那么会截取set，得到userService，去spring容器中找，如果找到了就添加到PropertyValues中，后面会调用applyPropertyValues注入，如果没有找到就不注入；如果是byType的方式，就负责点了，首先byType如果找到多个，要报错的，因为xml的自动注入的byType方式找到多个是要报错的，比如这种：
<bean name="orderService" class="com.bml10.service.OrderService">
</bean>
<bean name="orderService1" class="com.bml10.service.OrderService" />
<bean name="userService" class="com.bml10.service.UserService" autowire="byType">
</bean>
所以xml的自动注入通过byType的方式还是有缺陷的，万一你不小心注入了两个相同类型的bean，byType方式将会不成功；这里再说下，spring的xml的自动注入还有中全局的方式，就是在beans标签中设置一个全局的属性default-autowire
但是请注意的是设置了全局，那么每个bean里面就不需要设置了，但是如果你的某个bean设置了autowire，那么是局部生效的，不会用全局的，这个特性记住就行。
xml自动注入源码
刚刚上面演示的是spring的xml自动注入的例子，演示过后，我们来看下源码，源码在populateBean中，populateBean方法中的xml自动注入源码片段如下：
/**
* 下面的这段逻辑处理的是依赖注入，其实下面的代码主要处理xml中的配置的依赖注入
* 在xml中可以配置byType or byName的依赖注入
* spring中的依赖注入分为几种模式：
* 1.手动模式:在xml中配置Property属性，通过set方法进行注入，构造方法注入
* 2.自动模式：xml中配置autoWier属性（byType or byName),在注解中配置@AutoWired
* @Autowired可以注入属性，构造方法以及普通的方法
*下面的代码主要处理在xml中配置了autowire属性的依赖注入
* 也就是<bean id="xx" class="com.xx" autowire="byType" />
* 这样配置了话，那么就会根据autowire来进行依赖注入，就不需要写
* <Property name="" ref=""/>,还有种方式就是在beans中设置全局的default-autowire
*/
//下面的pvs就是找到在扫描过程中，如果xml配置了Property属性的标签会解析成PropertyValue
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
//得到在xml中配置的autowire属性值，比如配置了autowire="byType"，那么resolvedAutowireMode就会有值2
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
//在xml配置了byType or byName才会进入下面的依赖注入
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
/**
* 下面的是xml的依赖注入，现在使用注解的模式基本上是用不到，但是为了解释清楚，这里还是进行解析一下
* 其中分了两种默认，byType 和byName,byName的比较好理解
* byName：根据bean找到bean下面的所有set方法，比如setUserService,那么会截取set得到userService，然后去
* bd中找，如果找到了，然后进注入到pvs中，在本方法的最后applyPropertyValues进入设置属性进去
* byType：byType就比较复杂一点
*/
//先声明一个MutablePropertyValues，把原来的PropertyValues传进去，如果pvs为空，则构建一个list集合
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
//这个是以byName进行注入，bw是包装的bean对象，mbd是BeanDefinition，newpvs是属性注入的对象
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
//byType里面处理的逻辑有点复杂，我看了下，实现原理大概如下：
//1.先根据bean所在的类找到所有的set方法，然后得到set方法对应的名字，也就是beanName集合
//然后循环这个集合，将beanName装载成一个属性描述器，然后根据属性描述器得到方法参数对象MethodParameter
//2.然后在根据MethodParameter封装成一个byType的依赖描述器，请注意，只有byType才实行了依赖描述器的实现类
//byName是没有的，封装成一个byType的依赖描述器过后，根据这个依赖描述器获取bean，简单来说，就是你ref=“bean”中的
//bean在容器中的bean对象信息，那出来然后注入到newpvs中，在下面的applyPropertyValues方法填充进去
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
autowireByName
protected void autowireByName(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
//找到这个bean中所有的set方法，并且根据set方法截取beanname,并且返回一个beanName所对应的名字集合
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
//根据方法返回的属性名字，循环这个beannames集合
for (String propertyName : propertyNames) {
if (containsBean(propertyName)) {
//创建bean或者获取bean然后注入到pvs中
Object bean = getBean(propertyName);
pvs.add(propertyName, bean);
//下面是注入依赖的信息，表示我的这个bean依赖了那些bean
registerDependentBean(propertyName, beanName);
if (logger.isTraceEnabled()) {
logger.trace("Added autowiring by name from bean name '" + beanName +
"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
"' by name: no matching bean found");
}
}
}
}
autowireByType
protected void autowireByType(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
try {
//属性名字也就是通过set方法得到的beanName获取一个属性描述器
PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
// Don't try autowiring by type for type Object: never makes sense,
// even if it technically is a unsatisfied, non-simple property.
//这里是判断是你的属性描述器，也就是说你的set方法的参数的类型不能是Object
//因为如果setUserService(Object userService),那么像这个方法，如果是Object，spring根本不知道你要注入那个bean
//所以不能是Object
if (Object.class != pd.getPropertyType()) {
//根据属性描述器获取这个set方法的参数信息
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
// Do not allow eager init for type matching in case of a prioritized post-processor.
boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
/**
*
* 根据方法的参数MethodParameter获取一个bean
* 到这里知道这个方法是byType，byType的原理是根据你的set方法的参数类型得到一个bean，所以这里是通过
* set方法的参数比如setUserService(UserService uservice)中的UserService来构建一个依赖描述器
* 这个依赖描述器得到过后，根据这个依赖描述器和其他一些参数得到一个bean
*/
DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
//这个里面的方法有点复杂，大概是知道它做了什么事儿，后面有空再去看下它是如何处理的
//简单来说就是根据依赖描述器通过下面这个方法得到一个Bean，然后注入到pvs中
Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
if (autowiredArgument != null) {
pvs.add(propertyName, autowiredArgument);
}
//循环注入到当前bean所依赖的bean，autowiredBeanNames是当前bean锁依赖的bean集合
for (String autowiredBeanName : autowiredBeanNames) {
registerDependentBean(autowiredBeanName, beanName);
if (logger.isTraceEnabled()) {
logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +
propertyName + "' to bean named '" + autowiredBeanName + "'");
}
}
autowiredBeanNames.clear();
}
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
}
}
}
xml的自动注入看上面的源码分析都是不会马上注入，而是添加到pvs中，最后调用applyPropertyValues方法进行属性填充的，所以我们这里总结出一个结论就是
spring 的xml方式注入依赖，分为手动和自动，手动的时候spring会将属性扫描到pvs中，然后如果是自动的话，自动获取的属性对应关系也会放入pvs中，最后调用applyPropertyValues进行属性填充。
以@AutoWired的方式
1.属性方式注入
2.普通非静态方法的注入
3.构造方法的注入
这篇笔记中，我们主要记录下上面几种注入方式中的非构造方法的注入，构造方法的注入在后面会有记录
spring的注解依赖注入
sprng的注解方式@AutoWired注入模式和上面的不太一样，@AutoWired有三种注入模式：
1.属性注入
2.非静态方法注入
3.构造方法注入
这里只讲前两种，第三中在后面讲，@AutoWired注入分为两步，第一步是找到注入点，然后放入缓存，第二步是从缓存获取注入点进行注入,spring中的依赖注入@AutoWired也是通过AutowiredAnnotationBeanPostProcessor这个bean后置处理器实现的，这个后置处理器中提供了两个方法，spring分别是在实例化后初始化前调用，这两个方法是postProcessMergedBeanDefinition和postProcessProperties，其中postProcessMergedBeanDefinition是找到bena的注入点，而postProcessProperties是进行注入，先来看下如何找到注入点的源码，注入点的源码是在doCreateBean中实现的
doCreateBean之注入点
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//spring提供的又一个bean后置处理器，就是在bean实例化完成过后，可以进行调用
//这个后置处理器可以传入指定的BeanDefinition，也就是你可以改变BeanDefinition的属性
//但是这个时候bean都已经实例化完成了，就算你修改了beanclass也没有用了
//但是有些属性我们还是可以设置的，比如可以手动设置初始化的方法mbd.setInitMethodName
//@AutoWired注解的切入点就是在这个后置处理器中找到的并且注入到缓存中
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
/**
* Apply MergedBeanDefinitionPostProcessors to the specified bean definition,
* invoking their {@code postProcessMergedBeanDefinition} methods.
* @param mbd the merged bean definition for the bean
* @param beanType the actual type of the managed bean instance
* @param beanName the name of the bean
* @see MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition
* 这个方法我个人的理解是可以被叫做合并bean过后的bean后置处理器
* @AutoWired注解和@Value以及@Inject注解都是在这个后置处理器中实现的
* 具体的后置处理器是AutowiredAnnotationBeanPostProcessor,在里面调用了postProcessMergedBeanDefinition
*/
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof MergedBeanDefinitionPostProcessor) {
MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
}
}
}
后置处理器中调用的是postProcessMergedBeanDefinition，这个后置处理器是在AutowiredAnnotationBeanPostProcessor，所以我们看下AutowiredAnnotationBeanPostProcessor类中的注入点代码
postProcessMergedBeanDefinition
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
//找到所有的注入点@AutoWired
InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
metadata.checkConfigMembers(beanDefinition);
}
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
// Fall back to class name as cache key, for backwards compatibility with custom callers.
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
// Quick check on the concurrent map first, with minimal locking.
/**
* 先从缓存中获取，如果缓存中没有，就去根据bean的类去找到，找到过后注入到injectionMetadataCache缓存中
* 我们知道@AutoWired注入可以通过属性、普通方法、构造进行注入，这里对属性和普通方法进行注入
*/
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不为空，则去找注入点，如果注入点为空那么metadata=InjectionMetadata.EMPTY
metadata = buildAutowiringMetadata(clazz);
//找到过后放入缓存
this.injectionMetadataCache.put(cacheKey, metadata);
}
}
}
return metadata;
}
private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
//注意，这里不是判断clzz是否实现了@AutoWired,@Value @Inject注解，这里的判断很简单
//1.你传入的clazz如果是java.开头的则证明是java的内置的类，那么就返回false
//2.你传入的autowiredAnnotationTypes是否是java开头的注解
if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
return InjectionMetadata.EMPTY;
}
List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
Class<?> targetClass = clazz;
/**
* 下面用了一个do while循环去找注入点，
* 这里需要注意的是为什么要用do while，很简单的例子就是比如一个UserServce加了一个注解，那么是继承了BaseService
* 而BaseService中没有加@Componet，但是UserService加了@Component注解，那么这个时候以UserService为bean去找注入点
* spring会找到他的父类，一级一级的往上找，直到找到最顶层的类，所以在父类中加了@AutoWired等注解，就算父类没有@Component
* 也是可以找到摈弃注入的
* 下面的循环中是分了两部分来找的，第一部分是属性的注入，第二部分是普通方法的注入，而构造方法的注入不在这里
*/
do {
final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
//属性的注入点寻找,下面使用的是java8的lambad表达式的方式，这里不关心，关心的是lambad里面的逻辑
ReflectionUtils.doWithLocalFields(targetClass, field -> {
//循环每个属性，看下属性是否实现了@AutoWired,@Value @Inject注解,如果没有实现，那么就会返回null
MergedAnnotation<?> ann = findAutowiredAnnotation(field);
if (ann != null) {
//spring规定的是静态属性不能注入，也就是说你写的private static UserSerivce userService;
//是不能注入的
if (Modifier.isStatic(field.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static fields: " + field);
}
return;
}
//这里读取的是@AutoWired上面的required,这个属性默认是true，sping这里的意思就是说
// //如果你配置了required属性，如果这个属性为false，那么在注入的过程中如果没有找到，注入失败了，那么就不会报错
// //如果设置为true，那么如果没有注入成功，会报异常
boolean required = determineRequiredStatus(ann);
//找到过后然后放入currElements缓存，这里的放入的对象是AutowiredFieldElement，就是针对属性的注入
currElements.add(new AutowiredFieldElement(field, required));
}
});
//下面的这个方法是针对普通方法注入的处理
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
//这里也是去判断普通注入的方法是否有@AutoWired,@Value @Inject注解
MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
//如果方法有注解，并且方法是合法的，那么就进入找寻普通方法注入点的逻辑
if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
//相同的是注入的方法不能是静态方法
if (Modifier.isStatic(method.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static methods: " + method);
}
return;
}
//方法的参数也不能是空，因为@AutoWired方法的注入是通过方法的参数类型进行注入的
if (method.getParameterCount() == 0) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation should only be used on methods with parameters: " +
method);
}
}
//和属性注入的逻辑一样
boolean required = determineRequiredStatus(ann);
//在这里将方法生成一个属性描述器，这里面判断了是写入方法还是读取方法
// 这里的没隔方法的一些细节逻辑封装的有点多，我在这里大部分是为了把spirng的大部分逻辑和思想得到
//所以一些特别处理的地方就没有去细看，有兴趣的可以去细看下，比如下面这行代码是如何处理的
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
//封装好了AutowiredMethodElement，然后放入缓存
currElements.add(new AutowiredMethodElement(method, required, pd));
}
});
//每次循环找到注入点注入到currElements后，加入到elements
elements.addAll(0, currElements);
//每次本类找到过后，然后获取父类，一级一级的往上找
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
//这里将找到的注入点elements封装成一个InjectionMetadata返回，如果elements=null，那么封装的是InjectionMetadata.EMPTY
return InjectionMetadata.forElements(elements, clazz);
}
@Nullable
private MergedAnnotation<?> findAutowiredAnnotation(AccessibleObject ao) {
MergedAnnotations annotations = MergedAnnotations.from(ao);
for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
MergedAnnotation<?> annotation = annotations.get(type);
if (annotation.isPresent()) {
return annotation;
}
}
return null;
}
public AutowiredAnnotationBeanPostProcessor() {
this.autowiredAnnotationTypes.add(Autowired.class);
this.autowiredAnnotationTypes.add(Value.class);
try {
this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
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.
}
}
源码的注释在上面都已经写了，这边总结下spring的依赖注入@AutoWired的找寻注入点的原理：
1.spring在这个后置处理器中提供了两种方式的依赖注入，属性注入和普通非静态方法的注入；
2.首先根据传过来的bean，找到所有的声明的属性和方法，然后循环这个类，因为这个类可能有父类，找寻要找到所有的父类中看是否有注入的属性和方法，是根据是否实现了@AutoWired来找的；
3.如果找到了属性或者方法，那么如果是属性，就构造一个对象AutowiredFieldElement 或者AutowiredMethodElement，放入缓存，属性对象和方法对象都实现了InjectionMetadata.InjectedElement，所以这两个对象中都实现了inject方法，用来后面注入的。
4.InjectElement就是注入的对象点，也就是需要依赖注入的属性或者方法都保存在InjectElement里面，我们来看下InjectElement这个对象的结构:
/**
* A single injected element.
* 注入点，spring的依赖注入的注入点就是InjectedElement
* member可以是Field或者Method
*/
public abstract static class InjectedElement {
//注入的成员类型，Field或者Member
protected final Member member;
//注入点是否是属性Field
protected final boolean isField;
//属性的描述器，如果是属性注入的注入点，那么这个pd值是空的，只有方法的注入才有
@Nullable
protected final PropertyDescriptor pd;
@Nullable
protected volatile Boolean skip;
protected InjectedElement(Member member, @Nullable PropertyDescriptor pd) {
//member中可以是Field可以是method
this.member = member;
this.isField = (member instanceof Field);
this.pd = pd;
}
......
其中member可以是属性可以是方法，就根据你存入的是AutowiredMethodElement还是AutowiredFieldElement；
5.最后找到的所有注入点都缓存到对象private final Map<String, InjectionMetadata> injectionMetadataCache = new ConcurrentHashMap<>(256)中；
@AutoWired依赖注入
@AutoWired的依赖注入也是在bean的后置处理器中实现的，具体的代码是在populateBean这个方法里面，代码片段如下:
/**
* 这里调用的又是bean的后置处理器，这里的后置处理器是在bean属性填充过后的bean后置处理器
* 这个后置处理器正在现在用的最多，spring内部定义的InstantiationAwareBeanPostProcessor实现了这个接口，主要处理的是
* @AutoWired的后置处理器，依赖注入的在这里调用的，最重要的是postProcessProperties这个方法
* 所以InstantiationAwareBeanPostProcessor的后置处理器方法postProcessProperties是处理@AutoWired @Resource注解的
* 具体来说就是：
* @AutowiredannotationBeanPostProcessor处理的是@AutoWired、@Value，@Inject注解
* @CommonAnnotationBeanPostProcessor处理的是@Resource注解
* 都是在postProcessProperties方法中处理的
*/
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
主要是调用后置处理器中的方法postProcessProperties
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
//在实例化过后调用的后置处理器先将注入点找到并且准入到了缓存injectionMetadataCache中了
//所以这里的就是从缓存中获取，当然了如果在前面的后置处理器中没有注入成功，那么这个也会去注入，一般不会出现这种情况
//metadata就是bean类的所有注入点，只包括两种：普通非静态方法的注入点和非静态属性的注入点
//这里的注入点有两个，属性和犯法，所以下面的调用也分为两种
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
//开始注入，这里的注入根据是属性和方法调用不同的注入方式
//AutowiredFieldElement属性的注入
//AutowiredMethodElement是方法的注入
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是根据是属性注入还是方法注入调用具体的方法，AutowiredFieldElement中的inject方法和AutowiredMethodElement中的inject方法
AutowiredFieldElement.inejct
/**
* 这里就是根据属性注入的逻辑
* @param bean
* @param beanName
* @param pvs
* @throws Throwable
*/
@Override
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Field field = (Field) this.member;
Object value;
if (this.cached) {
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
}
else {
// 和xml那边一模一样的，就是先通过属性来构造一个依赖描述器
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();
try {
//然后通过依赖描述器来找到一个bean，请注意，这里是属性的依赖注入，比如private UserService uservice
// //那么这里是来找到bean类下面的属性UserService在spring容器中的ben对象，也就是value
//resolveDependency在这里是先byType，再byName，当byType有多个的时候，就要进行byName,所以在
// //在spring中写注入@AutoWired对应的属性名称的时候尽量规范一点
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
}
//下面的逻辑是如果开启了缓存cached，默认是false，然后取出注入的属性名称，也就是beanName，然后判断，设置缓存字段值
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;
}
}
}
if (value != null) {
//如果找到了注入的bena，然后通过反射进行注入
ReflectionUtils.makeAccessible(field);
field.set(bean, value);
}
}
}
AutowiredMethodElement.inject
/**
* 方法的注入，方法注入的要点是：
* 1.方法必须是普通的非静态方法（非构造方法，构造方法不在此处处理）
* 2.方法的参数个数必须大于0，也就是至少为1个
* 3.然后根据前两个条件，然后循环每一个方法的参数，请注意，每个参数应该都是一个bean对象，
* 然后封装一个参数数组，最后通过反射调用方法进行注入
* spring代码写的很多，但是我们研究spring的源码要看关键部分，关键部分就是它如何进行依赖注入的
* 通过属性和普通方法，至于一些很细的细节，就算你现在弄清楚了，过一段时间也会忘，所以太细的如果不太理解，就飘过
* @param bean
* @param beanName
* @param pvs
* @throws Throwable
*/
@Override
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
if (checkPropertySkipping(pvs)) {
return;
}
// 方法的注入，member强制转换成一个Method
Method method = (Method) this.member;
Object[] arguments;
if (this.cached) {
// Shortcut for avoiding synchronization...
arguments = resolveCachedArguments(beanName);
}
else {
//得到方法参数的个数，并且封装一个Object arguments
int argumentCount = method.getParameterCount();
// //这个数组存放的是每个参数对应的bean在spring容器中的bean对象
arguments = new Object[argumentCount];
//这里存放的是每个参数对应在spring容器中的bean对象构建的依赖描述器
DependencyDescriptor[] descriptors = new DependencyDescriptor[argumentCount];
Set<String> autowiredBeans = new LinkedHashSet<>(argumentCount);
Assert.state(beanFactory != null, "No BeanFactory available");
TypeConverter typeConverter = beanFactory.getTypeConverter();
//下面的代码逻辑就是循环每个方法参数，然后从spring容器中获取bean，然后填充到arguments中
// 逻辑都和属性注入一样，通过依赖描述器调用resolveDependency来获取一个bean对象
for (int i = 0; i < arguments.length; i++) {
MethodParameter methodParam = new MethodParameter(method, i);
DependencyDescriptor currDesc = new DependencyDescriptor(methodParam, this.required);
currDesc.setContainingClass(bean.getClass());
descriptors[i] = currDesc;
try {
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);
}
}
synchronized (this) {
if (!this.cached) {
if (arguments != null) {
DependencyDescriptor[] cachedMethodArguments = Arrays.copyOf(descriptors, arguments.length);
registerDependentBeans(beanName, autowiredBeans);
if (autowiredBeans.size() == argumentCount) {
Iterator<String> it = autowiredBeans.iterator();
Class<?>[] paramTypes = method.getParameterTypes();
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;
}
}
}
if (arguments != null) {
try {
//然后进行调用，就类似于setXxx(UserService u1,UsereSerivce u2),两个参数就是argumentgs
//arguments就是上面循环从spring容器中获取的
ReflectionUtils.makeAccessible(method);
method.invoke(bean, arguments);
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
}
大概总结下spring的@AutoWired依赖注入的要点：
1.从缓存中获取注入点，然后开始循环注入点；
2.如果是属性的注入点，那么就调用AutowiredFieldElement中的inject方法，在该方法中处理不用看spring源码大家也能知道，无非就是通过反射对feild进行赋值，也就是set方法区赋值，但是这里有点重要的点就是spring的@AutoWired是先byType，在byName的，什么意思呢？在注入的方法中有个方法特别重要就是resolveDependency，这个方法就是根据你注入的属性去spring的容器中找到对应的bean；比如我们有个属性是private UserService userservice；那么spring会根据userserivce去spring容器中找到，找到了直接返回，然后调用field.set进行注入赋值；但是在这个过程中spring的处理方式是：
先根据byType，也就是你的UserService找到对应的bean对象列表，这个时候分为三种情况：
1）.如果为空，则证明在spring容器中不存在这个bean，如果这个时候你的@AutoWired设置了required属性，并且为false，那么就注入不成功；
2）.如果不为空，只有一条数据，则证明在容器中已经找到了相对应的bean，直接返回注入就可了。
3）.如果返回多条，则证明在容器中存在多个相同的Bean对象，那么这个时候就要开始byName,根据字段的byName得到唯一的一个Bean，所以spring的@AutoWired依赖注入是先byType，在byName的。
3.如果是方法的注入点，那就调用AutowiredMethodElement中的inject方法，找bean的方式和属性的是一样的，我只是说byType和byName的方式和属性的是一样的，一样的调用了resolveDependency这个方法；但是方法的注入和属性注入不一样，比如我的注入方法如下：
public void setxxx(UserService userServie){
.....
}
public void setxxx(UserService userServie,OrderService){
.....
}
所以方法注入的要看方法的参数，所以spring的方法注入需要遵循两点：
1.方法的参数不能为空，为空谈何注入；
2.方法必须是普通的非静态方法。
那么spring会构建一个arguments数组，然后获取每个参数，然后根据参数去spring容器中找bean，找bean的过程也是先byType再byName，找到过后赋值给arguments[i]=object，最后找到了所有的参数对应的bean过后，执行
method.invoke(target,arguments)进行反射调用方法注入进行注入。
@Autowired例子演示
上面已经把@AutoWired的依赖注入的源码分析，但是我们要如何证明所述，其实属性的注入我就不演示不证明了，这个大家都用非常多，肯定是能注入的，我主要演示下方法的注入，一个参数和多个参数的方法注入：
@Component
public class UserService {
private OrderService orderService1;
private OrderService orderService2;
@Autowired
public void xxx(OrderService o1,OrderService o2){
this.orderService1 = o1;
this.orderService2 = o2;
}
public void test()
{
System.out.println("orderService1="+ orderService1);
System.out.println("orderService2="+ orderService2);
}
}
我的orderService1和orderService2都没有加@AutoWired注解，而是通过xxx方法进行注入的，看输出结果如下
所以spring是肯定能支持普通方法注入和属性注入的
最后附上一张@AutoWired依赖注入的图，仅供参考：
本文地址：https://blog.csdn.net/scjava/article/details/109275867
如您对本文有疑问或者有任何想说的，请点击进行留言回复，万千网友为您解惑！
网友评论