Spring源码-依赖注入

核心方法是：populateBean

整体流程：首先进行Spring自带的依赖注入，包括byName和byType，然后进行注解Autowired的注入

1.Spring自带依赖注入byName和byType

核心代码：

int resolvedAutowireMode = mbd.getResolvedAutowireMode();// byName 还是 byType
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
    // MutablePropertyValues是PropertyValues具体的实现类
    MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
    // Add property values based on autowire by name if applicable.
    if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
        autowireByName(beanName, mbd, bw, newPvs);
    }
    // Add property values based on autowire by type if applicable.
    if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
        autowireByType(beanName, mbd, bw, newPvs);
    }
    pvs = newPvs;
}

核心：当bean中只有set方法的时候，即使没有定义属性，也会进行属性注入

入口方法：autowireByName和autowireByType

1.propertyNames = unsatisfiedNonSimpleProperties

拿到可以进行依赖注入的属性名字

在这里包含以下几步：getPropertyDescriptors，从属性描述器拿到属性。属性描述器对应的属性名字是setXXX中的XXX。属性是private并且有get\set方法，那么java就认为他是一个真正的属性；然后依次判断属性是否符合注入的条件，也就是确定该属性是否需要进行注入，!pvs.contains，!isSimpleProperty。

注意：byName和byType不支持简单类型的注入，比如Number、Date；@Autowired支持简单类型注入。

简单类型如下：

public static boolean isSimpleValueType(Class<?> type) {
    return (Void.class != type && void.class != type &&
    (ClassUtils.isPrimitiveOrWrapper(type) ||
     Enum.class.isAssignableFrom(type) ||
     CharSequence.class.isAssignableFrom(type) ||
     Number.class.isAssignableFrom(type) ||
     Date.class.isAssignableFrom(type) ||
     Temporal.class.isAssignableFrom(type) ||
     URI.class == type ||
     URL.class == type ||
     Locale.class == type ||
     Class.class == type));
}

2.bean = getBean(propertyName)

依据属性name去找到bean

3.pvs.add(propertyName, bean)

存放依赖的bean，还没有真正赋值，赋值在Autowired注入之后。(而Autowired会直接注入)

4.registerDependentBean

记录一下propertyName对应的Bean被beanName给依赖了（注入关系）

在Autowired注入完成后，调用applyPropertyValues进行属性赋值，它会把字段Autowired注入的值覆盖，而不会覆盖方法的值，因为方法的值在注入的时候进行了判断。

2.处理Autowired注解

1）首先找到注入点，通过反射找到字段以及方法是否加了@Autowired注解和@Value注解和Inject注解，如果加了，则是注入点；

2）然后开始注入属性。

方法入口：filterPropertyDescriptorsForDependencyCheck

使用的核心类：AutowiredAnnotationBeanPostProcessor

两个核心方法：postProcessMergedBeanDefinition（先执行）、postProcessProperties（后执行）

if (hasInstAwareBpps) {
    if (pvs == null) {
        pvs = mbd.getPropertyValues();// 在这之前 我已经通过beanDefinition的方式进行属性赋值了
    }
    for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
        // 这里会调用AutowiredAnnotationBeanPostProcessor的postProcessProperties()方法，会直接给对象中的属性赋值
        // AutowiredAnnotationBeanPostProcessor内部并不会处理pvs，直接返回了
        PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
        if (pvsToUse == null) {
            if (filteredPds == null) {
                // 处理Autowired注解
                filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            }
            // 过期方法 不用了
            pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
            if (pvsToUse == null) {
                return;
            }
        }
        pvs = pvsToUse;
    }
}

2.1postProcessMergedBeanDefinition的执行流程

核心方法：findAutowiringMetadata

作用：寻找注入点

1.如果一个Bean的类型是String...，那么则根本不需要进行依赖注入（以java.开头的类）

2.找字段上是否存在@Autowired注解和@Value注解和Inject注解

static filed（静态属性）不是注入点，不会进行自动注入。（因为如果注入的bean是原型的，那么会导致静态属性被多次注入）

3.determineRequiredStatus

@Autowired(required = false)，查看required字段，是否必须注入（默认为true）

4.currElements.add(new AutowiredFieldElement(field, required))

将找到的注入点的字段加到这个集合中

5.遍历所有方法是否存在@Autowired、@Value、@Inject中的其中一个

静态方法不能被注入。如果方法的入参数量为0，会打印日志，如果该方法加了@Autowired注解，他就是注入点。入参就是需要注入的对象

if (method.getParameterCount() == 0) {
    if (logger.isInfoEnabled()) {
        logger.info("Autowired annotation should only be used on methods with parameters: " +
                    method);
    }
}

6.bridgedMethod

把桥接方法过滤掉（带泛型的方法）

(产生桥接方法的场景：一个子类在继承（或实现）一个父类（或接口）的泛型方法时，在子类中明确指定了泛型类型，那么在编译时编译器会自动生成桥接方法)

7.currElements.add

注入点的方法添加到集合中

8.InjectionMetadata.forElements(elements, clazz)

最终封装成这个对象，并进行缓存

2.2postProcessProperties的执行流程

作用：属性注入

1.findAutowiringMetadata-->injectionMetadataCache.get

此时就能从缓存中拿出来注入点了

2.inject

点进来默认的inject方法是处理@Resource的

要去找它的子类实现的方法，分别是字段AutowiredFieldElementh和方法AutowiredMethodElement。

其中：在方法中会判断checkPropertySkipping，如果pvs中有值，则跳过注入。（存在Spring自动注入的情况，也就是byName和byType）

注意：@Autowired先进行注入，然后进行set方法的注入。（程序员的赋值会覆盖spring自动的注入）

// 如果当前Bean中的BeanDefinition中设置了PropertyValues，那么最终将是PropertyValues中的值，覆盖@Autowired
if (pvs != null) {
    applyPropertyValues(beanName, mbd, bw, pvs);
}

3.resolveFieldValue

根据filed从BeanFactory中查到的匹配的Bean对象

4.field.set

反射给filed赋值(也就是属性注入)

3.Spring具体注入流程

调用顺序：postProcessProperties-->metadata.inject-->inject

注入分为两种类型：Field和Method（字段和方法）

resolveFieldValue：根据filed从BeanFactory中查到的匹配的Bean对象，然后调用resolveDependency注入

resolveMethodArguments：根据参数信息构造依赖描述符，然后去找Bean，然后调用resolveDependency注入

核心方法是DefaultListableBeanFactory#resolveDependency。

3.1 六种筛选逻辑

在byType到byName之间发生了6层筛选！

1.属性判断，bd中的属性

2.泛型判断

3.@Qualifier注解判断（用处：可以实现不同负载均衡的策略）

4.primary判断

5.优先级priority最高的判断

6.name判断

3.2 resolveDependency

1.initParameterNameDiscovery

初始化用来获取方法入参名字的发现器。（反射和字节码分析两种方式）

两种方法： 1.StandardReflectionParameterNameDiscoverer 反射（1.8+）； 2.LocalVariableTableParameterNameDiscoverer ASM分析.class文件

2.进入不同的不同if分支

3.所需要的类型是Optional

4.所需要的的类型是ObjectFactory，或ObjectProvider

5.else分支，result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary

其他类型，一般我们定义的都会进到这个分支。判断字段或者入参是否加了@Lazy注解。

如果加了@Lazy注解，就调用buildLazyResolutionProxy生成代理对象。(@Lazy可以写到类上，属性上)

说明：当用到代理对象的时候，才会用它去找到真正的bean，执行对应的方法

6.doResolveDependency，下面的方法都属于这个方法

7.去缓存拿依赖关系

8.处理@Value注解

8.1首先，getAutowireCandidateResolver().getSuggestedValue：获取@Value所指定的值；

8.2然后，进行占位符填充(${})，去Environment找对应key的value（如果没有找到key，则直接赋值给orderService，如果类型不同，要看存不存在对应的类型转换器，比如将String转化为OrderService的类型转换器）。

8.3然后，evaluateBeanDefinitionString：解析Spring表达式(#{})，也就是去Spring容器找对应名字的bean；

8.4最后，converter.convertIfNecessary(value, type）：将找到的bean进行类型匹配或者转换，需要看对应的类型转换器存不存在

后面就是处理@Autowired注解（先byType，后byName）

9.resolveMultipleBeans

处理集合或者Map的bean，如果是map，则要求key必须是String类型，为bean的名字；如果是Collection，也可以。

如果集合的类型为T，则直接抛出异常；如果为Object，则会找出来所有的bean

10.findAutowireCandidates（进行bean的筛选），第二小节详细讲这部分代码！

找到所有Bean，key是beanName, value有可能是bean对象，也有可能是beanClass，放到Map中。

Map<String, Object> matchingBeans = findAutowireCandidates

// 找到所有Bean，key是beanName, value有可能是bean对象，有可能是beanClass
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) {
    // required为true，抛异常
    if (isRequired(descriptor)) {
        raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
    }
    return null;
}

11.如果找到了一个bean，其就直接成为候选bean

12.如果找到了多个bean，需要继续筛选determineAutowireCandidate

筛选结果：筛选完后，要么有一个，要么有0个。（里面有控制，多于1个抛异常）

过程：

1)determinePrimaryCandidate：判断候选Bean有没有primary字段，如果存在@primary，就不要继续进行name匹配了。直接将找到的bean作为候选bean。

@Nullable
protected String determinePrimaryCandidate(Map<String, Object> candidates, Class<?> requiredType) {
    String primaryBeanName = null;
    for (Map.Entry<String, Object> entry : candidates.entrySet()) {
        String candidateBeanName = entry.getKey();
        Object beanInstance = entry.getValue();
        if (isPrimary(candidateBeanName, beanInstance)) {//
            if (primaryBeanName != null) {
                boolean candidateLocal = containsBeanDefinition(candidateBeanName);
                boolean primaryLocal = containsBeanDefinition(primaryBeanName);
                if (candidateLocal && primaryLocal) {
                    throw new NoUniqueBeanDefinitionException(requiredType, candidates.size(),
                                                              "more than one 'primary' bean found among candidates: " + candidates.keySet());
                }
                else if (candidateLocal) {
                    primaryBeanName = candidateBeanName;
                }
            }
            else {
                primaryBeanName = candidateBeanName;
            }
        }
    }
    return primaryBeanName;
}

2)determineHighestPriorityCandidate：处理@Priority注解。取优先级最高的Bean，如果优先级相同，则抛异常。

但是@Priority注解不能写在方法上，得按下面的方法使用

3)matchesBeanName：判断候选bean的name和我需要的name是否相同（name匹配）。

// Fallback
// 匹配descriptor的名字，要么是字段的名字，要么是set方法入参的名字
for (Map.Entry<String, Object> entry : candidates.entrySet()) {
    String candidateName = entry.getKey();
    Object beanInstance = entry.getValue();

    // resolvableDependencies记录了某个类型对应某个Bean，启动Spring时会进行设置，比如BeanFactory.class对应BeanFactory实例
    // 注意：如果是Spring自己的byType，descriptor.getDependencyName()将返回空，只有是@Autowired才会方法属性名或方法参数名
    if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) ||
        matchesBeanName(candidateName, descriptor.getDependencyName())) {
        return candidateName;
    }
}

13.resolveCandidate

有可能筛选出来的是某个bean的类型Class，此处就进行实例化，调用getBean

14.找到的bean是NullBean，抛异常

3.3 findAutowireCandidates

基于类型去找候选Bean，找到的bean可能有多个

1.String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors

从自己的BeanFactory中根据类型找bean的名字，也要去父BeanFactory找bean，然后合并找到的beanName

其中调用getBeanNamesForType，将找到的结果存到两个Map中，

Map<Class<?>, String[]> allBeanNamesByType 存放所有bean，Map<Class<?>

String[]> singletonBeanNamesByType 存放单例bean。

注意：在创建FactoryBean的时候，重写了getObjectType方法，这个方法用于告诉bean的类型是什么，getObject此时不用被调用。可以减少创建bean的数量

2.去resolvableDependencies找，看有没有符合情况的bean(在工厂启动的时候，会向这个map存放bean，也可以手动加入bean)

Map<Class<?>, Object> resolvableDependencies是额外存放bean的地方，在Spring启动的时候就会往里面放一些bean

Map：某个类型对应的Bean对象

3.将找到的beanName放到result

4.继续筛选。isSelfReference：判断是不是自己，找到多个bean，优先注入别人。如果别的bean都不符合条件，最后选择注入自己。

5.isAutowireCandidate

责任链模式，涉及三个主要的类，分别是：QualifierAnnotationAutowireCandidateResolver（判断@Qualifier注解）；GenericTypeAwareAutowireCandidateResolver（判断泛型）；SimpleAutowireCandidateResolver（判断属性是否为true/false）

包含三种筛选：1.属性判断(autowireCandidate)；2.泛型判断；3.@Qualifier注解判断

筛选的顺序（父类来判断该bean是否能依赖注入）：SimpleAutowireCandidateResolver(属性判断)--> GenericTypeAwareAutowireCandidateResolver（泛型）--> QualifierAnnotationAutowireCandidateResolver（@Qualifier）

@Qualifier，限定词，找到相同的限定词。可以用来实现分组，用于切换不同的负载均衡算法

3.4 为什么缓存的是BeanName呢

因为如果是原型bean，那么每次注入的时候都应该是不同的bean，缓存name保证了每次注入都通过beanName去创建一个新的bean用来注入。

3.5 @Resource的工作原理

先byName，再byType

(如果根据name找不到bean，就根据type去找)

也是先找注入点，然后注入

它的inject在父类中

注入点对象为ResourceElement

使用@Resource时没有指定具体的name，那么则用field的name，或setXxx()中的xxx

@Override
protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
    return (this.lazyLookup ? buildLazyResourceProxy(this, requestingBeanName) :
            getResource(this, requestingBeanName));
}

buildLazyResourceProxy：如果加了@Lazy注解，那就直接生成一个代理对象，返回；

getResource->autowireResource：如果没加@Lazy注解，

假设@Resource中没有指定name，并且field的name或setXxx()的xxx不存在对应的bean，那么则根据field类型或方法参数类型从BeanFactory去找

// 假设@Resource中没有指定name，并且field的name或setXxx()的xxx不存在对应的bean，那么则根据field类型或方法参数类型从BeanFactory去找
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 {
    resource = beanFactory.resolveBeanByName(name, descriptor);// 根据name去getBean
    autowiredBeanNames = Collections.singleton(name);
}