依赖注入的定义

在 Java 中，依赖注入（Dependency Injection，简称 DI）是一种设计模式，它是控制反转（Inversion of Control，简称 IoC）的一种具体实现方式。控制反转是指将对象的创建和依赖关系的管理从对象内部转移到外部容器中，而依赖注入则是通过外部容器将对象所依赖的其他对象注入到该对象中。

简单来说，当一个类需要另一个类的功能时，传统方式是在该类内部主动创建所依赖的类的实例；而在依赖注入模式下，所依赖的类的实例由外部提供，这个类只需要使用这些实例即可。

依赖注入的好处

1. 降低耦合度

通过依赖注入，对象之间的依赖关系由外部容器管理，使得各个类之间的耦合度降低。一个类不再需要直接负责创建和管理它所依赖的对象，只需要关注自身的业务逻辑。这样，当所依赖的对象发生变化时，不需要修改该类的代码，提高了代码的可维护性和可扩展性。

例如，在一个用户服务类中，如果需要使用数据库操作类，传统方式下用户服务类会直接在内部创建数据库操作类的实例，当数据库操作类的实现发生变化时，用户服务类也需要相应修改。而使用依赖注入，用户服务类只需要接收外部传入的数据库操作类实例，数据库操作类的变化不会影响用户服务类。

2. 提高可测试性

依赖注入使得代码的测试更加容易。在进行单元测试时，可以通过注入模拟对象（Mock Object）来替代真实的依赖对象，从而隔离测试环境，专注于测试目标类的功能。这样可以减少测试的复杂性，提高测试的准确性和效率。

例如，在测试一个服务类时，如果该服务类依赖于一个远程服务，通过依赖注入可以在测试时注入一个模拟的远程服务对象，避免了对真实远程服务的依赖，使得测试可以独立进行。

3. 增强代码的灵活性和可配置性

使用依赖注入可以在运行时动态地改变对象的依赖关系。通过配置文件或注解等方式，可以轻松地替换所依赖的对象，实现不同的业务逻辑。这样，代码可以根据不同的环境和需求进行灵活配置。

例如，在一个应用中，根据不同的配置可以选择使用不同的数据库连接池，只需要在配置文件中修改相应的依赖注入配置即可。

依赖注入的实现方式

1. 构造函数注入

构造函数注入是指通过目标类的构造函数将依赖对象传递进去。在创建目标类的实例时，必须提供所依赖的对象，否则无法创建实例。

示例代码：

// 依赖接口
interface DatabaseService {
    void saveData(String data);
}

// 依赖实现类
class MySQLDatabaseService implements DatabaseService {
    @Override
    public void saveData(String data) {
        System.out.println("Saving data to MySQL: " + data);
    }
}

// 目标类
class UserService {
    private final DatabaseService databaseService;

    // 构造函数注入
    public UserService(DatabaseService databaseService) {
        this.databaseService = databaseService;
    }

    public void addUser(String userData) {
        databaseService.saveData(userData);
    }
}

// 使用示例
public class ConstructorInjectionExample {
    public static void main(String[] args) {
        DatabaseService databaseService = new MySQLDatabaseService();
        UserService userService = new UserService(databaseService);
        userService.addUser("John Doe");
    }
}

在上述代码中，UserService 类通过构造函数接收一个 DatabaseService 类型的对象，从而实现了依赖注入。

2. Setter 方法注入

Setter 方法注入是指通过目标类的 Setter 方法将依赖对象传递进去。目标类可以先创建实例，然后通过调用 Setter 方法来设置所依赖的对象。

示例代码：

// 依赖接口
interface DatabaseService {
    void saveData(String data);
}

// 依赖实现类
class MySQLDatabaseService implements DatabaseService {
    @Override
    public void saveData(String data) {
        System.out.println("Saving data to MySQL: " + data);
    }
}

// 目标类
class UserService {
    private DatabaseService databaseService;

    // Setter 方法注入
    public void setDatabaseService(DatabaseService databaseService) {
        this.databaseService = databaseService;
    }

    public void addUser(String userData) {
        if (databaseService != null) {
            databaseService.saveData(userData);
        }
    }
}

// 使用示例
public class SetterInjectionExample {
    public static void main(String[] args) {
        UserService userService = new UserService();
        DatabaseService databaseService = new MySQLDatabaseService();
        userService.setDatabaseService(databaseService);
        userService.addUser("Jane Smith");
    }
}

在上述代码中，UserService 类通过 setDatabaseService 方法接收一个 DatabaseService 类型的对象，从而实现了依赖注入。

3. 接口注入

接口注入是指目标类实现一个特定的接口，该接口定义了一个方法用于注入依赖对象。外部容器通过调用该接口方法将依赖对象注入到目标类中。

示例代码：

// 依赖注入接口
interface DatabaseServiceInjector {
    void injectDatabaseService(DatabaseService databaseService);
}

// 依赖接口
interface DatabaseService {
    void saveData(String data);
}

// 依赖实现类
class MySQLDatabaseService implements DatabaseService {
    @Override
    public void saveData(String data) {
        System.out.println("Saving data to MySQL: " + data);
    }
}

// 目标类
class UserService implements DatabaseServiceInjector {
    private DatabaseService databaseService;

    @Override
    public void injectDatabaseService(DatabaseService databaseService) {
        this.databaseService = databaseService;
    }

    public void addUser(String userData) {
        if (databaseService != null) {
            databaseService.saveData(userData);
        }
    }
}

// 使用示例
public class InterfaceInjectionExample {
    public static void main(String[] args) {
        UserService userService = new UserService();
        DatabaseService databaseService = new MySQLDatabaseService();
        userService.injectDatabaseService(databaseService);
        userService.addUser("Bob Johnson");
    }
}

在上述代码中，UserService 类实现了 DatabaseServiceInjector 接口，通过 injectDatabaseService 方法接收一个 DatabaseService 类型的对象，从而实现了依赖注入。

在实际开发中，构造函数注入和 Setter 方法注入是比较常用的方式，Spring 框架中也广泛使用这两种方式来实现依赖注入。