Java Composition：如何实现依赖注入

发布时间：2025-04-10 21:55:05 作者：小樊
来源：亿速云阅读：100

在Java中，依赖注入（Dependency Injection，简称DI）是一种设计模式，用于降低代码间的耦合度。通过将依赖关系的创建和管理交给外部容器，而不是在类内部直接创建，可以实现更好的模块化和可测试性。以下是使用Java实现依赖注入的几种常见方法：

1. 使用构造器注入

构造器注入是通过类的构造函数来注入依赖。这是最常用和推荐的方式之一，因为它使得依赖关系清晰且不可变。

示例

// 定义一个接口
public interface MessageService {
    void sendMessage(String message);
}

// 实现接口
public class EmailService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("发送邮件: " + message);
    }
}

// 使用依赖的类
public class Notification {
    private final MessageService messageService;

    // 构造器注入
    public Notification(MessageService messageService) {
        this.messageService = messageService;
    }

    public void notifyUser(String message) {
        messageService.sendMessage(message);
    }
}

// 主类进行依赖注入
public class Main {
    public static void main(String[] args) {
        MessageService emailService = new EmailService();
        Notification notification = new Notification(emailService);
        notification.notifyUser("Hello, Dependency Injection!");
    }
}

2. 使用Setter方法注入

Setter方法注入是通过类的setter方法来注入依赖。这种方式适用于可选依赖或在对象创建后可能需要更改依赖的情况。

示例

public class Notification {
    private MessageService messageService;

    // Setter方法注入
    public void setMessageService(MessageService messageService) {
        this.messageService = messageService;
    }

    public void notifyUser(String message) {
        if (messageService == null) {
            throw new IllegalStateException("MessageService未注入");
        }
        messageService.sendMessage(message);
    }
}

// 主类进行依赖注入
public class Main {
    public static void main(String[] args) {
        Notification notification = new Notification();
        MessageService emailService = new EmailService();
        notification.setMessageService(emailService);
        notification.notifyUser("Hello, Setter Injection!");
    }
}

3. 使用字段注入

字段注入是通过直接在字段上使用注解来注入依赖。这种方式简单直观，但不推荐用于生产环境，因为它不利于单元测试和代码的可读性。

示例（使用Spring框架）

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

@Component
public class Notification {
    @Autowired
    private MessageService messageService;

    public void notifyUser(String message) {
        messageService.sendMessage(message);
    }
}

@Component
public class EmailService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("发送邮件: " + message);
    }
}

// Spring配置类
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
}

运行Spring应用时，Spring容器会自动装配Notification类的messageService字段。

4. 使用依赖注入框架（如Spring）

Spring框架是Java中最流行的依赖注入框架之一。它提供了强大的功能，如控制反转（IoC）容器、AOP、事务管理等。

示例（使用Spring Boot）

首先，确保你已经添加了Spring Boot的依赖。以下是一个简单的Spring Boot应用示例：

// Maven依赖（pom.xml）
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
</dependencies>

// MessageService接口
public interface MessageService {
    void sendMessage(String message);
}

// EmailService实现
import org.springframework.stereotype.Service;

@Service
public class EmailService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("发送邮件: " + message);
    }
}

// Notification类
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Notification {
    private final MessageService messageService;

    @Autowired
    public Notification(MessageService messageService) {
        this.messageService = messageService;
    }

    public void notifyUser(String message) {
        messageService.sendMessage(message);
    }
}

// 主应用类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class DependencyInjectionApplication {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(DependencyInjectionApplication.class, args);
        Notification notification = context.getBean(Notification.class);
        notification.notifyUser("Hello, Spring Boot!");
    }
}

运行上述应用，Spring Boot会自动装配Notification类的依赖，并输出：

发送邮件: Hello, Spring Boot!

5. 使用Java内置的依赖注入机制（如Java EE的CDI）

Java EE提供了Contexts and Dependency Injection（CDI）规范，可以通过注解实现依赖注入。

示例

import javax.inject.Inject;
import javax.enterprise.context.ApplicationScoped;

// MessageService接口
public interface MessageService {
    void sendMessage(String message);
}

// EmailService实现
import javax.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class EmailService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("发送邮件: " + message);
    }
}

// Notification类
import javax.inject.Inject;
import javax.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class Notification {
    private final MessageService messageService;

    @Inject
    public Notification(MessageService messageService) {
        this.messageService = messageService;
    }

    public void notifyUser(String message) {
        messageService.sendMessage(message);
    }
}

// 主类（需要使用CDI容器启动）
import javax.enterprise.event.Observes;
import javax.enterprise.inject.se.SeContainer;
import javax.enterprise.inject.se.SeContainerInitializer;

public class Main {
    public static void main(String[] args) {
        try (SeContainer container = SeContainerInitializer.newInstance().initialize()) {
            Notification notification = container.select(Notification.class).get();
            notification.notifyUser("Hello, CDI!");
        }
    }
}

运行上述代码，CDI容器会自动装配Notification类的依赖，并输出：

发送邮件: Hello, CDI!

总结

依赖注入是一种强大的设计模式，能够提高代码的可维护性和可测试性。在Java中，可以通过构造器注入、Setter方法注入、字段注入等方式实现依赖注入，而使用依赖注入框架（如Spring）则可以更方便地管理复杂的依赖关系。选择合适的注入方式取决于具体的应用场景和需求。