手把手教你用Java实现IoC，轻松搞定依赖注入！

想要掌握Java的IoC（控制反转）和依赖注入（DI）？本文手把手教你搞定！IoC将对象创建和依赖管理交给外部容器，DI则通过构造器、Setter或接口注入实现。以Spring为例，我们讲解如何配置容器、定义Bean，并使用@Autowired进行依赖注入，包括构造器注入（推荐）、Setter注入（可选）和字段注入（不推荐）。同时，还会介绍Java配置方式，使用@Configuration和@Bean定义Bean。本文还将深入探讨Spring IoC容器的启动流程，从资源定位、加载解析到Bean的实例化、注入和初始化，并详细解析循环依赖问题及其解决方案——三级缓存机制。最后，对比构造器、Setter和字段三种注入方式的优缺点，助你选择最合适的依赖注入策略，提升代码质量。

IoC的核心是将对象创建和依赖管理交给外部容器，DI通过构造器、Setter或接口注入实现。Spring实现DI需配置容器并定义Bean，使用@Autowired进行注入，可通过构造器（推荐）、Setter（可选）或字段（不推荐）完成。Java配置用@Configuration和@Bean定义Bean。启动流程包括定位资源、加载解析为BeanDefinition、注册、实例化、注入、初始化至就绪状态。循环依赖通过三级缓存解决：一级存完整Bean，二级存早期Bean，三级存ObjectFactory，仅支持单例Bean。构造器注入保证必需依赖，Setter用于可选依赖，字段注入破坏封装应避免。

IoC（控制反转）的核心在于将对象的创建和依赖关系的管理权从对象自身转移到外部容器。依赖注入（DI）则是实现IoC的一种常用方式，它通过构造器注入、Setter方法注入或接口注入，将依赖对象“注入”到目标对象中，而非由目标对象主动创建。简单来说，就是让容器帮你new对象，并把对象需要的“零件”也给你装好。

解决方案

Java中实现IoC/DI，通常会借助第三方框架，例如Spring、Guice、Dagger等。这里以Spring为例，讲解如何实现依赖注入：

1. 使用Spring容器: 首先，你需要配置Spring容器。这通常通过XML配置、注解配置或者Java配置来实现。

2. 定义Bean: 你需要定义哪些类由Spring容器来管理，这些类被称为Bean。可以使用@Component、@Service、@Repository、@Controller等注解来标记Bean，或者在XML配置中声明Bean。

3. 依赖注入: Spring提供了三种主要的依赖注入方式：

   • 构造器注入: 通过类的构造器来注入依赖。使用@Autowired注解在构造器上，Spring会自动找到匹配的Bean并注入。

     @Component
     public class MyService {
         private final MyRepository myRepository;
     
         @Autowired
         public MyService(MyRepository myRepository) {
             this.myRepository = myRepository;
         }
     
         // ...
     }

   • Setter方法注入: 通过Setter方法来注入依赖。使用@Autowired注解在Setter方法上。

     @Component
     public class MyService {
         private MyRepository myRepository;
     
         @Autowired
         public void setMyRepository(MyRepository myRepository) {
             this.myRepository = myRepository;
         }
     
         // ...
     }

   • 字段注入: 直接在字段上使用@Autowired注解。虽然方便，但不太推荐，因为它破坏了类的封装性，并且在单元测试时可能会遇到问题。

     @Component
     public class MyService {
         @Autowired
         private MyRepository myRepository;
     
         // ...
     }

4. 使用@Qualifier解决歧义: 如果存在多个相同类型的Bean，Spring不知道应该注入哪个，这时可以使用@Qualifier注解来指定具体的Bean名称。

   ```java
   @Component
   public class MyService {
       private final MyRepository myRepository;
   
       @Autowired
       public MyService(@Qualifier("myRepositoryImpl1") MyRepository myRepository) {
           this.myRepository = myRepository;
       }
   
       // ...
   }
   ```

5. Java配置: 除了XML和注解，还可以使用Java配置来定义Bean和依赖关系。使用@Configuration注解标记配置类，使用@Bean注解标记Bean的创建方法。

   ```java
   @Configuration
   public class AppConfig {
       @Bean
       public MyRepository myRepository() {
           return new MyRepositoryImpl();
       }
   
       @Bean
       public MyService myService(MyRepository myRepository) {
           return new MyService(myRepository);
       }
   }
   ```

Spring IoC容器启动流程是怎样的？

Spring IoC容器的启动流程可以大致分为以下几个步骤：

1. 定位资源: 容器首先需要定位到Bean定义的资源，例如XML配置文件、注解标记的类等。
2. 加载资源: 容器加载这些资源，并将Bean定义解析成Spring内部的BeanDefinition对象。
3. 注册BeanDefinition: 容器将BeanDefinition注册到BeanDefinitionRegistry中，这是一个Bean定义的注册中心。
4. 实例化Bean: 容器根据BeanDefinition创建Bean实例。这通常发生在第一次请求Bean时，也可以配置成在容器启动时就预先实例化。
5. 依赖注入: 容器将Bean所需的依赖注入到Bean实例中。
6. 初始化Bean: 容器调用Bean的初始化方法（如果配置了），例如实现了InitializingBean接口的afterPropertiesSet()方法，或者使用@PostConstruct注解标记的方法。
7. Bean准备就绪: Bean实例创建完成，可以被应用程序使用了。

构造器注入、Setter注入和字段注入，应该选择哪种？

这三种注入方式各有优缺点：

• 构造器注入: 强制依赖，保证对象创建时所有必需的依赖都已就绪。有利于对象的不可变性。推荐使用。
• Setter注入: 允许可选依赖，可以在对象创建后动态设置依赖。但容易出现依赖未设置的情况。
• 字段注入: 最简单，但破坏了封装性，不利于单元测试。不推荐使用。

总体来说，构造器注入是最佳选择，因为它能够保证对象的完整性和不可变性。如果存在可选依赖，可以考虑Setter注入。尽量避免字段注入。

循环依赖问题如何解决？

循环依赖是指两个或多个Bean之间相互依赖，形成一个循环引用。例如，A依赖B，B依赖C，C又依赖A。Spring IoC容器可以通过以下方式解决循环依赖问题：

• 提前暴露Bean: Spring在创建Bean时，会提前将Bean的ObjectFactory暴露出来，以便其他Bean可以引用。这样，即使Bean还没有完全创建完成，也可以被其他Bean引用。
• 三级缓存: Spring使用三级缓存来解决循环依赖问题。
  • 一级缓存 (singletonObjects): 存放完全初始化好的Bean。
  • 二级缓存 (earlySingletonObjects): 存放提前暴露的Bean，这些Bean可能还没有完全初始化完成。
  • 三级缓存 (singletonFactories): 存放Bean的ObjectFactory，用于创建Bean实例。

当出现循环依赖时，Spring会首先尝试从一级缓存中获取Bean，如果获取不到，则尝试从二级缓存中获取，如果还获取不到，则从三级缓存中获取ObjectFactory，并使用ObjectFactory创建Bean实例。创建Bean实例后，将Bean放入二级缓存，并移除三级缓存中的ObjectFactory。当Bean完全初始化完成后，将Bean从二级缓存移动到一级缓存。

需要注意的是，Spring只能解决单例Bean的循环依赖问题，对于原型Bean，由于每次获取Bean都是一个新的实例，因此无法解决循环依赖问题。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。