Spring 依赖注入（DI）详解：原理、实现与最佳实践

优点

可变依赖：适用于在运行时动态改变依赖的情况。 延迟初始化：依赖可以在对象创建后注入，适用于可选依赖。

缺点

初始化问题：对象可能在依赖注入前被使用，导致空指针异常。 难以控制顺序：多个依赖的注入顺序难以控制，可能导致不一致的状态。

3. 属性注入（Field Injection）

属性注入是直接在类的字段上使用@Autowired 注解，将依赖注入到字段中。

@Service
public class UserService {
    @Autowired
    private Student s3;

    public void print() {
        System.out.println("do Service");
        System.out.println(s3);
    }
}

判断属性注入是否成功，需补充测试代码：

@Data
public class Student {
    public String name;
    public int age;
}

@Component
public class StudentComponent {
    @Bean
    public Student s1() {
        Student student = new Student();
        student.setAge(18);
        student.setName("张三");
        return student;
    }

    @Primary
    @Bean
    public Student s2() {
        Student student = new Student();
        student.setAge(20);
        student.setName("李四");
        return student;
    }
}

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(DemoApplication.class, args);
        UserService userService = context.getBean(UserService.class);
        userService.print();
    }
}

优点

简单直观，代码简洁。 适用于不需要显式控制注入时机的场景。

缺点

破坏封装性：直接暴露了类的字段，违反了面向对象的封装原则。 延迟初始化问题：字段可能在类初始化时未被注入，导致空指针异常。 难以测试：由于字段直接依赖外部注入，单元测试时可能需要额外的配置。

三、Spring DI 的核心注解

在 Spring 中，依赖注入主要通过以下注解实现：

1. @Autowired

@Autowired是最常用的注解，用于自动注入依赖。

@Service
public class UserService {
    @Autowired
    private Student s3;

    public void print() {
        System.out.println("do Service");
        System.out.println(s3);
    }
}

2. @Qualifier

当存在多个相同类型的 Bean 时，可以通过@Qualifier指定具体的 Bean。

@Component
public class StudentComponent {
    @Bean(name = "s3")
    public Student s1() {
        Student student = new Student();
        student.setAge(18);
        student.setName("张三");
        return student;
    }

    @Primary
    @Bean(name = "s4")
    public Student s2() {
        Student student = new Student();
        student.setAge(20);
        student.setName("李四");
        return student;
    }
}

Spring 默认情况下会根据类型来注入 Bean，但如果存在多个相同类型的 Bean，Spring 会不知道该注入哪一个。此时可以使用@Primary注解来指定一个默认的 Bean，或使用@Qualifier明确指定。

@Service
public class UserService {
    @Autowired
    @Qualifier("s3")
    private Student s3;

    public void print() {
        System.out.println("do Service");
        System.out.println(s3);
    }
}

3. @Resource

@Resource是 JDK 提供的注解，也可用于依赖注入。

@Service
public class UserService {
    @Resource(name = "s3")
    private Student s3;

    public void print() {
        System.out.println("do Service");
        System.out.println(s3);
    }
}

4. @Value

@Value用于注入配置文件中的属性值。

@Service
public class UserService {
    @Value("${my.key}")
    private String myKey;

    public void print() {
        System.out.println("配置文件属性值" + myKey);
    }
}

四、Spring DI 的高级特性

1. 条件注入

通过@Conditional系列注解，可以根据条件动态注入 Bean。

@Configuration
public class AppConfig {
    @Bean
    @ConditionalOnProperty(name = "env", havingValue = "dev")
    public UserDAO devUserDAO() {
        return new DevUserDAO();
    }

    @Bean
    @ConditionalOnProperty(name = "env", havingValue = "prod")
    public UserDAO prodUserDAO() {
        return new ProdUserDAO();
    }
}

2. 循环依赖

在 Spring 中，循环依赖通常通过构造注入解决。通过@Autowired注解的required属性，可以控制依赖是否为必选。

@Service
public class ServiceA {
    @Autowired(required = false)
    private ServiceB serviceB;

    public void doSomething() {
        if (serviceB != null) {
            serviceB.doSomething();
        }
    }
}

3. 注入范围

通过@Scope注解，可以控制 Bean 的作用域（如singleton、prototype等）。

@Service
@Scope("prototype")
public class UserService {
    public void saveUser(User user) {
        System.out.println("Saving user in prototype scope");
    }
}

五、三种注入方式的比较

六、最佳实践

1. 优先使用构造注入：构造注入在处理不可变依赖时更加安全和直观。
2. 避免过度注入：只注入真正需要的依赖，避免'饥饿注入'。
3. 合理使用@Qualifier：在存在多个相同类型 Bean 时，通过@Qualifier明确指定。
4. 结合配置文件：通过@Value注解将配置文件中的属性注入到 Bean 中。
5. 测试驱动开发：通过依赖注入，更容易编写单元测试。

七、总结

通过本文，你了解了 Spring 依赖注入（DI）的核心原理，掌握了如何用它实现代码的优雅解耦。Spring DI 帮助你实现模块化设计、提升可测试性和增强扩展性。用 Spring DI，让你的代码更干净、更易维护，也让开发过程更具乐趣。