设计模式-依赖注入模式

设计模式专栏

- 模式介绍
- 模式特点
- 应用场景
- 依赖注入和控制反转的区别
- 代码示例
- - Java实现依赖注入模式
  - Python实现依赖注入模式
- 依赖注入模式在spring中的应用

模式介绍

依赖注入（Dependency Injection，简称DI）是一种面向对象编程中的设计模式，它的目的是将一个对象所依赖的其他对象的创建过程从该对象本身中分离出来，以便更好地实现解耦和可测试性。

在DI模式中，对象不是通过自己创建所需要的依赖对象，而是通过构造函数、属性或接口传递进来。主要有以下几种方式：

构造函数注入（Constructor Injection）：依赖对象通过被依赖对象的构造函数传入。这种方式是DI的主要方式，也是最简单的一种方式。它可以保证依赖对象的创建和注入是在同一时间完成的，因此可以确保依赖对象的可用性。适用于依赖对象需要在整个对象生命周期中都存在的情况，例如一个数据库连接对象。
属性注入（Property Injection）：依赖对象通过被依赖对象的公共属性进行注入。
接口注入（Interface Injection）：依赖对象通过实现被依赖对象的接口进行注入。

依赖注入的意义在于：

保证客户类仅仅与其依赖的服务类耦合，而不与服务类的子类型耦合，使得程序符合OCP或依赖于抽象类型原则。
不需声明全局公共的服务类对象，而是通过依赖注入（伸手-等待）来获取：在接受注入时声明所依赖的服务对象（伸手），框架会在初始化时将对象传递进来（等待）。

在这里插入图片描述

模式特点

依赖注入的主要特点包括：

降低耦合度 ：依赖注入的核心思想是将对象之间的依赖关系分离出来，将原本紧耦合的对象变得松耦合，使得各个模块之间的依赖关系减少，有利于代码的复用和测试。
提高可扩展性 ：由于依赖关系是通过外部方式注入的，因此当需要添加新的功能或模块时，只需要在配置文件中添加新的依赖关系，而不需要修改原有的代码，从而提高了系统的可扩展性。
便于测试和调试 ：通过外部方式注入依赖关系，可以很容易地模拟和控制依赖对象的行为，便于进行单元测试和调试。
增强代码的可读性和可维护性 ：通过使用依赖注入，代码更加清晰易懂，同时也可以减少代码中的硬编码，使得代码更加灵活、可维护。

在这里插入图片描述

应用场景

依赖注入模式的应用场景主要包括以下几个方面：

单元测试 ：在单元测试中，依赖注入模式可以使得测试更加简单和有效。通过模拟依赖对象的行为，可以很容易地对被测试对象进行隔离和测试。
插件式开发 ：在插件式开发中，依赖注入模式可以使得插件之间的依赖关系更加清晰和灵活。通过配置文件或注解等方式，可以很容易地管理和控制插件之间的依赖关系。
多环境配置 ：在不同的运行环境中，可能需要使用不同的依赖对象。通过依赖注入模式，可以很容易地根据不同的环境配置来注入不同的依赖对象，从而提高了代码的灵活性和可维护性。
框架开发 ：在框架开发中，依赖注入模式可以使得框架更加灵活和可扩展。通过提供统一的依赖注入机制，可以使得框架的使用者更加方便地使用和管理框架提供的各种服务。

在这里插入图片描述

依赖注入和控制反转的区别

控制反转（Inversion of Control，简称IoC）和依赖注入（Dependency Injection，简称DI）是两个相关但略有不同的概念。

控制反转是创建对象实例的控制权从代码控制剥离到IoC容器控制，侧重于原理。依赖注入则是在创建对象实例时，为这个对象注入属性值或其它对象实例，侧重于实现。

简单来说，依赖注入是从应用程序的角度在描述：应用程序依赖容器创建并注入它所需要的外部资源；而控制反转是从容器的角度在描述：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的外部资源（对象、文件等）。

在这里插入图片描述

代码示例

Java实现依赖注入模式

以下是一个简单的Java实现依赖注入模式的示例：

// 定义依赖对象
public class Dependency {
    public void doSomething() {
        System.out.println("Dependency is doing something.");
    }
}

// 定义服务类，接受依赖对象
public class Service {
    private Dependency dependency;

    // 通过构造函数注入依赖对象
    public Service(Dependency dependency) {
        this.dependency = dependency;
    }

    public void performTask() {
        dependency.doSomething();
    }
}

// 定义容器类，负责创建和注入依赖对象
public class Container {
    private Map<Class<?>, Object> dependencies = new HashMap<>();

    public <T> void addDependency(Class<T> clazz, T instance) {
        dependencies.put(clazz, instance);
    }

    public Object getDependency(Class<?> clazz) {
        return dependencies.get(clazz);
    }
}

// 使用容器创建服务对象并注入依赖对象
public class Main {
    public static void main(String[] args) {
        Container container = new Container();
        Dependency dependency = new Dependency();
        container.addDependency(Dependency.class, dependency);
        Service service = new Service((Dependency) container.getDependency(Dependency.class));
        service.performTask(); // 输出 "Dependency is doing something."
    }
}

在这个示例中，我们定义了一个依赖对象Dependency和一个服务类Service，服务类通过构造函数接受依赖对象。然后我们定义了一个容器类Container，负责创建和注入依赖对象。在主程序中，我们创建了一个容器实例，将依赖对象添加到容器中，然后通过容器实例创建服务对象并注入依赖对象。最后，我们调用服务对象的performTask()方法，输出依赖对象的doSomething()方法的结果。

Python实现依赖注入模式

以下是Python实现依赖注入模式的一个示例：

# 定义依赖对象
class Dependency:
    def do_something(self):
        print("Dependency is doing something.")

# 定义服务类，接受依赖对象
class Service:
    def __init__(self, dependency):
        self.dependency = dependency

    def perform_task(self):
        self.dependency.do_something()

# 定义容器类，负责创建和注入依赖对象
class Container:
    def __init__(self):
        self.dependencies = {}

    def add_dependency(self, clazz, instance):
        self.dependencies[clazz] = instance

    def get_dependency(self, clazz):
        return self.dependencies.get(clazz)

# 使用容器创建服务对象并注入依赖对象
def main():
    container = Container()
    dependency = Dependency()
    container.add_dependency(Dependency, dependency)
    service = Service(container.get_dependency(Dependency))
    service.perform_task()  # 输出 "Dependency is doing something."

if __name__ == "__main__":
    main()

在这个示例中，我们定义了一个依赖对象Dependency和一个服务类Service。服务类通过构造函数接受依赖对象。然后我们定义了一个容器类Container，负责创建和注入依赖对象。在主程序中，我们创建了一个容器实例，将依赖对象添加到容器中，然后通过容器实例创建服务对象并注入依赖对象。最后，我们调用服务对象的perform_task()方法，输出依赖对象的do_something()方法的结果。

在这里插入图片描述

依赖注入模式在spring中的应用

在Spring框架中，依赖注入是一种核心特性，用于管理Bean之间的依赖关系。依赖注入允许在运行时动态地将依赖对象注入到Bean中，从而降低了对象之间的耦合度，提高了代码的可维护性和可测试性。

Spring提供了多种方式来实现依赖注入，包括注解和XML配置。使用注解的方式，可以在Bean的定义中添加相应的注解（如@Autowired、@Resource等），来指定注入的依赖对象。而使用XML配置的方式，可以在配置文件中定义Bean之间的关系，Spring容器在启动时会解析这些配置并自动注入依赖对象。

依赖注入主要有两种方式：构造器注入和Setter注入。构造器注入是通过Bean的构造方法来注入依赖对象，而Setter注入则是通过设置器方法来注入依赖对象。在Spring中，可以通过@Autowired注解来实现构造器注入，而通过@Resource注解或XML配置来实现Setter注入。

此外，Spring还提供了@Qualifier注解来指定具体的依赖对象。当Spring容器中存在多个符合条件的对象时，可以使用@Qualifier注解来指定要注入的具体对象。