本文共 10228 字，大约阅读时间需要 34 分钟。

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

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

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

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

• Autowiring（自动绑定）

3. 依赖注入类型

2. 自动绑定（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.

• 优点

  • Autowiring can significantly reduce the need to specify properties or constructor arguments.
  • Autowiring can update a configuration as your objects evolve.

3. 自动绑定（Autowiring）模式

参考枚举：org.springframework.beans.factory.annotation.Autowire

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

官方说明

Limitations and Disadvantages of Autowiring 小节 链接：https://docs.spring.io/spring-framework/docs/5.2.2.RELEASE/spring-framework-reference/core.html#beans-autowired-exceptions

5. Setter 方法注入

• 手动模式
  • XML 资源配置元信息

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 资源，解析并且生成 BeanDefinition        beanDefinitionReader.loadBeanDefinitions(xmlResourcePath);        // 依赖查找并且创建 Bean        UserHolder userHolder = beanFactory.getBean(UserHolder.class);        System.out.println(userHolder);    }

• Java 注解配置元信息

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 资源，解析并且生成 BeanDefinition        beanDefinitionReader.loadBeanDefinitions(xmlResourcePath);        // 启动 Spring 应用上下文        applicationContext.refresh();        // 依赖查找并且创建 Bean        UserHolder userHolder = applicationContext.getBean(UserHolder.class);        System.out.println(userHolder);        // 显示地关闭 Spring 应用上下文        applicationContext.close();    }    @Bean    public UserHolder userHolder(User user) {           UserHolder userHolder = new UserHolder();        userHolder.setUser(user);        return userHolder;    }

• API 配置元信息

public static void main(String[] args) {           // 创建 BeanFactory 容器        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();        // 生成 UserHolder 的 BeanDefinition        BeanDefinition userHolderBeanDefinition = createUserHolderBeanDefinition();        // 注册 UserHolder 的 BeanDefinition        applicationContext.registerBeanDefinition("userHolder", userHolderBeanDefinition);        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);        String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";        // 加载 XML 资源，解析并且生成 BeanDefinition        beanDefinitionReader.loadBeanDefinitions(xmlResourcePath);        // 启动 Spring 应用上下文        applicationContext.refresh();        // 依赖查找并且创建 Bean        UserHolder userHolder = applicationContext.getBean(UserHolder.class);        System.out.println(userHolder);        // 显示地关闭 Spring 应用上下文        applicationContext.close();    }    /**     * 为 {@link UserHolder} 生成 {@link BeanDefinition}     *     * @return     */    private static BeanDefinition createUserHolderBeanDefinition() {           BeanDefinitionBuilder definitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(UserHolder.class);        definitionBuilder.addPropertyReference("user", "superUser");        return definitionBuilder.getBeanDefinition();    }

• 自动模式
  • byName
  • byType

6. 构造器依赖注入：官方为什么推荐使用构造器注入？

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

7.字段注入：为什么Spring官方文档没有单独列举这种注入方式？

手动模式

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

@Autowired  private UserHolder userHolder; //    static @Autowired 会忽略掉静态字段，即不注入  @Resource  private UserHolder userHolder2;

8. 方法注入：方法注入是@Autowired专利吗？

手动模式

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

private UserHolder userHolder;    private UserHolder userHolder2;    @Autowired    public void init1(UserHolder userHolder) {           this.userHolder = userHolder;    }    @Resource    public void init2(UserHolder userHolder2) {           this.userHolder2 = userHolder2;    }    @Bean    public UserHolder userHolder(User user) {           return new UserHolder(user);    }

9. 接口回调注入：回调注入的使用场景和限制有哪些？

10.依赖注入类型选择：各种依赖注入有什么样的使用场景？

• 低依赖：构造器注入（强制依赖注入）
• 多依赖：Setter 方法注入(注入的顺序和时机取决于用户，可能有问题)
• 便利性：字段注入
• 声明类：方法注入

11.基础类型注入：String和Java原生类型也能注入Bean的属性，它们算依赖注入吗？

• 原生类型（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 等

           
            
            
            
            
                
                     
      
       BEIJING
                      
      
       SHANGHAI
                  
             
            
        
   

12.集合类型注入：注入Collection和Map类型的依赖区别？还支持哪些集合类型？

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

13. 限定注入：如何限定Bean名称注入？如何实现Bean逻辑分组注入？

• 使用注解 @Qualifier 限定
  • 通过 Bean 名称限定
  • 通过分组限定
• 基于注解 @Qualifier 扩展限定
  • 自定义注解 - 如 Spring Cloud @LoadBalanced

@Configurationpublic class QualifierAnnotationDependencyInjectionDemo {       @Autowired    private User user; // superUser -> primary =true    @Autowired    @Qualifier("user") // 指定 Bean 名称或 ID    private User namedUser;    // 整体应用上下文存在 4 个 User 类型的 Bean:    // superUser    // user    // user1 -> @Qualifier    // user2 -> @Qualifier    @Autowired    private Collection
   
     allUsers; // 2 Beans = user + superUser    @Autowired    @Qualifier    private Collection
    
      qualifiedUsers; // 2 Beans = user1 + user2 -> 4 Beans = user1 + user2 + user3 + user4    @Autowired    @UserGroup    private Collection
     
       groupedUsers; // 2 Beans = user3 + user4    @Bean    @Qualifier // 进行逻辑分组    public User user1() {           return createUser(7L);    }    @Bean    @Qualifier // 进行逻辑分组    public User user2() {           return createUser(8L);    }    @Bean    @UserGroup    public User user3() {           return createUser(9L);    }    @Bean    @UserGroup    public User user4() {           return createUser(10L);    }    private 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 Bean        applicationContext.register(QualifierAnnotationDependencyInjectionDemo.class);        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);        String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";        // 加载 XML 资源，解析并且生成 BeanDefinition        beanDefinitionReader.loadBeanDefinitions(xmlResourcePath);        // 启动 Spring 应用上下文        applicationContext.refresh();        // 依赖查找 QualifierAnnotationDependencyInjectionDemo Bean        QualifierAnnotationDependencyInjectionDemo demo = applicationContext.getBean(QualifierAnnotationDependencyInjectionDemo.class);        // 期待输出 superUser Bean        System.out.println("demo.user = " + demo.user);        // 期待输出 user Bean        System.out.println("demo.namedUser = " + demo.namedUser);        // 期待输出 superUser user user1 user2        System.out.println("demo.allUsers = " + demo.allUsers);        // 期待输出 user1 user2        System.out.println("demo.qualifiedUsers = " + demo.qualifiedUsers);        // 期待输出 user3 user4        System.out.println("demo.groupedUsers = " + demo.groupedUsers);        // 显示地关闭 Spring 应用上下文        applicationContext.close();    }}
     
    
   

14.延迟依赖注入：如何实现延迟执行依赖注入？与延迟依赖查找是类似的吗？

• 使用 API ObjectFactory 延迟注入
  • 单一类型
  • 集合类型
• 使用 API ObjectProvider 延迟注入（推荐）
  • 单一类型
  • 集合类型

@Configurationpublic class LazyAnnotationDependencyInjectionDemo {       @Autowired    @Qualifier("user")    private User user; // 实时注入    @Autowired    private ObjectProvider
   
     userObjectProvider; // 延迟注入    @Autowired    private ObjectFactory
    
     
      > usersObjectFactory;    public static void main(String[] args) {           // 创建 BeanFactory 容器        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();        // 注册 Configuration Class（配置类） -> Spring Bean        applicationContext.register(LazyAnnotationDependencyInjectionDemo.class);        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);        String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";        // 加载 XML 资源，解析并且生成 BeanDefinition        beanDefinitionReader.loadBeanDefinitions(xmlResourcePath);        // 启动 Spring 应用上下文        applicationContext.refresh();        // 依赖查找 QualifierAnnotationDependencyInjectionDemo Bean        LazyAnnotationDependencyInjectionDemo demo = applicationContext.getBean(LazyAnnotationDependencyInjectionDemo.class);        // 期待输出 superUser Bean        System.out.println("demo.user = " + demo.user);        // 期待输出 superUser Bean        System.out.println("demo.userObjectProvider = " + demo.userObjectProvider.getObject()); // 继承 ObjectFactory        // 期待输出 superUser user Beans        System.out.println("demo.usersObjectFactory = " + demo.usersObjectFactory.getObject());        demo.userObjectProvider.forEach(System.out::println);        // 显示地关闭 Spring 应用上下文        applicationContext.close();    }}
     
    
   

15. 依赖处理过程：依赖处理时会发生什么？其中与依赖查找的差异在哪？

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

16. @Autowired注入：@Autowired注入的规则和原理有哪些？

@Autowired 注入规则

• 非静态字段
• 非静态方法
• 构造器

@Autowired 注入过程

• 元信息解析
• 依赖查找
• 依赖注入（字段、方法）

转载地址：http://kthwz.baihongyu.com/