1.写在前面

前面的博客我们已经写了Spring的依赖查找，这篇博客我们来了解写Spring的依赖注入。

2.依赖注入的模式和类型

手动模式 - 配置或者编程的方式， 提前安排注入规则

• XML 资源配置元信息
• Java 注解配置元信息
• API 配置元信息

自动模式 - 实现方提供依赖自动关联的方式， 按照內建的注入规则

• Autowiring（ 自动绑定）

依赖注入的类型

3.自动绑定（ Autowiring）

官方说明

• The Spring container can autowire relationships between collaborating beans. You can let Spring resolve collaborators (other beans) automatically for your bean by inspecting the contents of the ApplicationContext.
• Spring 容器可以自动装配协作 bean 之间的关系。 您可以让 Spring 通过检查 ApplicationContext 的内容自动为您的 bean 解析协作者（其他 bean）。

优点

• Autowiring can significantly reduce the need to specify properties or constructor arguments.(自动装配可以显着减少指定属性或构造函数参数的需要。)
• Autowiring can update a configuration as your objects evolve.(随着对象的发展，自动装配可以更新配置。)

4.自动绑定（ Autowiring） 模式

5.自动绑定（ Autowiring） 限制和不足

官方说明

• Limitations and Disadvantages of Autowiring 小节
• 

6.Setter 方法注入

实现方法

• 手动模式
  • XML 资源配置元信息
  • Java 注解配置元信息
  • API 配置元信息
• 自动模式
  • byName
  • byType

下面我们来展示各种代码，具体的如下：

XML 资源配置元信息

package org.learn.spring.dependency.injection;import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;// 基于 xml 的setter依赖注入的示例
public class XmlDependencySetterInjectionDemo {public static void main(String[] args) {DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);String xmlResourcePath = "classpath:/META-INF/dependency-setter-injection.xml";// 加载XML资源，解析并生成BeanDefinitionbeanDefinitionReader.loadBeanDefinitions(xmlResourcePath);// 创建依赖查找并且创建BeanUserHolder userHolder = beanFactory.getBean(UserHolder.class);System.out.println(userHolder);}
}

Java 注解配置元信息

package org.learn.spring.dependency.injection;import org.learn.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;import java.util.Map;// 基于 Annotation 的setter依赖注入的示例
public class AnnotationDependencySetterInjectionDemo {public static void main(String[] args) {// 创建BeanFactory的容器AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();// 注册Configuration Class 配置类applicationContext.register(AnnotationDependencySetterInjectionDemo.class);XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";// 加载XML资源，解析并生成BeanDefinitionbeanDefinitionReader.loadBeanDefinitions(xmlResourcePath);// 启动应用上下文applicationContext.refresh();// 创建依赖查找并且创建BeanUserHolder userHolder = applicationContext.getBean(UserHolder.class);System.out.println(userHolder);// 显示的关闭spring应用上下文applicationContext.close();}@Beanpublic UserHolder userHolder(User user){UserHolder userHolder = new UserHolder();userHolder.setUser(user);return userHolder;}
}

API 配置元信息

package org.learn.spring.dependency.injection;import org.learn.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;// 基于 API 的setter依赖注入的示例
public class ApiDependencySetterInjectionDemo {public static void main(String[] args) {// 创建BeanFactory的容器AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();// 生成UserHolder 的BeanDefinitionBeanDefinition userHolderBeanDefinition = createUserHolderBeanDefinition();// 注册UserHolder 的BeanDefinitionapplicationContext.registerBeanDefinition("userHolder", userHolderBeanDefinition);XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";// 加载XML资源，解析并生成BeanDefinitionbeanDefinitionReader.loadBeanDefinitions(xmlResourcePath);// 启动应用上下文applicationContext.refresh();// 创建依赖查找并且创建BeanUserHolder userHolder = applicationContext.getBean(UserHolder.class);System.out.println(userHolder);// 显示的关闭spring应用上下文applicationContext.close();}// 为UserHolder生成BeanDefinitionprivate static BeanDefinition createUserHolderBeanDefinition() {BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(UserHolder.class);beanDefinitionBuilder.addPropertyReference("user", "superUser");return beanDefinitionBuilder.getBeanDefinition();}}

byName

package org.learn.spring.dependency.injection;import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;// byName AutoWring 依赖 setter方法注入示例
public class AutoWringByNameDependencySetterInjectionDemo {public static void main(String[] args) {DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);String xmlResourcePath = "classpath:/META-INF/autowring-dependency-setter-injection.xml";// 加载XML资源，解析并生成BeanDefinitionbeanDefinitionReader.loadBeanDefinitions(xmlResourcePath);// 创建依赖查找并且创建BeanUserHolder userHolder = beanFactory.getBean(UserHolder.class);System.out.println(userHolder);}}

byType

package org.learn.spring.dependency.injection;import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;// byName AutoWring 依赖 setter方法注入示例
public class AutoWringByNameDependencySetterInjectionDemo {public static void main(String[] args) {DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);String xmlResourcePath = "classpath:/META-INF/autowring-dependency-setter-injection.xml";// 加载XML资源，解析并生成BeanDefinitionbeanDefinitionReader.loadBeanDefinitions(xmlResourcePath);// 创建依赖查找并且创建BeanUserHolder userHolder = beanFactory.getBean(UserHolder.class);System.out.println(userHolder);}}

7.构造器注入

实现方法

• 手动模式
  • XML 资源配置元信息
  • Java 注解配置元信息
  • API 配置元信息
• 自动模式
  • constructor

下面来展示示例代码

XML 资源配置元信息

package org.learn.spring.dependency.injection;import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;// 基于 xml 的Constructor依赖注入的示例
public class XmlDependencyConstructorInjectionDemo {public static void main(String[] args) {DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);String xmlResourcePath = "classpath:/META-INF/dependency-constructor-injection.xml";// 加载XML资源，解析并生成BeanDefinitionbeanDefinitionReader.loadBeanDefinitions(xmlResourcePath);// 创建依赖查找并且创建BeanUserHolder userHolder = beanFactory.getBean(UserHolder.class);System.out.println(userHolder);}
}

Java 注解配置元信息

package org.learn.spring.dependency.injection;import org.learn.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;// 基于 Annotation 的Constructor依赖注入的示例
public class AnnotationDependencyConstructorInjectionDemo {public static void main(String[] args) {// 创建BeanFactory的容器AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();// 注册Configuration Class 配置类applicationContext.register(AnnotationDependencyConstructorInjectionDemo.class);XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";// 加载XML资源，解析并生成BeanDefinitionbeanDefinitionReader.loadBeanDefinitions(xmlResourcePath);// 启动应用上下文applicationContext.refresh();// 创建依赖查找并且创建BeanUserHolder userHolder = applicationContext.getBean(UserHolder.class);System.out.println(userHolder);// 显示的关闭spring应用上下文applicationContext.close();}@Beanpublic UserHolder userHolder(User user){return new UserHolder(user);}
}

API 配置元信息

package org.learn.spring.dependency.injection;import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;// 基于 API 的Constructor依赖注入的示例
public class ApiDependencyConstructorInjectionDemo {public static void main(String[] args) {// 创建BeanFactory的容器AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();// 生成UserHolder 的BeanDefinitionBeanDefinition userHolderBeanDefinition = createUserHolderBeanDefinition();// 注册UserHolder 的BeanDefinitionapplicationContext.registerBeanDefinition("userHolder", userHolderBeanDefinition);XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";// 加载XML资源，解析并生成BeanDefinitionbeanDefinitionReader.loadBeanDefinitions(xmlResourcePath);// 启动应用上下文applicationContext.refresh();// 创建依赖查找并且创建BeanUserHolder userHolder = applicationContext.getBean(UserHolder.class);System.out.println(userHolder);// 显示的关闭spring应用上下文applicationContext.close();}// 为UserHolder生成BeanDefinitionprivate static BeanDefinition createUserHolderBeanDefinition() {BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(UserHolder.class);beanDefinitionBuilder.addConstructorArgReference("superUser");return beanDefinitionBuilder.getBeanDefinition();}}

constructor

package org.learn.spring.dependency.injection;import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;// constructor AutoWring 依赖 constructor方法注入示例
public class AutoWringConstructorDependencyConstructorInjectionDemo {public static void main(String[] args) {DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);String xmlResourcePath = "classpath:/META-INF/autowring-dependency-constructor-injection.xml";// 加载XML资源，解析并生成BeanDefinitionbeanDefinitionReader.loadBeanDefinitions(xmlResourcePath);// 创建依赖查找并且创建BeanUserHolder userHolder = beanFactory.getBean(UserHolder.class);System.out.println(userHolder);}}

8.字段注入

实现方法

• 手动模式
• Java 注解配置元信息
  • @Autowired
  • @Resource
  • @Inject（ 可选）

具体的代码如下：

@Autowired

package org.learn.spring.dependency.injection;import org.learn.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;// 基于 Annotation 的Field依赖注入的示例
public class AnnotationDependencyFieldInjectionDemo {@Autowired // @Autowired 会忽略静态字段private UserHolder userHolder;public static void main(String[] args) {// 创建BeanFactory的容器AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();// 注册Configuration Class 配置类 -> Spring BeanapplicationContext.register(AnnotationDependencyFieldInjectionDemo.class);XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";// 加载XML资源，解析并生成BeanDefinitionbeanDefinitionReader.loadBeanDefinitions(xmlResourcePath);// 启动应用上下文applicationContext.refresh();// 依赖查找 AnnotationDependencyFieldInjectionDemo BeanAnnotationDependencyFieldInjectionDemo demo = applicationContext.getBean(AnnotationDependencyFieldInjectionDemo.class);// 通过@Autowired字段关联UserHolder userHolder = demo.userHolder;System.out.println(userHolder);// 显示的关闭spring应用上下文applicationContext.close();}@Beanpublic UserHolder userHolder(User user){return new UserHolder(user);}
}

@Resource

package org.learn.spring.dependency.injection;import org.learn.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;import javax.annotation.Resource;// 基于 Annotation 的Field依赖注入的示例
public class AnnotationDependencyFieldInjectionDemo {@Autowired // @Autowired 会忽略静态字段private UserHolder userHolder;@Resourceprivate UserHolder userHolder2;public static void main(String[] args) {// 创建BeanFactory的容器AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();// 注册Configuration Class 配置类 -> Spring BeanapplicationContext.register(AnnotationDependencyFieldInjectionDemo.class);XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";// 加载XML资源，解析并生成BeanDefinitionbeanDefinitionReader.loadBeanDefinitions(xmlResourcePath);// 启动应用上下文applicationContext.refresh();// 依赖查找 AnnotationDependencyFieldInjectionDemo BeanAnnotationDependencyFieldInjectionDemo demo = applicationContext.getBean(AnnotationDependencyFieldInjectionDemo.class);// 通过@Autowired字段关联UserHolder userHolder = demo.userHolder;System.out.println(userHolder);// 通过@Resource字段关联UserHolder userHolder2 = demo.userHolder2;System.out.println(userHolder2);// 显示的关闭spring应用上下文applicationContext.close();}@Beanpublic UserHolder userHolder(User user){return new UserHolder(user);}
}

9.方法注入

实现方法

• 手动模式
  • Java 注解配置元信息
    • @Autowired
    • @Resource
    • @Inject（ 可选）
    • @Bean

具体的代码如下：

package org.learn.spring.dependency.injection;import org.learn.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;import javax.annotation.Resource;// 基于 Annotation 的Method依赖注入的示例
public class AnnotationDependencyMethodInjectionDemo {private UserHolder userHolder;private UserHolder userHolder2;@Autowiredpublic void init1(UserHolder userHolder){this.userHolder = userHolder;}@Resourcepublic void init2(UserHolder userHolder2){this.userHolder2 = userHolder2;}public static void main(String[] args) {// 创建BeanFactory的容器AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();// 注册Configuration Class 配置类 -> Spring BeanapplicationContext.register(AnnotationDependencyMethodInjectionDemo.class);XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";// 加载XML资源，解析并生成BeanDefinitionbeanDefinitionReader.loadBeanDefinitions(xmlResourcePath);// 启动应用上下文applicationContext.refresh();// 依赖查找 AnnotationDependencyFieldInjectionDemo BeanAnnotationDependencyMethodInjectionDemo demo = applicationContext.getBean(AnnotationDependencyMethodInjectionDemo.class);// 通过@Autowired字段关联UserHolder userHolder = demo.userHolder;System.out.println(userHolder);// 通过@Resource字段关联UserHolder userHolder2 = demo.userHolder2;System.out.println(userHolder2);System.out.println(userHolder == userHolder2);// 显示的关闭spring应用上下文applicationContext.close();}@Beanpublic UserHolder userHolder(User user){return new UserHolder(user);}
}

10.接口回调注入

Aware 系列接口回调

自动模式

具体的代码如下：

package org.learn.spring.dependency.injection;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;// 基于 Aware 的接口回调依赖注入的示例
public class AwareInterfaceDependencyInjectionDemo implements BeanFactoryAware, ApplicationContextAware {private static BeanFactory beanFactory;private static ApplicationContext applicationContext;public static void main(String[] args) {// 创建BeanFactory的容器AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();// 注册Configuration Class 配置类 -> Spring Beancontext.register(AwareInterfaceDependencyInjectionDemo.class);// 启动应用上下文context.refresh();System.out.println(beanFactory == context.getBeanFactory());System.out.println(applicationContext == context);// 显示的关闭spring应用上下文context.close();}@Overridepublic void setBeanFactory(BeanFactory beanFactory) throws BeansException {AwareInterfaceDependencyInjectionDemo.beanFactory = beanFactory;}@Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {AwareInterfaceDependencyInjectionDemo.applicationContext = applicationContext;}
}

11.依赖注入类型选择

注入选型

• 低依赖： 构造器注入
• 多依赖： Setter 方法注入
• 便利性： 字段注入
• 声明类： 方法注入

12.基础类型注入

基础类型

• 原生类型（ Primitive） ： boolean、 byte、 char、 short、 int、 float、 long、 double

• 标量类型（ Scalar） ： Number、 Character、 Boolean、 Enum、 Locale、 Charset、 Currency、

  Properties、 UUID

• 常规类型（ General） ： Object、 String、 TimeZone、 Calendar、 Optional 等

• Spring 类型： Resource、 InputSource、 Formatter 等

具体的代码如下：

package org.learn.spring.ioc.overview.domain;import org.learn.spring.ioc.overview.enums.City;
import org.springframework.core.io.Resource;import java.util.Arrays;
import java.util.List;// 用户类
public class User {private Long id;private String name;private City city;private Resource configFileLocation;public Long getId() {return id;}public void setId(Long id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public City getCity() {return city;}public void setCity(City city) {this.city = city;}public Resource getConfigFileLocation() {return configFileLocation;}public void setConfigFileLocation(Resource configFileLocation) {this.configFileLocation = configFileLocation;}public static User createUser(){User user = new User();user.setId(1L);user.setName("温蒂");return user;}@Overridepublic String toString() {return "User{" +"id=" + id +", name='" + name + '\'' +", city=" + city +", configFileLocation=" + configFileLocation +'}';}
}

package org.learn.spring.ioc.overview.dependency.lookup;import org.learn.spring.ioc.overview.annotation.Super;
import org.learn.spring.ioc.overview.domain.SuperUser;
import org.learn.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;import java.util.Map;// 依赖查找的示例
public class DependencyLookupDemo {public static void main(String[] args) {// 配置XML 配置文件// 启动spring的应用上下文BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:META-INF/dependency-lookup-context.xml");// 1.按照名称查找lookupInRealTime(beanFactory);lookupInLazy(beanFactory);// 2.按照类型查找lookupByType(beanFactory);lookupCollectionByType(beanFactory);// 3.按照类型和名称查找lookupByNameAndType(beanFactory);// 4.通过注解查找对象lookupCollectionByAnnotation(beanFactory);}// 实时查找private static void lookupInRealTime(BeanFactory beanFactory) {User user = (User) beanFactory.getBean("user");System.out.println("实时查找：" + user);}// 延时查找private static void lookupInLazy(BeanFactory beanFactory) {ObjectFactory objectFactory = (ObjectFactory) beanFactory.getBean("objectFactory");User user = objectFactory.getObject();System.out.println("延时查找：" + user);}// 按照类型查找private static void lookupByType(BeanFactory beanFactory) {User user = beanFactory.getBean(User.class);System.out.println("按照类型查找单一对象：" + user);}// 按照类型查找集合private static void lookupCollectionByType(BeanFactory beanFactory) {if (beanFactory instanceof ListableBeanFactory) {ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;Map users = listableBeanFactory.getBeansOfType(User.class);System.out.println("按照类型查找到的所有的 User 集合对象：" + users);}}// 按照类型和名称private static void lookupByNameAndType(BeanFactory beanFactory) {User user = beanFactory.getBean("user", User.class);System.out.println("按照类型和名称查找:" + user);}// 按照注解查找集合对象private static void lookupCollectionByAnnotation(BeanFactory beanFactory) {if (beanFactory instanceof ListableBeanFactory) {ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;Map users = (Map) listableBeanFactory.getBeansWithAnnotation(Super.class);System.out.println("按照注解查找到的所有的标注@SuperUser User 集合对象：" + users);}}
}

13.集合类型注入

集合类型

• 数组类型（ Array） ： 原生类型、 标量类型、 常规类型、 Spring 类型
• 集合类型（ Collection）
  • Collection： List、 Set（ SortedSet、 NavigableSet、 EnumSet）
  • Map： Properties

具体的代码如下：

BEIJINGHANGZHOUSHANGHAI

package org.learn.spring.ioc.overview.domain;import org.learn.spring.ioc.overview.enums.City;
import org.springframework.core.io.Resource;import java.util.Arrays;
import java.util.List;// 用户类
public class User {private Long id;private String name;private City city;private City[] workCities;private List lifeCities;private Resource configFileLocation;public Long getId() {return id;}public void setId(Long id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public City getCity() {return city;}public void setCity(City city) {this.city = city;}public Resource getConfigFileLocation() {return configFileLocation;}public void setConfigFileLocation(Resource configFileLocation) {this.configFileLocation = configFileLocation;}public City[] getWorkCities() {return workCities;}public void setWorkCities(City[] workCities) {this.workCities = workCities;}public List getLifeCities() {return lifeCities;}public void setLifeCities(List lifeCities) {this.lifeCities = lifeCities;}public static User createUser(){User user = new User();user.setId(1L);user.setName("温蒂");return user;}@Overridepublic String toString() {return "User{" +"id=" + id +", name='" + name + '\'' +", city=" + city +", workCities=" + Arrays.toString(workCities) +", lifeCities=" + lifeCities +", configFileLocation=" + configFileLocation +'}';}
}

package org.learn.spring.ioc.overview.dependency.lookup;import org.learn.spring.ioc.overview.annotation.Super;
import org.learn.spring.ioc.overview.domain.SuperUser;
import org.learn.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;import java.util.Map;// 依赖查找的示例
public class DependencyLookupDemo {public static void main(String[] args) {// 配置XML 配置文件// 启动spring的应用上下文BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:META-INF/dependency-lookup-context.xml");// 1.按照名称查找lookupInRealTime(beanFactory);lookupInLazy(beanFactory);// 2.按照类型查找lookupByType(beanFactory);lookupCollectionByType(beanFactory);// 3.按照类型和名称查找lookupByNameAndType(beanFactory);// 4.通过注解查找对象lookupCollectionByAnnotation(beanFactory);}// 实时查找private static void lookupInRealTime(BeanFactory beanFactory) {User user = (User) beanFactory.getBean("user");System.out.println("实时查找：" + user);}// 延时查找private static void lookupInLazy(BeanFactory beanFactory) {ObjectFactory objectFactory = (ObjectFactory) beanFactory.getBean("objectFactory");User user = objectFactory.getObject();System.out.println("延时查找：" + user);}// 按照类型查找private static void lookupByType(BeanFactory beanFactory) {User user = beanFactory.getBean(User.class);System.out.println("按照类型查找单一对象：" + user);}// 按照类型查找集合private static void lookupCollectionByType(BeanFactory beanFactory) {if (beanFactory instanceof ListableBeanFactory) {ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;Map users = listableBeanFactory.getBeansOfType(User.class);System.out.println("按照类型查找到的所有的 User 集合对象：" + users);}}// 按照类型和名称private static void lookupByNameAndType(BeanFactory beanFactory) {User user = beanFactory.getBean("user", User.class);System.out.println("按照类型和名称查找:" + user);}// 按照注解查找集合对象private static void lookupCollectionByAnnotation(BeanFactory beanFactory) {if (beanFactory instanceof ListableBeanFactory) {ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;Map users = (Map) listableBeanFactory.getBeansWithAnnotation(Super.class);System.out.println("按照注解查找到的所有的标注@SuperUser User 集合对象：" + users);}}
}

14.限定注入

使用注解 @Qualifier 限定

• 通过 Bean 名称限定
• 通过分组限定

基于注解 @Qualifier 扩展限定

• 自定义注解 - 如 Spring Cloud @LoadBalanced

具体的代码如下：

package org.learn.spring.dependency.injection.annotation;import org.springframework.beans.factory.annotation.Qualifier;import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;// 用户组 注解 扩展 @Qualifier
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@Qualifier
public @interface UserGroup {
}

package org.learn.spring.dependency.injection;import org.learn.spring.dependency.injection.annotation.UserGroup;
import org.learn.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;import java.util.Collection;// Qualifier 注解依赖注入
public class QualifierAnnotationDependencyInjectionDemo {@Autowiredprivate User user; // superUser -> primary@Autowired@Qualifier(value = "user") // 指定Bean 名称或者id注入private User nameUser;// 整体应用上下文存在4个 User类型的Bean：// superUser// user// user1 -> @Qualifier// user2 -> @Qualifier@Autowiredprivate Collection allUsers; // 2 Bean superUser + user@Autowired@Qualifierprivate Collection qualifiedUsers; // 2 Bean = user1 + user2 -> 4 Bean = user1 + user2 + user3 + user4@Autowired@UserGroupprivate Collection groupedUsers; // 2 Bean = user3 + user4@Bean@Qualifier // 进行逻辑分组public User user1(){return createUser(7L);}@Bean@Qualifier // 进行逻辑分组public User user2(){return createUser(8L);}@Bean@UserGrouppublic User user3(){return createUser(9L);}@Bean@UserGrouppublic User user4(){return createUser(10L);}public static User createUser(Long id){User user = new User();user.setId(id);return user;}public static void main(String[] args) {// 创建BeanFactory的容器AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();// 注册Configuration Class 配置类 -> Spring BeanapplicationContext.register(QualifierAnnotationDependencyInjectionDemo.class);XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";// 加载XML资源，解析并生成BeanDefinitionbeanDefinitionReader.loadBeanDefinitions(xmlResourcePath);// 启动应用上下文applicationContext.refresh();// 依赖查找 QualifierAnnotationDependencyInjectionDemo BeanQualifierAnnotationDependencyInjectionDemo demo = applicationContext.getBean(QualifierAnnotationDependencyInjectionDemo.class);// 期待输出superUser BeanSystem.out.println("demo.user = " + demo.user);// 期待输出user BeanSystem.out.println("demo.nameUser = " + demo.nameUser);// 期待输出2 Bean superUser + userSystem.out.println("demo.allUsers = " + demo.allUsers);// 期待输出2 Bean user1 user2System.out.println("demo.qualifiedUsers = " + demo.qualifiedUsers);// 期待输出2 Bean user3 user4System.out.println("demo.groupedUsers = " + demo.groupedUsers);// 显示的关闭spring应用上下文applicationContext.close();}
}

15.延迟依赖注入

使用 API ObjectFactory 延迟注入

• 单一类型
• 集合类型

使用 API ObjectProvider 延迟注入（ 推荐）

• 单一类型
• 集合类型

具体的代码如下：

package org.learn.spring.dependency.injection;import org.learn.spring.dependency.injection.annotation.UserGroup;
import org.learn.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;import java.util.Collection;
import java.util.Set;// ObjectProvider 实现延迟依赖注入
public class LazyAnnotationDependencyInjectionDemo {@Autowiredprivate User user; // 实时注入@Autowiredprivate ObjectProvider userObjectProvider; // 延迟注入@Autowiredprivate ObjectFactory> usersObjectFactory;public static void main(String[] args) {// 创建BeanFactory的容器AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();// 注册Configuration Class 配置类 -> Spring BeanapplicationContext.register(LazyAnnotationDependencyInjectionDemo.class);XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";// 加载XML资源，解析并生成BeanDefinitionbeanDefinitionReader.loadBeanDefinitions(xmlResourcePath);// 启动应用上下文applicationContext.refresh();// 依赖查找 LazyAnnotationDependencyInjectionDemo BeanLazyAnnotationDependencyInjectionDemo demo = applicationContext.getBean(LazyAnnotationDependencyInjectionDemo.class);// 期待输出superUser BeanSystem.out.println("demo.user = " + demo.user);// 期待输出superUser BeanSystem.out.println("demo.userObjectProvider = " + demo.userObjectProvider.getObject()); // 继承ObjectFactory中的方法// 期待输出superUser User BeanSystem.out.println("demo.usersObjectFactory = " + demo.usersObjectFactory.getObject());demo.userObjectProvider.stream().forEach(System.out::println);// 显示的关闭spring应用上下文applicationContext.close();}
}

16.依赖处理过程

基础知识

• 入口 - DefaultListableBeanFactory#resolveDependency
• 依赖描述符 - DependencyDescriptor
• 自定绑定候选对象处理器 - AutowireCandidateResolver

先来简单的分析下对应的源码，具体的代码如下：

/*
*
descriptor ——依赖项的描述符（字段/方法/构造函数） 
requestingBeanName – 声明给定依赖项的 bean 的名称 
autowiredBeanNames – 应该将所有自动装配 bean 的名称（用于解析给定的依赖项）添加到的集合 
typeConverter – 类型转换器
*/
@Override
@Nullable
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());if (Optional.class == descriptor.getDependencyType()) {return createOptionalDependency(descriptor, requestingBeanName);}else if (ObjectFactory.class == descriptor.getDependencyType() ||ObjectProvider.class == descriptor.getDependencyType()) {return new DependencyObjectProvider(descriptor, requestingBeanName);}else if (javaxInjectProviderClass == descriptor.getDependencyType()) {return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);}else {Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);if (result == null) {result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);}return result;}
}

我们先来看第一个参数DependencyDescriptor依赖的描述符，我们先打开对应的代码，先看对应的属性，具体的如下：

public class DependencyDescriptor extends InjectionPoint implements Serializable {// 被注入的类、容器private final Class declaringClass;// 注入的方法的名称@Nullableprivate String methodName;// 注入的方法的参数类型@Nullableprivate Class[] parameterTypes;// 注入的参数的索引private int parameterIndex;// 注入的字段的名称@Nullableprivate String fieldName;// 是否是必须注入的 对应的@Autowired注解中的值private final boolean required;// 对应的是@Lazy注解中的值private final boolean eager;// 嵌入的层次private int nestingLevel = 1;// 包含的类@Nullableprivate Class containingClass;// 泛型的内容，后面的内容会讲@Nullableprivate transient volatile ResolvableType resolvableType;// 类型的描述@Nullableprivate transient volatile TypeDescriptor typeDescriptor;}

上面只是简单的分析了一下，比较模糊，下面我们通过一个简单的例子和debug的方式来帮助我们更深层次的理解，具体的例子如下：

package org.learn.spring.dependency.injection;import org.learn.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;import java.util.Set;// 注解实现延迟依赖注入处理过程
public class AnnotationDependencyInjectionResolutionDemo {@Autowired // 依赖查找(处理)private User user;  // DependencyDescriptor ->// 必须(required = true)// (eager = true) 实时注入// 通过类型(User.class)// 字段名称("user")// 是否是首要的(primary = true)public static void main(String[] args) {// 创建BeanFactory的容器AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();// 注册Configuration Class 配置类 -> Spring BeanapplicationContext.register(AnnotationDependencyInjectionResolutionDemo.class);XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";// 加载XML资源，解析并生成BeanDefinitionbeanDefinitionReader.loadBeanDefinitions(xmlResourcePath);// 启动应用上下文applicationContext.refresh();// 依赖查找 LazyAnnotationDependencyInjectionDemo BeanAnnotationDependencyInjectionResolutionDemo demo = applicationContext.getBean(AnnotationDependencyInjectionResolutionDemo.class);// 期待输出superUser BeanSystem.out.println("demo.user = " + demo.user);// 显示的关闭spring应用上下文applicationContext.close();}
}

我们在DefaultListableBeanFactory#resolveDependency方法中加入对应的断点，然后Debug，就可以看到如下的截图，看看我们之前猜测的DependencyDescriptor是否是对的，具体的内容如下：

我们继续拿出之前的代码，具体的如下：

@Override
@Nullable
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {// 这儿是字段注入，所以这个方法直接返回descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());// descriptor.getDependencyType() 获取依赖的类型if (Optional.class == descriptor.getDependencyType()) {return createOptionalDependency(descriptor, requestingBeanName);}else if (ObjectFactory.class == descriptor.getDependencyType() ||ObjectProvider.class == descriptor.getDependencyType()) {return new DependencyObjectProvider(descriptor, requestingBeanName);}else if (javaxInjectProviderClass == descriptor.getDependencyType()) {return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);}else {Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);if (result == null) {result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);}return result;}
}

descriptor.getDependencyType()是获取依赖的类型，具体的内容如下：

public Class getDependencyType() {// 这里的field 是等于userif (this.field != null) {// 这儿的层级是等于1，所以直接返回的userif (this.nestingLevel > 1) {Type type = this.field.getGenericType();for (int i = 2; i <= this.nestingLevel; i++) {if (type instanceof ParameterizedType) {Type[] args = ((ParameterizedType) type).getActualTypeArguments();type = args[args.length - 1];}}if (type instanceof Class) {return (Class) type;}else if (type instanceof ParameterizedType) {Type arg = ((ParameterizedType) type).getRawType();if (arg instanceof Class) {return (Class) arg;}}return Object.class;}else {// 直接返回userreturn this.field.getType();}}else {return obtainMethodParameter().getNestedParameterType();}}

由于descriptor.getDependencyType()返回的是user类型，所以上面的resolveDependency的四个if判断的类型都是不满足的，直接走最后一个判断。代码如下：

// 这个方法返回 null,后面再说
Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);
if (result == null) {result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}
return result;

然后会直接调用doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);方法，具体的内容如下：

@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {// 只有多次嵌套的时候这儿才不会返回nullInjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);try {// 快捷方式这儿也是没有的，返回的是nullObject shortcut = descriptor.resolveShortcut(this);if (shortcut != null) {return shortcut;}// 这儿返回的是user类型Class type = descriptor.getDependencyType();// 这儿返回的也是null，后面我们会讲Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);if (value != null) {if (value instanceof String) {String strVal = resolveEmbeddedValue((String) value);BeanDefinition bd = (beanName != null && containsBean(beanName) ?getMergedBeanDefinition(beanName) : null);value = evaluateBeanDefinitionString(strVal, bd);}TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());try {return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());}catch (UnsupportedOperationException ex) {// A custom TypeConverter which does not support TypeDescriptor resolution...return (descriptor.getField() != null ?converter.convertIfNecessary(value, type, descriptor.getField()) :converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));}}// 直接跳到这儿执行// 这儿判断是否要注入的是多个bean，也是nullObject multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);if (multipleBeans != null) {return multipleBeans;}// 这儿方法中的beanName 等于的是 annotationDependencyInjectionResolutionDemo 也是被注入的beanName// type 是User.class// descriptor 是前面我们的DependencyDescriptor.classMap matchingBeans = findAutowireCandidates(beanName, type, descriptor);if (matchingBeans.isEmpty()) {if (isRequired(descriptor)) {raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);}return null;}String autowiredBeanName;Object instanceCandidate;if (matchingBeans.size() > 1) {autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);if (autowiredBeanName == null) {if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);}else {// In case of an optional Collection/Map, silently ignore a non-unique case:// possibly it was meant to be an empty collection of multiple regular beans// (before 4.3 in particular when we didn't even look for collection beans).return null;}}instanceCandidate = matchingBeans.get(autowiredBeanName);}else {// We have exactly one match.Map.Entry entry = matchingBeans.entrySet().iterator().next();autowiredBeanName = entry.getKey();instanceCandidate = entry.getValue();}if (autowiredBeanNames != null) {autowiredBeanNames.add(autowiredBeanName);}if (instanceCandidate instanceof Class) {instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);}Object result = instanceCandidate;if (result instanceof NullBean) {if (isRequired(descriptor)) {raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);}result = null;}if (!ClassUtils.isAssignableValue(type, result)) {throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());}return result;}finally {ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);}
}

这儿我们需要了解是findAutowireCandidates(beanName, type, descriptor);方法，具体的内容如下：

protected Map findAutowireCandidates(@Nullable String beanName, Class requiredType, DependencyDescriptor descriptor) {// 这儿是查找对应的beanName// this DefaultListableBeanFactory// requiredType User.class// true 查找的时候包含非单例的Bean// descriptor.isEager() 是否是非延迟加载// 这儿返回的beanName 应该是两个 一个 user 一个是superUser// 这儿是有序的，这儿的顺序就是你定义的顺序String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this, requiredType, true, descriptor.isEager());Map result = new LinkedHashMap<>(candidateNames.length);// 这儿代码我们不需要看，与我们的主流程没有任何关系，直接跳过for (Map.Entry, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {Class autowiringType = classObjectEntry.getKey();if (autowiringType.isAssignableFrom(requiredType)) {Object autowiringValue = classObjectEntry.getValue();autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);if (requiredType.isInstance(autowiringValue)) {result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);break;}}}// 直接跳到这个地方// 这儿遍历两次，将刚刚找出来的beanName,然后找到对应的Class 添加到reslut中去for (String candidate : candidateNames) {if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {addCandidateEntry(result, candidate, descriptor, requiredType);}}// 这儿的长度是2，直接返回if (result.isEmpty()) {boolean multiple = indicatesMultipleBeans(requiredType);// Consider fallback matches if the first pass failed to find anything...DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();for (String candidate : candidateNames) {if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor) &&(!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) {addCandidateEntry(result, candidate, descriptor, requiredType);}}if (result.isEmpty() && !multiple) {// Consider self references as a final pass...// but in the case of a dependency collection, not the very same bean itself.for (String candidate : candidateNames) {if (isSelfReference(beanName, candidate) &&(!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&isAutowireCandidate(candidate, fallbackDescriptor)) {addCandidateEntry(result, candidate, descriptor, requiredType);}}}}return result;
}

上面的流程走完了，我们在回到原来的代码，具体的如下：

@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {// 只有多次嵌套的时候这儿才不会返回nullInjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);try {// 快捷方式这儿也是没有的，返回的是nullObject shortcut = descriptor.resolveShortcut(this);if (shortcut != null) {return shortcut;}// 这儿返回的是user类型Class type = descriptor.getDependencyType();// 这儿返回的也是null，后面我们会讲Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);if (value != null) {if (value instanceof String) {String strVal = resolveEmbeddedValue((String) value);BeanDefinition bd = (beanName != null && containsBean(beanName) ?getMergedBeanDefinition(beanName) : null);value = evaluateBeanDefinitionString(strVal, bd);}TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());try {return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());}catch (UnsupportedOperationException ex) {// A custom TypeConverter which does not support TypeDescriptor resolution...return (descriptor.getField() != null ?converter.convertIfNecessary(value, type, descriptor.getField()) :converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));}}// 直接跳到这儿执行// 这儿判断是否要注入的是多个bean，也是nullObject multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);if (multipleBeans != null) {return multipleBeans;}// 这儿方法中的beanName 等于的是 annotationDependencyInjectionResolutionDemo 也是被注入的beanName// type 是User.class// descriptor 是前面我们的DependencyDescriptor.classMap matchingBeans = findAutowireCandidates(beanName, type, descriptor);// 这个map的长度是2，这个判断是不会进的，继续往下走if (matchingBeans.isEmpty()) {if (isRequired(descriptor)) {raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);}return null;}String autowiredBeanName;Object instanceCandidate;// 会走到这儿if (matchingBeans.size() > 1) {// 这儿会找到首要的Bean，就是PrimaryautowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);if (autowiredBeanName == null) {if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);}else {// In case of an optional Collection/Map, silently ignore a non-unique case:// possibly it was meant to be an empty collection of multiple regular beans// (before 4.3 in particular when we didn't even look for collection beans).return null;}}// 这儿找到了superUserinstanceCandidate = matchingBeans.get(autowiredBeanName);}else {// We have exactly one match.Map.Entry entry = matchingBeans.entrySet().iterator().next();autowiredBeanName = entry.getKey();instanceCandidate = entry.getValue();}// 添加到对应autowiredBeanNames 添加的内容是superUserif (autowiredBeanNames != null) {autowiredBeanNames.add(autowiredBeanName);}// superUser 直接getBean 这儿直接转成一个Bean对象if (instanceCandidate instanceof Class) {instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);}Object result = instanceCandidate;if (result instanceof NullBean) {if (isRequired(descriptor)) {raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);}result = null;}if (!ClassUtils.isAssignableValue(type, result)) {throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());}// 最终返回了return result;}finally {ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);}
}

上面的源码分析，是注入一个简单的，下面我们来分析下注入集合的。将原来的示例代码修改如下：

package org.learn.spring.dependency.injection;import org.learn.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;import java.util.Collection;
import java.util.Map;
import java.util.Set;// 注解实现延迟依赖注入处理过程
public class AnnotationDependencyInjectionResolutionDemo {@Autowired // 依赖查找(处理)private User user;  // DependencyDescriptor ->// 必须(required = true)// (eager = true) 实时注入// 通过类型(User.class)// 字段名称("user")// 是否是首要的(primary = true)@Autowired // 集合类型的依赖注入private Map users; // user superUserpublic static void main(String[] args) {// 创建BeanFactory的容器AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();// 注册Configuration Class 配置类 -> Spring BeanapplicationContext.register(AnnotationDependencyInjectionResolutionDemo.class);XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";// 加载XML资源，解析并生成BeanDefinitionbeanDefinitionReader.loadBeanDefinitions(xmlResourcePath);// 启动应用上下文applicationContext.refresh();// 依赖查找 LazyAnnotationDependencyInjectionDemo BeanAnnotationDependencyInjectionResolutionDemo demo = applicationContext.getBean(AnnotationDependencyInjectionResolutionDemo.class);// 期待输出superUser BeanSystem.out.println("demo.user = " + demo.user);// 显示的关闭spring应用上下文applicationContext.close();}
}

前面的代码都是一样的，我们直接看如下的代码：

@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {// 只有多次嵌套的时候这儿才不会返回nullInjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);try {// 快捷方式这儿也是没有的，返回的是nullObject shortcut = descriptor.resolveShortcut(this);if (shortcut != null) {return shortcut;}// 这儿返回的是user类型Class type = descriptor.getDependencyType();// 这儿返回的也是null，后面我们会讲Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);if (value != null) {if (value instanceof String) {String strVal = resolveEmbeddedValue((String) value);BeanDefinition bd = (beanName != null && containsBean(beanName) ?getMergedBeanDefinition(beanName) : null);value = evaluateBeanDefinitionString(strVal, bd);}TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());try {return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());}catch (UnsupportedOperationException ex) {// A custom TypeConverter which does not support TypeDescriptor resolution...return (descriptor.getField() != null ?converter.convertIfNecessary(value, type, descriptor.getField()) :converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));}}// 直接跳到这儿执行// 这儿判断是否要注入的是多个bean，我们先跳到这个方法中看对应的代码Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);if (multipleBeans != null) {return multipleBeans;}Map matchingBeans = findAutowireCandidates(beanName, type, descriptor);if (matchingBeans.isEmpty()) {if (isRequired(descriptor)) {raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);}return null;}String autowiredBeanName;Object instanceCandidate;if (matchingBeans.size() > 1) {autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);if (autowiredBeanName == null) {if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);}else {// In case of an optional Collection/Map, silently ignore a non-unique case:// possibly it was meant to be an empty collection of multiple regular beans// (before 4.3 in particular when we didn't even look for collection beans).return null;}}instanceCandidate = matchingBeans.get(autowiredBeanName);}else {// We have exactly one match.Map.Entry entry = matchingBeans.entrySet().iterator().next();autowiredBeanName = entry.getKey();instanceCandidate = entry.getValue();}if (autowiredBeanNames != null) {autowiredBeanNames.add(autowiredBeanName);}if (instanceCandidate instanceof Class) {instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);}Object result = instanceCandidate;if (result instanceof NullBean) {if (isRequired(descriptor)) {raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);}result = null;}if (!ClassUtils.isAssignableValue(type, result)) {throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());}return result;}finally {ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);}
}

这儿直接调用的resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);这个方法，具体的代码如下：

	@Nullableprivate Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName,@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) {// 这儿的获取的类型是mapfinal Class type = descriptor.getDependencyType();// 判断不满足 直接跳过if (descriptor instanceof StreamDependencyDescriptor) {Map matchingBeans = findAutowireCandidates(beanName, type, descriptor);if (autowiredBeanNames != null) {autowiredBeanNames.addAll(matchingBeans.keySet());}Stream