依赖注入简介 依赖注入 (DI) 是一种用于实现控制反转 (IoC) 的设计模式，其中创建和管理依赖项的控制从应用程序转移到外部实体。这有助于创建更模块化、可测试和可维护的代码。这是一种将创建对象的责任转移到代码其他部分的技术。这促进了松散耦合，使代码更加模块化且更易于管理。 类通常需要引用其他类才能正常运行。例如，假设 类需要 类。这些必需的类称为依赖项。Library 依赖于 类的实例才能运行。 Library Book Library Book 类获取其所需对象的主要方式有三种： ：类创建并初始化自己的依赖项。例如， 类将创建并初始化自己的 类实例。 自我构造 Library Book ：该类从外部源检索依赖项。一些 Android API（例如 getters 和 以这种方式工作。 外部检索 Context getSystemService() ：在构造类时或通过需要依赖项的方法为类提供依赖项。例如， 构造函数将接收 实例作为参数。 依赖注入 Library Book 第三个选项是依赖注入！使用 DI，您可以提供类的依赖项，而不是让类实例本身获取它们。 没有依赖注入的示例 如果没有 DI，创建自己的 依赖项的 可能如下所示： Book Library class Library { private Book book = new Book(); void open() { book.read(); } } public class Main { public static void main(String[] args) { Library library = new Library(); library.open(); } } 这不是 DI 的示例，因为 类构造了自己的 。这可能会有问题，因为： Library Book ： 和 紧密耦合。Library 一个实例使用一种 类型，因此很难使用子类或其他实现。 紧密耦合 Library Book Library Book ：对 的严格依赖使测试更具挑战性。Library 的真实实例，从而阻止使用测试替身来修改 以适应不同的测试用例。 测试难度 Book Library Book Book 依赖注入示例 使用 DI， 的每个实例不再构造自己的 对象，而是在其构造函数中接收 对象作为参数： Library Book Book class Library { private Book book; Library(Book book) { this.book = book; } void open() { book.read(); } } public class Main { public static void main(String[] args) { Book book = new Book(); Library library = new Library(book); library.open(); } main 函数使用 。由于 依赖于 ，因此应用程序会创建 的一个实例，然后使用它来构造 的一个实例。这种基于 DI 的方法有以下好处： Library Library Book Book Library ：您可以将 的不同实现传递给 。例如，您可以定义一个名为 的 新子类，并希望 使用。使用 DI，您只需将 的一个实例传递给 ，它就可以正常工作，无需进一步更改。 Library 的可重用性 Book Library EBook Book Library EBook Library ：您可以传递测试替身来测试不同的场景。 轻松测试 Library 另一个 DI 示例 考虑这样一种情况，即 类依赖于 类。如果没有 DI， 会直接创建 的实例，这使得使用不同类型的通知或使用各种通知实现测试服务变得很困难。 NotificationService Notification NotificationService Notification 为了说明 DI，让我们重构这个例子： interface Notification { void send(); } class EmailNotification implements Notification { @Override public void send() { // Send email notification } } class SMSNotification implements Notification { @Override public void send() { // Send SMS notification } } class NotificationService { void sendNotification(Notification notification) { notification.send(); } } 现在， 依赖于 接口，而不是特定的类。这允许可以互换使用不同的 实现。您可以通过 方法设置要使用的实现： NotificationService Notification Notification sendNotification NotificationService service = new NotificationService(); service.sendNotification(new EmailNotification()); service.sendNotification(new SMSNotification()); Android 中的依赖注入方法 DI 主要有三种类型： ：依赖项通过方法传递，类可以通过接口或其他类访问这些方法。上例演示了方法注入。 方法（接口）注入 ：依赖项通过其构造函数传递给类。 构造函数注入 class NotificationService { private final Notification notification; public NotificationService(Notification notification) { this.notification = notification; } public void sendNotification() { notification.send(); } } public class Main { public static void main(String[] args) { NotificationService service = new NotificationService(new EmailNotification()); service.sendNotification(); } } ：某些 Android 框架类（例如 Activity 和 Fragment）由系统实例化，因此无法进行构造函数注入。使用字段注入，依赖项在类创建后实例化。 3. 字段注入（或 Setter 注入） class NotificationService { private Notification notification; public Notification getNotification() { return notification; } public void setNotification(Notification notification) { this.notification = notification; } public void sendNotification() { notification.send(); } } public class Main { public static void main(String[] args) { NotificationService service = new NotificationService(); service.setNotification(new EmailNotification()); service.sendNotification(); } } ：通过方法提供依赖项，通常使用 注解。 4. 方法注入 @Inject 依赖注入的优点 类的可重用性增强，对特定实现的依赖性降低。这是由于控制反转，类不再管理其依赖项，而是使用提供的任何配置。 依赖项是 API 表面的一部分，可以在对象创建或编译时进行验证，从而使重构更容易。 由于类不管理其依赖项，因此可以在测试期间传入不同的实现以覆盖各种场景。 自动依赖注入 在上一个示例中，您手动创建、提供和管理了不同类的依赖项，而无需使用库。这种方法称为手动依赖项注入。虽然它适用于简单的情况，但随着依赖项和类的数量增加，它会变得繁琐。手动依赖项注入有几个缺点： ：对于大型应用程序，管理所有依赖项并正确连接它们可能会导致大量重复代码。在多层架构中，为顶层创建对象需要为其下方的层提供所有依赖项。例如，要构建计算机，您需要 CPU、主板、RAM 和其他组件；而 CPU 可能需要晶体管和电容器。 样板代码 ：当您无法预先构建依赖项（例如使用延迟初始化或将对象范围限定到应用程序中的特定流）时，您需要编写和维护自定义容器（或依赖图）来管理内存中依赖项的生命周期。 复杂的依赖管理 库可以通过为您创建和提供依赖项来自动化此过程。这些库分为两类： ：这些解决方案在运行时连接依赖项。 基于反射的解决方案 ：这些解决方案在编译时生成连接依赖项的代码。 静态解决方案 Dagger 是一个流行的 Java、Kotlin 和 Android 依赖注入库，由 Google 维护。Dagger 通过为您创建和管理依赖关系图来简化应用中的 DI。它提供完全静态的编译时依赖关系，解决了与基于反射的解决方案（如 Guice）相关的许多开发和性能问题。 基于反射的解决方案 这些框架在运行时连接依赖项： ：使用反射连接依赖项的运行时 DI 框架。它设计为轻量级且快速，适合 Android 应用程序。 Toothpick 静态解决方案 这些框架在编译时生成连接依赖项的代码： ：Hilt 建立在 Dagger 之上，提供了一种将 Dagger 依赖注入纳入 Android 应用程序的标准方法。 。 Hilt 它通过提供预定义的组件和范围简化了 Dagger 的设置和使用 ：一个轻量级且简单的 Kotlin DI 框架。Koin 使用 DSL 来定义依赖项，并且易于设置和使用。 Koin ：基于 Kotlin 的 DI 框架，易于使用和理解。它提供了一个简单灵活的 API 来管理依赖项。 Kodein 依赖注入的替代方案 依赖注入的替代方案是服务定位器模式。此设计模式还有助于将类与其具体依赖项分离。您可以创建一个称为服务定位器的类，该类可创建和存储依赖项，并根据需要提供它们。 object ServiceLocator { fun getProcessor(): Processor = Processor() } class Computer { private val processor = ServiceLocator.getProcessor() fun start() { processor.run() } } fun main(args: Array<String>) { val computer = Computer() computer.start() } 服务定位器模式与依赖注入的区别在于依赖项的使用方式。使用服务定位器模式时，类会请求所需的依赖项；使用依赖注入时，应用会主动提供所需的对象。 什么是 Dagger 2？ Dagger 2 是一款流行的 Android DI 框架。它使用编译时代码生成，并以其高性能而闻名。Dagger 2 通过生成处理依赖项所需的代码来简化依赖项注入过程，从而减少样板并提高效率。 Dagger 2 是一个基于注释的 Android 依赖注入库。以下是关键注释及其用途： ：用于定义提供依赖项的类。例如，模块可以为 Retrofit 提供 。 @Module ApiClient ：注释模块中的方法来指定如何创建和返回依赖项。 @Provides ：用于请求依赖项。可应用于字段、构造函数和方法。 @Inject ：连接 和 的接口。它包含所有模块并为应用程序提供构建器。 @Component @Module @Inject ：确保创建依赖项的单个实例。 @Singleton ：用于抽象类中提供依赖关系，类似于 ，但更简洁。 @Binds @Provides Dagger 组件 Dagger 可以为您的项目生成依赖关系图，从而让它在需要时确定从哪里获取依赖项。要实现此功能，您需要创建一个接口并使用 对其进行注释。 @Component 在 接口中，您可以定义返回所需类实例的方法（例如 ）。 注释指示 Dagger 生成一个容器，其中包含满足其公开类型所需的所有依赖项。此容器称为 Dagger 组件，它包含 Dagger 知道如何提供的对象图及其依赖项。 @Component BookRepository @Component 例子 让我们考虑一个涉及 的示例： LibraryRepository ：向 构造函数添加 注释，以便 Dagger 知道如何创建 的实例。 注释构造函数 LibraryRepository @Inject LibraryRepository public class LibraryRepository { private final LocalLibraryDataSource localDataSource; private final RemoteLibraryDataSource remoteDataSource; @Inject public LibraryRepository(LocalLibraryDataSource localDataSource, RemoteLibraryDataSource remoteDataSource) { this.localDataSource = localDataSource; this.remoteDataSource = remoteDataSource; } } ：类似地，注释依赖项的构造函数（ 和 ），以便 Dagger 知道如何创建它们。 2. 注释依赖项 LocalLibraryDataSource RemoteLibraryDataSource public class LocalLibraryDataSource { @Inject public LocalLibraryDataSource() { // Initialization code } } public class RemoteLibraryDataSource { private final LibraryService libraryService; @Inject public RemoteLibraryDataSource(LibraryService libraryService) { this.libraryService = libraryService; } } ：创建一个用 注释的接口来定义依赖图。 3. 定义组件 @Component @Component public interface ApplicationComponent { LibraryRepository getLibraryRepository(); } 当你构建项目时，Dagger 会为你生成 接口的实现，通常名为 。 ApplicationComponent DaggerApplicationComponent 用法 您现在可以使用生成的组件来获取类的实例并自动注入它们的依赖项： public class MainApplication extends Application { private ApplicationComponent applicationComponent; @Override public void onCreate() { super.onCreate(); applicationComponent = DaggerApplicationComponent.create(); } public ApplicationComponent getApplicationComponent() { return applicationComponent; } } 在您的活动或片段中，您可以检索 实例： LibraryRepository public class MainActivity extends AppCompatActivity { @Inject LibraryRepository libraryRepository; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); ((MainApplication) getApplication()).getApplicationComponent().inject(this); // Use the injected libraryRepository } } Dagger 2 中的关键概念 1. 模块 ∘ 模块的关键概念 ∘ 在组件中包含模块 2. 范围 3. 组件 4. 组件依赖关系 5.运行时绑定 1. 模块 Dagger 2 中的模块是使用 注释的类，用于为组件提供依赖项。它们包含使用 或 注释的方法，用于指定如何创建和提供依赖项。模块对于组织和管理应用程序所需的对象的创建至关重要。 @Module @Provides @Binds 模块的关键概念 @Module 注解：此注解用于将类定义为 Dagger 模块。模块类包含提供依赖项的方法。 @Provides 注解：此注解用于模块内的方法，表示该方法提供某种依赖关系。这些方法负责创建和返回依赖关系的实例。 @Binds 注解：此注解用于抽象类中，将实现绑定到接口。它比 更简洁，适用于模块为抽象类的情况。 @Provides 模块示例 @Module public class NetworkModule { @Provides @Singleton Retrofit provideRetrofit() { return new Retrofit.Builder() .baseUrl("https://api.example.com") .addConverterFactory(GsonConverterFactory.create()) .build(); } @Provides @Singleton OkHttpClient provideOkHttpClient() { return new OkHttpClient.Builder() .addInterceptor(new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY)) .build(); } } 在这个例子中， 是一个用 注释的类。它包含两个用 注释的方法，用于创建并返回 和 的实例。 NetworkModule @Module @Provides Retrofit OkHttpClient 使用 @Binds 当你有一个接口及其实现时，可以使用 将实现绑定到接口。这比使用 更简洁。 @Binds @Provides public interface ApiService { void fetchData(); } public class ApiServiceImpl implements ApiService { @Override public void fetchData() { // Implementation } } @Module public abstract class ApiModule { @Binds abstract ApiService bindApiService(ApiServiceImpl apiServiceImpl); } 在这个例子中， 是一个用 注解的抽象类。 方法用 注解，用于将 绑定到 。 ApiModule @Module bindApiService @Binds ApiServiceImpl ApiService 模块可以根据其提供的功能进行组织。例如，您可以为网络操作、数据库操作和 UI 相关依赖项设置单独的模块。 例子： ：提供与网络相关的依赖项，例如 和 。 NetworkModule Retrofit OkHttpClient ：提供与数据库相关的依赖项，例如 。 DatabaseModule RoomDatabase ：提供与 UI 相关的依赖项，例如 和 。 UIModule ViewModel Presenter 在组件中包含模块 模块包含在组件中，用于为需要它们的类提供依赖项。设置方法如下： 应用程序组件.java： @Singleton @Component(modules = {NetworkModule.class, DatabaseModule.class}) public interface ApplicationComponent { void inject(MyApplication application); } 在这个例子中， 包括 和 来为应用程序提供依赖项。 ApplicationComponent NetworkModule DatabaseModule 2. 范围 Dagger 2 中的范围是定义依赖项生命周期的注释。它们确保在指定范围内创建和共享依赖项的单个实例。这有助于有效管理内存并确保在适当的情况下重用依赖项。 ：确保在整个应用程序的生命周期中依赖项只有一个实例。 单例范围 ：确保活动生命周期内依赖关系的单个实例。 活动范围 ：确保片段生命周期内依赖项的单个实例。 片段范围 1. 单例范围 ： 范围确保在整个应用程序的生命周期内创建并共享依赖项的单个实例。 定义 @Singleton 此范围通常用于需要在整个应用程序内共享的依赖项，例如网络客户端、数据库实例或共享首选项。 例子： @Singleton @Component(modules = {NetworkModule.class, DatabaseModule.class}) public interface ApplicationComponent { void inject(MyApplication application); } 在这个例子中， 注解确保 和 提供的 和 实例是单例，并在整个应用程序中共享。 @Singleton NetworkModule DatabaseModule Retrofit Database 2. 活动范围 ： （自定义范围）确保在活动的生命周期内创建并共享依赖项的单个实例。 定义 @ActivityScope 此范围对于特定于活动的依赖项很有用，并且每次重新创建活动时都应重新创建，例如演示者或视图模型。 ： 例子 @Scope @Retention(RetentionPolicy.RUNTIME) public @interface ActivityScope { } @ActivityScope @Component(dependencies = ApplicationComponent.class, modules = ActivityModule.class) public interface ActivityComponent { void inject(MainActivity mainActivity); } 在此示例中， 注释确保 提供的依赖项作用域于活动的生命周期。 @ActivityScope ActivityModule 3. 片段范围 ： （另一个自定义范围）确保在片段的生命周期内创建并共享依赖项的单个实例。 定义 @FragmentScope 用例：此范围对于特定于片段的依赖项很有用，并且每次重新创建片段时都应重新创建，例如特定于片段的演示者或视图模型。 ： 例子 @Scope @Retention(RetentionPolicy.RUNTIME) public @interface FragmentScope { } @FragmentScope @Component(dependencies = ActivityComponent.class, modules = FragmentModule.class) public interface FragmentComponent { void inject(MyFragment myFragment); } 在此示例中， 注释确保 提供的依赖项作用域于片段的生命周期。 @FragmentScope FragmentModule 3. 组件 组件依赖关系允许一个组件依赖于另一个组件，从而实现依赖关系的重用。组件依赖关系主要有两种类型： ：提供整个应用程序所需的依赖项。 应用程序组件 ：提供特定活动内所需的依赖项。 活动组件 1. 应用程序组件 ：应用程序组件提供整个应用程序所需的依赖项。它通常使用 来确保依赖项在整个应用程序中共享。 定义 @Singleton 该组件用于需要全局可用的依赖项，例如网络客户端、数据库实例或共享首选项。 ： 例子 @Singleton @Component(modules = {NetworkModule.class, DatabaseModule.class}) public interface ApplicationComponent { void inject(MyApplication application); } 在这个例子中， 负责提供 和 实例，它们在整个应用程序共享。 ApplicationComponent Retrofit Database 2. 活动组件 ：活动组件提供特定活动所需的依赖项。它通常使用自定义范围（例如 ）来限定范围，以确保每次重新创建活动时都会重新创建依赖项。 定义 @ActivityScope 该组件用于特定于活动的依赖项，例如演示者或视图模型。 ： 例子 @ActivityScope @Component(dependencies = ApplicationComponent.class, modules = ActivityModule.class) public interface ActivityComponent { void inject(MainActivity mainActivity); } 在此示例中， 依赖于 并提供特定于 的依赖项。 ActivityComponent ApplicationComponent MainActivity 4. 组件依赖关系 组件依赖关系允许一个组件依赖于另一个组件，从而实现依赖关系的重用。组件依赖关系主要有两种类型： ：子组件是另一个组件的子组件，可以访问其父组件的依赖项。 子组件 ：这允许一个组件依赖于另一个组件，而无需成为子组件。 依赖属性 1.子组件： 子组件是另一个组件的子项，可以访问其父组件的依赖项。子组件在父组件内定义，可以继承其范围。 ： 例子 @ActivityScope @Subcomponent(modules = ActivityModule.class) public interface ActivitySubcomponent { void inject(MainActivity mainActivity); } 在这个例子中， 是父组件的子组件，并可以访问其依赖项。 ActivitySubcomponent 2. 依赖属性 这允许组件依赖另一个组件，而无需成为子组件。依赖组件可以访问父组件提供的依赖项。 ： 例子 @ActivityScope @Component(dependencies = ApplicationComponent.class, modules = ActivityModule.class) public interface ActivityComponent { void inject(MainActivity mainActivity); } 在这个例子中， 依赖于 并且可以访问其依赖项。 ActivityComponent ApplicationComponent 5. 运行时绑定 Dagger 2 中的运行时绑定是指根据需要的上下文在运行时创建和管理的依赖项的提供。 ：用于需要与应用程序一起存在的依赖项。 应用程序上下文 ：用于需要与活动一样长久存在的依赖项。 活动上下文 1. 应用背景 ：应用程序上下文是与整个应用程序的生命周期相关的上下文。它用于需要与应用程序本身一样长的依赖项。 定义 在整个应用程序中共享的依赖项，无需为每个活动或片段重新创建。示例包括网络客户端、数据库实例和共享首选项。 ： 例子 @Module public class AppModule { private final Application application; public AppModule(Application application) { this.application = application; } @Provides @Singleton Application provideApplication() { return application; } @Provides @Singleton Context provideApplicationContext() { return application.getApplicationContext(); } } 在此示例中， 将应用程序上下文作为单例依赖项提供。 方法确保提供的上下文与应用程序的生命周期相关联。 AppModule provideApplicationContext 2. 活动背景 ：活动上下文是与特定活动生命周期相关的上下文。它用于需要与活动本身同时存在的依赖项。 定义 特定于某项活动的依赖项，每次重新创建活动时都应重新创建。示例包括视图模型、演示器和与 UI 相关的依赖项。 ： 例子 @Module public class ActivityModule { private final Activity activity; public ActivityModule(Activity activity) { this.activity = activity; } @Provides @ActivityScope Activity provideActivity() { return activity; } @Provides @ActivityScope Context provideActivityContext() { return activity; } } 在此示例中， 将活动上下文作为范围依赖项提供。 方法确保提供的上下文与活动的生命周期相关联。 ActivityModule provideActivityContext 在组件中使用运行时绑定 要使用这些运行时绑定，您需要在组件中包含相应的模块： ： 应用程序组件 @Singleton @Component(modules = {AppModule.class, NetworkModule.class}) public interface ApplicationComponent { void inject(MyApplication application); Context getApplicationContext(); } ： 活动组件 @ActivityScope @Component(dependencies = ApplicationComponent.class, modules = ActivityModule.class) public interface ActivityComponent { void inject(MainActivity mainActivity); Context getActivityContext(); } 注入上下文 设置好组件和模块后，您可以根据需要将上下文注入到类中。 ： 活动中的示例 public class MainActivity extends AppCompatActivity { @Inject Context activityContext; @Inject Context applicationContext; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); ApplicationComponent appComponent = ((MyApplication) getApplication()).getApplicationComponent(); ActivityComponent activityComponent = DaggerActivityComponent.builder() .applicationComponent(appComponent) .activityModule(new ActivityModule(this)) .build(); activityComponent.inject(this); // Use the injected contexts Log.d("MainActivity", "Activity Context: " + activityContext); Log.d("MainActivity", "Application Context: " + applicationContext); } } 在此示例中， 通过依赖项注入接收活动上下文和应用程序上下文。这允许活动根据依赖项的特定需求使用适当的上下文。 MainActivity 示例：在 Android 应用程序中使用 Dagger 2 设置 Dagger 2 要在您的项目中使用 Dagger 2，您需要在 文件中添加以下依赖项： build.gradle dependencies { implementation 'com.google.dagger:dagger:2.x' annotationProcessor 'com.google.dagger:dagger-compiler:2.x' } 将 替换为最新版本的 Dagger 2。 2.x 步骤 1：定义模块 创建一个模块来提供依赖项。例如，一个 来提供 实例： NetworkModule Retrofit @Module public class NetworkModule { @Provides @Singleton Retrofit provideRetrofit() { return new Retrofit.Builder() .baseUrl("https://api.example.com") .addConverterFactory(GsonConverterFactory.create()) .build(); } } 步骤 2：定义组件 创建一个组件来连接模块和需要依赖项的类： @Singleton @Component(modules = {NetworkModule.class}) public interface ApplicationComponent { void inject(MyApplication application); } 步骤 3：注入依赖项 使用组件将依赖项注入到您的类中。例如，在您的 类中： Application public class MyApplication extends Application { private ApplicationComponent applicationComponent; @Override public void onCreate() { super.onCreate(); applicationComponent = DaggerApplicationComponent.builder() .networkModule(new NetworkModule()) .build(); applicationComponent.inject(this); } public ApplicationComponent getApplicationComponent() { return applicationComponent; } } 步骤 4：使用注入依赖项 现在，您可以在类中使用注入的依赖项。例如，在 中： Activity public class MainActivity extends AppCompatActivity { @Inject Retrofit retrofit; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); ((MyApplication) getApplication()).getApplicationComponent().inject(this); // Use the injected Retrofit instance // ... } } 结论 我们来总结一下这个话题： DI 的主要目的是松开耦合，使得管理依赖关系变得更容易。 通过使用 DI，您可以增加代码灵活性并简化测试过程。 DI 是一个复杂的主题，根据场景有不同的实现。 不同语言的 DI 具有各自的特性，这会影响您的使用方式。 Dagger 2 自动化了创建和提供依赖项的过程，减少了样板代码并提高了可维护性。 Dagger 2 提供编译时安全性，确保应用程序运行前所有依赖项都得到满足。 通过在编译时生成代码，Dagger 2 避免了基于反射的解决方案相关的性能开销。
