Java 中的依赖注入：概念、使用与最佳实践

简介

在 Java 开发中，依赖注入（Dependency Injection，简称 DI）是一种重要的软件设计模式，它极大地提升了代码的可维护性、可测试性和可扩展性。通过依赖注入，对象之间的依赖关系由外部进行管理和提供，而非对象自身负责创建依赖对象。这篇博客将深入探讨 Java 中的依赖注入，帮助你全面掌握这一强大的技术。

目录

1. 基础概念
2. 使用方法
   • 构造函数注入
   • Setter 注入
   • 接口注入
3. 常见实践
   • 依赖注入框架
   • 与 IoC 容器的结合
4. 最佳实践
   • 依赖的单一职责
   • 适当的作用域管理
   • 避免循环依赖
5. 小结
6. 参考资料

基础概念

依赖注入是控制反转（Inversion of Control，IoC）原则的一种具体实现方式。在传统的编程方式中，对象 A 若依赖对象 B，那么 A 通常会在内部自行创建 B 的实例，这使得 A 与 B 紧密耦合。而依赖注入则将创建和提供依赖对象的职责从依赖对象内部转移到外部，使得对象之间的依赖关系更加松散。

例如，一个 Car 类依赖于 Engine 类。在传统方式下，Car 类可能会在内部创建 Engine 实例：

public class Car {
    private Engine engine;

    public Car() {
        this.engine = new Engine();
    }

    public void drive() {
        engine.start();
        System.out.println("Car is driving.");
    }
}

public class Engine {
    public void start() {
        System.out.println("Engine started.");
    }
}

在依赖注入的方式下，Engine 实例由外部提供给 Car：

public class Car {
    private Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public void drive() {
        engine.start();
        System.out.println("Car is driving.");
    }
}

public class Engine {
    public void start() {
        System.out.println("Engine started.");
    }
}

这样，Car 类不再负责创建 Engine 实例，降低了两者之间的耦合度。

使用方法

构造函数注入

构造函数注入是最常用的依赖注入方式之一。通过构造函数，将依赖对象作为参数传入。

public class Logger {
    public void log(String message) {
        System.out.println(message);
    }
}

public class UserService {
    private final Logger logger;

    public UserService(Logger logger) {
        this.logger = logger;
    }

    public void registerUser(String username) {
        logger.log("Registering user: " + username);
        // 实际注册用户的逻辑
    }
}

在使用时：

public class Main {
    public static void main(String[] args) {
        Logger logger = new Logger();
        UserService userService = new UserService(logger);
        userService.registerUser("John");
    }
}

Setter 注入

Setter 注入通过对象的 setter 方法来注入依赖。

public class DatabaseConnection {
    public void connect() {
        System.out.println("Connected to database.");
    }
}

public class ProductDao {
    private DatabaseConnection connection;

    public void setConnection(DatabaseConnection connection) {
        this.connection = connection;
    }

    public void saveProduct(Product product) {
        connection.connect();
        // 实际保存产品的逻辑
    }
}

使用示例：

public class Main {
    public static void main(String[] args) {
        DatabaseConnection connection = new DatabaseConnection();
        ProductDao productDao = new ProductDao();
        productDao.setConnection(connection);
        Product product = new Product("Laptop", 1000);
        productDao.saveProduct(product);
    }
}

接口注入

接口注入通过接口来定义注入的方法。这种方式在实际应用中相对较少使用。

public interface MessageSender {
    void sendMessage(String message);
}

public class EmailSender implements MessageSender {
    @Override
    public void sendMessage(String message) {
        System.out.println("Sending email: " + message);
    }
}

public class NotificationService {
    private MessageSender messageSender;

    public void setMessageSender(MessageSender messageSender) {
        this.messageSender = messageSender;
    }

    public void sendNotification(String message) {
        messageSender.sendMessage(message);
    }
}

使用示例：

public class Main {
    public static void main(String[] args) {
        EmailSender emailSender = new EmailSender();
        NotificationService notificationService = new NotificationService();
        notificationService.setMessageSender(emailSender);
        notificationService.sendNotification("Important update!");
    }
}

常见实践

依赖注入框架

在实际项目中，通常会使用依赖注入框架来简化依赖注入的过程。常见的框架有 Spring 和 Google Guice。

以 Spring 为例：

首先，添加 Spring 依赖（例如使用 Maven）：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.10</version>
</dependency>

定义一个服务类：

import org.springframework.stereotype.Service;

@Service
public class BookService {
    public void borrowBook(String bookTitle) {
        System.out.println("Borrowing book: " + bookTitle);
    }
}

另一个类依赖 BookService：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class LibraryUser {
    private final BookService bookService;

    @Autowired
    public LibraryUser(BookService bookService) {
        this.bookService = bookService;
    }

    public void borrow() {
        bookService.borrowBook("Effective Java");
    }
}

配置并使用 Spring 容器：

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(LibraryUser.class, BookService.class);
        context.refresh();

        LibraryUser user = context.getBean(LibraryUser.class);
        user.borrow();
    }
}

与 IoC 容器的结合

依赖注入通常与 IoC 容器结合使用。IoC 容器负责创建、管理和提供对象实例，使得依赖注入更加方便和高效。Spring 框架就是一个强大的 IoC 容器，它不仅支持各种依赖注入方式，还提供了许多其他企业级功能。

最佳实践

依赖的单一职责

每个依赖对象应该只负责一项职责。例如，一个 UserService 类不应该既负责用户注册，又负责用户登录和密码找回等多种职责。将不同职责分离到不同的类中，使得代码更加清晰和易于维护。

适当的作用域管理

在使用依赖注入框架时，要注意管理依赖对象的作用域。例如，在 Spring 中，常见的作用域有 singleton（单例）和 prototype（原型）。对于无状态的服务，可以使用 singleton 作用域以提高性能；而对于有状态的对象，可能需要使用 prototype 作用域，以确保每个使用场景都有独立的实例。

避免循环依赖

循环依赖是指两个或多个对象相互依赖，形成一个闭环。这会导致对象创建过程中的复杂性和潜在的错误。在设计架构时，要尽量避免循环依赖。如果无法避免，可以考虑使用延迟注入等技术来解决。

小结

依赖注入是 Java 开发中一项强大的技术，它通过将依赖对象的创建和管理外部化，降低了对象之间的耦合度，提高了代码的可维护性、可测试性和可扩展性。掌握不同的依赖注入方式（构造函数注入、Setter 注入、接口注入）以及依赖注入框架（如 Spring）的使用，遵循最佳实践原则，将有助于编写高质量的 Java 代码。

参考资料

• Spring Framework Documentation
• Google Guice Documentation
• 《Effective Java》 by Joshua Bloch