在 Android 应用程序中使用 Dagger

该 Dagger 基础页面介绍了 Dagger 如何帮助您在应用中自动执行依赖项注入。使用 Dagger，您不必编写乏味且容易出错的样板代码。

最佳实践摘要

使用带有 @Inject 的构造函数注入，在可能的情况下向 Dagger 图添加类型。当它不可行时
- 使用 @Binds 告诉 Dagger 接口应该具有哪个实现。
- 使用 @Provides 告诉 Dagger 如何提供项目不拥有的类。
您应该只在组件中声明一次模块。
根据使用注释的生命周期命名作用域注释。例如，@ApplicationScope、@LoggedUserScope 和 @ActivityScope。

添加依赖项

要在项目中使用 Dagger，请在 build.gradle 文件中将这些依赖项添加到您的应用。您可以在此 GitHub 项目中找到 Dagger 的最新版本。

Kotlin

plugins {
  id 'kotlin-kapt'
}

dependencies {
    implementation 'com.google.dagger:dagger:2.x'
    kapt 'com.google.dagger:dagger-compiler:2.x'
}

Java

dependencies {
    implementation 'com.google.dagger:dagger:2.x'
    annotationProcessor 'com.google.dagger:dagger-compiler:2.x'
}

Android 中的 Dagger

考虑一个具有图 1 中依赖项图的示例 Android 应用。

LoginActivity depends on LoginViewModel, which depends on UserRepository,
which depends on UserLocalDataSource and UserRemoteDataSource, which in turn
depends on Retrofit.

图 1.示例代码的依赖项图

在 Android 中，您通常会在应用类中创建一个 Dagger 图，因为您希望只要应用在运行，图的实例就一直存在于内存中。这样，图就与应用生命周期相关联。在某些情况下，您可能还希望在图中提供应用上下文。为此，您还需要将图放在 Application 类中。这种方法的一个优势是，图可供其他 Android 框架类使用。此外，它通过允许您在测试中使用自定义 Application 类，从而简化了测试。

由于生成图表的界面用@Component注释，因此您可以将其称为ApplicationComponent或ApplicationGraph。您通常会在自定义的Application类中保留该组件的实例，并在每次需要应用程序图时调用它，如下面的代码片段所示

Kotlin

// Definition of the Application graph
@Component
interface ApplicationComponent { ... }

// appComponent lives in the Application class to share its lifecycle
class MyApplication: Application() {
    // Reference to the application graph that is used across the whole app
    val appComponent = DaggerApplicationComponent.create()
}

Java

// Definition of the Application graph
@Component
public interface ApplicationComponent {
}

// appComponent lives in the Application class to share its lifecycle
public class MyApplication extends Application {

    // Reference to the application graph that is used across the whole app
    ApplicationComponent appComponent = DaggerApplicationComponent.create();
}

由于某些 Android 框架类（例如活动和片段）由系统实例化，因此 Dagger 无法为您创建它们。对于活动而言，任何初始化代码都需要放入onCreate()方法中。这意味着您不能像在前面的示例中那样在类的构造函数中使用@Inject注释（构造函数注入）。相反，您必须使用字段注入。

您不希望在onCreate()方法中创建活动所需的依赖项，而是希望 Dagger 为您填充这些依赖项。对于字段注入，您改为将@Inject注释应用于要从 Dagger 图中获取的字段。

Kotlin

class LoginActivity: Activity() {
    // You want Dagger to provide an instance of LoginViewModel from the graph
    @Inject lateinit var loginViewModel: LoginViewModel
}

Java

public class LoginActivity extends Activity {

    // You want Dagger to provide an instance of LoginViewModel from the graph
    @Inject
    LoginViewModel loginViewModel;
}

为了简单起见，LoginViewModel不是 Android 架构组件 ViewModel；它只是一个充当 ViewModel 的普通类。有关如何注入这些类的更多信息，请查看官方 Android 蓝图 Dagger 实现中的代码，在 dev-dagger 分支中。

Dagger 的一个注意事项是注入的字段不能是私有的。它们需要至少具有与前面代码中一样的包私有可见性。

注入活动

Dagger 需要知道LoginActivity必须访问图才能提供它所需的ViewModel。在 Dagger 基础页面中，您使用@Component接口通过公开具有想要从图中获取的类型的返回值的函数来从图中获取对象。在这种情况下，您需要告诉 Dagger 关于一个需要注入依赖关系的对象（本例中为LoginActivity）。为此，您公开一个以请求注入的对象作为参数的函数。

Kotlin

@Component
interface ApplicationComponent {
    // This tells Dagger that LoginActivity requests injection so the graph needs to
    // satisfy all the dependencies of the fields that LoginActivity is requesting.
    fun inject(activity: LoginActivity)
}

Java

@Component
public interface ApplicationComponent {
    // This tells Dagger that LoginActivity requests injection so the graph needs to
    // satisfy all the dependencies of the fields that LoginActivity is injecting.
    void inject(LoginActivity loginActivity);
}

此函数告诉 Dagger LoginActivity想要访问图并请求注入。Dagger 需要满足LoginActivity所需的所有依赖项（具有自身依赖项的LoginViewModel）。如果您有多个请求注入的类，则必须在组件中使用其确切类型将它们全部显式声明。例如，如果您有请求注入的LoginActivity和RegistrationActivity，则您将有两个inject()方法，而不是一个涵盖两种情况的通用方法。通用的inject()方法不会告诉 Dagger 需要提供什么。接口中的函数可以具有任何名称，但在它们接收要注入的对象作为参数时将它们称为inject()是 Dagger 中的一种约定。

要在活动中注入对象，您将使用在Application类中定义的appComponent，并调用inject()方法，并将请求注入的活动的实例传递进去。

在使用活动时，在活动onCreate()方法中调用super.onCreate()之前注入 Dagger，以避免片段恢复出现问题。在super.onCreate()中的恢复阶段，活动会附加可能想要访问活动绑定的片段。

在使用片段时，在片段onAttach()方法中注入 Dagger。在这种情况下，可以在调用super.onAttach()之前或之后进行。

Kotlin

class LoginActivity: Activity() {
    // You want Dagger to provide an instance of LoginViewModel from the graph
    @Inject lateinit var loginViewModel: LoginViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        // Make Dagger instantiate @Inject fields in LoginActivity
        (applicationContext as MyApplication).appComponent.inject(this)
        // Now loginViewModel is available

        super.onCreate(savedInstanceState)
    }
}

// @Inject tells Dagger how to create instances of LoginViewModel
class LoginViewModel @Inject constructor(
    private val userRepository: UserRepository
) { ... }

Java

public class LoginActivity extends Activity {

    // You want Dagger to provide an instance of LoginViewModel from the graph
    @Inject
    LoginViewModel loginViewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // Make Dagger instantiate @Inject fields in LoginActivity
        ((MyApplication) getApplicationContext()).appComponent.inject(this);
        // Now loginViewModel is available

        super.onCreate(savedInstanceState);
    }
}

public class LoginViewModel {

    private final UserRepository userRepository;

    // @Inject tells Dagger how to create instances of LoginViewModel
    @Inject
    public LoginViewModel(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

让我们告诉 Dagger 如何提供其余的依赖项以构建图

Kotlin

class UserRepository @Inject constructor(
    private val localDataSource: UserLocalDataSource,
    private val remoteDataSource: UserRemoteDataSource
) { ... }

class UserLocalDataSource @Inject constructor() { ... }
class UserRemoteDataSource @Inject constructor(
    private val loginService: LoginRetrofitService
) { ... }

Java

public class UserRepository {

    private final UserLocalDataSource userLocalDataSource;
    private final UserRemoteDataSource userRemoteDataSource;

    @Inject
    public UserRepository(UserLocalDataSource userLocalDataSource, UserRemoteDataSource userRemoteDataSource) {
        this.userLocalDataSource = userLocalDataSource;
        this.userRemoteDataSource = userRemoteDataSource;
    }
}

public class UserLocalDataSource {

    @Inject
    public UserLocalDataSource() {}
}

public class UserRemoteDataSource {

    private final LoginRetrofitService loginRetrofitService;

    @Inject
    public UserRemoteDataSource(LoginRetrofitService loginRetrofitService) {
        this.loginRetrofitService = loginRetrofitService;
    }
}

Dagger 模块

对于此示例，您使用的是 Retrofit 网络库。UserRemoteDataSource依赖于LoginRetrofitService。但是，创建LoginRetrofitService实例的方法与您迄今为止所做的不同。它不是类实例化；而是调用Retrofit.Builder()并传递不同的参数来配置登录服务的结果。

除了@Inject注释之外，还有另一种方法可以告诉 Dagger 如何提供类的实例：Dagger 模块中的信息。Dagger 模块是一个用@Module注释的类。在那里，您可以使用@Provides注释定义依赖项。

Kotlin

// @Module informs Dagger that this class is a Dagger Module
@Module
class NetworkModule {

    // @Provides tell Dagger how to create instances of the type that this function
    // returns (i.e. LoginRetrofitService).
    // Function parameters are the dependencies of this type.
    @Provides
    fun provideLoginRetrofitService(): LoginRetrofitService {
        // Whenever Dagger needs to provide an instance of type LoginRetrofitService,
        // this code (the one inside the @Provides method) is run.
        return Retrofit.Builder()
                .baseUrl("https://example.com")
                .build()
                .create(LoginService::class.java)
    }
}

Java

// @Module informs Dagger that this class is a Dagger Module
@Module
public class NetworkModule {

    // @Provides tell Dagger how to create instances of the type that this function
    // returns (i.e. LoginRetrofitService).
    // Function parameters are the dependencies of this type.
    @Provides
    public LoginRetrofitService provideLoginRetrofitService() {
        // Whenever Dagger needs to provide an instance of type LoginRetrofitService,
        // this code (the one inside the @Provides method) is run.
        return new Retrofit.Builder()
                .baseUrl("https://example.com")
                .build()
                .create(LoginService.class);
    }
}

模块是语义上封装有关如何提供对象的信息的一种方式。如您所见，您调用了NetworkModule类来对提供与网络相关的对象逻辑进行分组。如果应用程序扩展，您还可以在此处添加如何提供 OkHttpClient，或者如何配置 Gson 或 Moshi。

@Provides方法的依赖项是该方法的参数。对于前面的方法，LoginRetrofitService可以在没有依赖项的情况下提供，因为该方法没有参数。如果您将OkHttpClient声明为参数，则 Dagger 需要从图中提供OkHttpClient实例以满足LoginRetrofitService的依赖项。例如

Kotlin

@Module
class NetworkModule {
    // Hypothetical dependency on LoginRetrofitService
    @Provides
    fun provideLoginRetrofitService(
        okHttpClient: OkHttpClient
    ): LoginRetrofitService { ... }
}

Java

@Module
public class NetworkModule {

    @Provides
    public LoginRetrofitService provideLoginRetrofitService(OkHttpClient okHttpClient) {
        ...
    }
}

为了使 Dagger 图知道此模块，您必须将其添加到@Component接口中，如下所示

Kotlin

// The "modules" attribute in the @Component annotation tells Dagger what Modules
// to include when building the graph
@Component(modules = [NetworkModule::class])
interface ApplicationComponent {
    ...
}

Java

// The "modules" attribute in the @Component annotation tells Dagger what Modules
// to include when building the graph
@Component(modules = NetworkModule.class)
public interface ApplicationComponent {
    ...
}

将类型添加到 Dagger 图的推荐方法是使用构造函数注入（即，在类的构造函数上使用@Inject注释）。有时，这不可能，您必须使用 Dagger 模块。一个例子是，当您希望 Dagger 使用计算结果来确定如何创建对象的实例时。每当它必须提供该类型的实例时，Dagger 都会运行@Provides方法中的代码。

这就是示例中 Dagger 图现在的样子

Diagram of LoginActivity dependency graph

图 2. 用LoginActivity被 Dagger 注入的图的表示

图的入口点是LoginActivity。由于LoginActivity注入LoginViewModel，因此 Dagger 会构建一个知道如何提供LoginViewModel实例的图，并递归地提供其依赖项。Dagger 知道如何做到这一点，因为类构造函数上有@Inject注释。

在 Dagger 生成的ApplicationComponent中，有一个工厂类型的方法来获取它知道如何提供的每个类的实例。在此示例中，Dagger 委托给包含在ApplicationComponent中的NetworkModule来获取LoginRetrofitService的实例。

Dagger 范围

范围在 Dagger 基础页面中提到，作为在组件中拥有类型的唯一实例的一种方式。这就是将类型范围限定为组件的生命周期的含义。

因为您可能想要在应用程序的其他功能中使用UserRepository，并且可能不希望每次需要它时都创建一个新对象，所以您可以将其指定为整个应用程序的唯一实例。对于LoginRetrofitService也是如此：它可能很昂贵，并且您也希望该对象的唯一实例被重用。创建UserRemoteDataSource的实例并不那么昂贵，因此将其范围限定为组件的生命周期没有必要。

@Singleton 是 javax.inject 包中附带的唯一范围注释。您可以使用它来注释ApplicationComponent以及您希望在整个应用程序中重用的对象。

Kotlin

@Singleton
@Component(modules = [NetworkModule::class])
interface ApplicationComponent {
    fun inject(activity: LoginActivity)
}

@Singleton
class UserRepository @Inject constructor(
    private val localDataSource: UserLocalDataSource,
    private val remoteDataSource: UserRemoteDataSource
) { ... }

@Module
class NetworkModule {
    // Way to scope types inside a Dagger Module
    @Singleton
    @Provides
    fun provideLoginRetrofitService(): LoginRetrofitService { ... }
}

Java

@Singleton
@Component(modules = NetworkModule.class)
public interface ApplicationComponent {
    void inject(LoginActivity loginActivity);
}

@Singleton
public class UserRepository {

    private final UserLocalDataSource userLocalDataSource;
    private final UserRemoteDataSource userRemoteDataSource;

    @Inject
    public UserRepository(UserLocalDataSource userLocalDataSource, UserRemoteDataSource userRemoteDataSource) {
        this.userLocalDataSource = userLocalDataSource;
        this.userRemoteDataSource = userRemoteDataSource;
    }
}

@Module
public class NetworkModule {

    @Singleton
    @Provides
    public LoginRetrofitService provideLoginRetrofitService() { ... }
}

在将范围应用于对象时，注意不要引入内存泄漏。只要有范围的组件在内存中，创建的对象也在内存中。由于ApplicationComponent是在应用程序启动时创建的（在Application类中），因此它会在应用程序被销毁时被销毁。因此，UserRepository的唯一实例将始终保留在内存中，直到应用程序被销毁为止。

Dagger 子组件

如果您的登录流程（由单个LoginActivity管理）包含多个片段，那么您应该在所有片段中重用同一个LoginViewModel实例。@Singleton不能注释LoginViewModel以重用实例，原因如下

LoginViewModel的实例将在流程结束后持续保留在内存中。
您希望每个登录流程都有不同的LoginViewModel实例。例如，如果用户注销，您希望有一个与用户第一次登录时不同的LoginViewModel实例。

要将LoginViewModel的范围限定为LoginActivity的生命周期，您需要为登录流程创建一个新的组件（一个新的子图）和一个新的范围。

让我们创建一个特定于登录流程的图表。

Kotlin

@Component
interface LoginComponent {}

Java

@Component
public interface LoginComponent {
}

现在，LoginActivity 应该从 LoginComponent 获取注入，因为它具有登录特定的配置。这将从 ApplicationComponent 类中移除注入 LoginActivity 的责任。

Kotlin

@Component
interface LoginComponent {
    fun inject(activity: LoginActivity)
}

Java

@Component
public interface LoginComponent {
    void inject(LoginActivity loginActivity);
}

LoginComponent 必须能够访问来自 ApplicationComponent 的对象，因为 LoginViewModel 依赖于 UserRepository。告诉 Dagger 你想要一个新的组件来使用另一个组件的一部分的方法是使用 *Dagger 子组件*。新组件必须是包含共享资源的组件的子组件。

*子组件* 是继承并扩展父组件对象图的组件。因此，在父组件中提供的全部对象也将在子组件中提供。这样，子组件中的对象可以依赖于父组件提供的对象。

要创建子组件的实例，你需要父组件的实例。因此，父组件提供给子组件的对象仍然是父组件范围内的。

在本例中，你必须将 LoginComponent 定义为 ApplicationComponent 的子组件。为此，请使用 @Subcomponent 注解 LoginComponent。

Kotlin

// @Subcomponent annotation informs Dagger this interface is a Dagger Subcomponent
@Subcomponent
interface LoginComponent {

    // This tells Dagger that LoginActivity requests injection from LoginComponent
    // so that this subcomponent graph needs to satisfy all the dependencies of the
    // fields that LoginActivity is injecting
    fun inject(loginActivity: LoginActivity)
}

Java

// @Subcomponent annotation informs Dagger this interface is a Dagger Subcomponent
@Subcomponent
public interface LoginComponent {

    // This tells Dagger that LoginActivity requests injection from LoginComponent
    // so that this subcomponent graph needs to satisfy all the dependencies of the
    // fields that LoginActivity is injecting
    void inject(LoginActivity loginActivity);
}

你还必须在 LoginComponent 内定义一个子组件工厂，以便 ApplicationComponent 知道如何创建 LoginComponent 的实例。

Kotlin

@Subcomponent
interface LoginComponent {

    // Factory that is used to create instances of this subcomponent
    @Subcomponent.Factory
    interface Factory {
        fun create(): LoginComponent
    }

    fun inject(loginActivity: LoginActivity)
}

Java

@Subcomponent
public interface LoginComponent {

    // Factory that is used to create instances of this subcomponent
    @Subcomponent.Factory
    interface Factory {
        LoginComponent create();
    }

    void inject(LoginActivity loginActivity);
}

要告诉 Dagger LoginComponent 是 ApplicationComponent 的子组件，你需要通过以下方式指示它：

创建一个新的 Dagger 模块（例如 SubcomponentsModule），将子组件的类传递给注解的 subcomponents 属性。

Kotlin

// The "subcomponents" attribute in the @Module annotation tells Dagger what
// Subcomponents are children of the Component this module is included in.
@Module(subcomponents = LoginComponent::class)
class SubcomponentsModule {}

Java

// The "subcomponents" attribute in the @Module annotation tells Dagger what
// Subcomponents are children of the Component this module is included in.
@Module(subcomponents = LoginComponent.class)
public class SubcomponentsModule {
}

将新的模块（即 SubcomponentsModule）添加到 ApplicationComponent。
Kotlin
```
// Including SubcomponentsModule, tell ApplicationComponent that
// LoginComponent is its subcomponent.
@Singleton
@Component(modules = [NetworkModule::class, SubcomponentsModule::class])
interface ApplicationComponent {
}
```
Java
```
// Including SubcomponentsModule, tell ApplicationComponent that
// LoginComponent is its subcomponent.
@Singleton
@Component(modules = {NetworkModule.class, SubcomponentsModule.class})
public interface ApplicationComponent {
}
```
请注意，ApplicationComponent 不再需要注入 LoginActivity，因为该责任现在属于 LoginComponent，因此你可以从 ApplicationComponent 中移除 inject() 方法。

ApplicationComponent 的使用者需要知道如何创建 LoginComponent 的实例。父组件必须在其接口中添加一个方法，以便使用者能够从父组件的实例中创建子组件的实例。

在接口中公开创建 LoginComponent 实例的工厂。

Kotlin

@Singleton
@Component(modules = [NetworkModule::class, SubcomponentsModule::class])
interface ApplicationComponent {
// This function exposes the LoginComponent Factory out of the graph so consumers
// can use it to obtain new instances of LoginComponent
fun loginComponent(): LoginComponent.Factory
}

Java

@Singleton
@Component(modules = { NetworkModule.class, SubcomponentsModule.class} )
public interface ApplicationComponent {
// This function exposes the LoginComponent Factory out of the graph so consumers
// can use it to obtain new instances of LoginComponent
LoginComponent.Factory loginComponent();
}

为子组件分配范围。

如果你构建了项目，你可以创建 ApplicationComponent 和 LoginComponent 的实例。ApplicationComponent 附加到应用程序的生命周期，因为只要应用程序在内存中，你都希望使用同一个图实例。

LoginComponent 的生命周期是什么？你需要 LoginComponent 的原因之一是因为你需要在登录相关的片段之间共享 LoginViewModel 的同一个实例。但是，你希望在每次有新的登录流程时，拥有不同的 LoginViewModel 实例。LoginActivity 是 LoginComponent 的正确生命周期：对于每个新的活动，你需要一个新的 LoginComponent 实例，以及可以使用该 LoginComponent 实例的片段。

因为 LoginComponent 附加到 LoginActivity 生命周期的，所以你必须在活动中保留对组件的引用，就像你在 Application 类中保留对 applicationComponent 的引用一样。这样，片段就可以访问它。

Kotlin

class LoginActivity: Activity() {
    // Reference to the Login graph
    lateinit var loginComponent: LoginComponent
    ...
}

Java

public class LoginActivity extends Activity {

    // Reference to the Login graph
    LoginComponent loginComponent;

    ...
}

请注意，变量 loginComponent 没有使用 @Inject 注解，因为你不希望该变量由 Dagger 提供。

你可以使用 ApplicationComponent 获取对 LoginComponent 的引用，然后像下面这样注入 LoginActivity。

Kotlin

class LoginActivity: Activity() {
    // Reference to the Login graph
    lateinit var loginComponent: LoginComponent

    // Fields that need to be injected by the login graph
    @Inject lateinit var loginViewModel: LoginViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        // Creation of the login graph using the application graph
        loginComponent = (applicationContext as MyDaggerApplication)
                            .appComponent.loginComponent().create()

        // Make Dagger instantiate @Inject fields in LoginActivity
        loginComponent.inject(this)

        // Now loginViewModel is available

        super.onCreate(savedInstanceState)
    }
}

Java

public class LoginActivity extends Activity {

    // Reference to the Login graph
    LoginComponent loginComponent;

    // Fields that need to be injected by the login graph
    @Inject
    LoginViewModel loginViewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // Creation of the login graph using the application graph
        loginComponent = ((MyApplication) getApplicationContext())
                                .appComponent.loginComponent().create();

        // Make Dagger instantiate @Inject fields in LoginActivity
        loginComponent.inject(this);

        // Now loginViewModel is available

        super.onCreate(savedInstanceState);
    }
}

LoginComponent 在活动的 onCreate() 方法中创建，并且当活动被销毁时，它会自动被销毁。

LoginComponent 必须始终在每次请求时提供相同的 LoginViewModel 实例。你可以通过创建一个自定义的注解范围，并使用它来注解 LoginComponent 和 LoginViewModel 来确保这一点。请注意，你不能使用 @Singleton 注解，因为它已经被父组件使用了，这会导致该对象成为应用程序单例（整个应用程序中唯一的实例）。你需要创建一个不同的注解范围。

在这种情况下，你可以将此范围称为 @LoginScope，但这并不是一个好习惯。范围注解的名称不应该明确地说明它所实现的目的。相反，它应该根据其生命周期命名，因为注解可以被兄弟组件（如 RegistrationComponent 和 SettingsComponent）重复使用。这就是为什么你应该将它称为 @ActivityScope 而不是 @LoginScope。

Kotlin

// Definition of a custom scope called ActivityScope
@Scope
@Retention(value = AnnotationRetention.RUNTIME)
annotation class ActivityScope

// Classes annotated with @ActivityScope are scoped to the graph and the same
// instance of that type is provided every time the type is requested.
@ActivityScope
@Subcomponent
interface LoginComponent { ... }

// A unique instance of LoginViewModel is provided in Components
// annotated with @ActivityScope
@ActivityScope
class LoginViewModel @Inject constructor(
    private val userRepository: UserRepository
) { ... }

Java

// Definition of a custom scope called ActivityScope
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface ActivityScope {}

// Classes annotated with @ActivityScope are scoped to the graph and the same
// instance of that type is provided every time the type is requested.
@ActivityScope
@Subcomponent
public interface LoginComponent { ... }

// A unique instance of LoginViewModel is provided in Components
// annotated with @ActivityScope
@ActivityScope
public class LoginViewModel {

    private final UserRepository userRepository;

    @Inject
    public LoginViewModel(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

现在，如果你有两个需要 LoginViewModel 的片段，它们都将获得相同的实例。例如，如果你有一个 LoginUsernameFragment 和一个 LoginPasswordFragment，它们需要由 LoginComponent 注入。

Kotlin

@ActivityScope
@Subcomponent
interface LoginComponent {

    @Subcomponent.Factory
    interface Factory {
        fun create(): LoginComponent
    }

    // All LoginActivity, LoginUsernameFragment and LoginPasswordFragment
    // request injection from LoginComponent. The graph needs to satisfy
    // all the dependencies of the fields those classes are injecting
    fun inject(loginActivity: LoginActivity)
    fun inject(usernameFragment: LoginUsernameFragment)
    fun inject(passwordFragment: LoginPasswordFragment)
}

Java

@ActivityScope
@Subcomponent
public interface LoginComponent {

    @Subcomponent.Factory
    interface Factory {
        LoginComponent create();
    }

    // All LoginActivity, LoginUsernameFragment and LoginPasswordFragment
    // request injection from LoginComponent. The graph needs to satisfy
    // all the dependencies of the fields those classes are injecting
    void inject(LoginActivity loginActivity);
    void inject(LoginUsernameFragment loginUsernameFragment);
    void inject(LoginPasswordFragment loginPasswordFragment);
}

组件访问位于 LoginActivity 对象中的组件实例。以下代码片段显示了 LoginUserNameFragment 的示例代码。

Kotlin

class LoginUsernameFragment: Fragment() {

    // Fields that need to be injected by the login graph
    @Inject lateinit var loginViewModel: LoginViewModel

    override fun onAttach(context: Context) {
        super.onAttach(context)

        // Obtaining the login graph from LoginActivity and instantiate
        // the @Inject fields with objects from the graph
        (activity as LoginActivity).loginComponent.inject(this)

        // Now you can access loginViewModel here and onCreateView too
        // (shared instance with the Activity and the other Fragment)
    }
}

Java

public class LoginUsernameFragment extends Fragment {

    // Fields that need to be injected by the login graph
    @Inject
    LoginViewModel loginViewModel;

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);

        // Obtaining the login graph from LoginActivity and instantiate
        // the @Inject fields with objects from the graph
        ((LoginActivity) getActivity()).loginComponent.inject(this);

        // Now you can access loginViewModel here and onCreateView too
        // (shared instance with the Activity and the other Fragment)
    }
}

对 LoginPasswordFragment 也是如此。

Kotlin

class LoginPasswordFragment: Fragment() {

    // Fields that need to be injected by the login graph
    @Inject lateinit var loginViewModel: LoginViewModel

    override fun onAttach(context: Context) {
        super.onAttach(context)

        (activity as LoginActivity).loginComponent.inject(this)

        // Now you can access loginViewModel here and onCreateView too
        // (shared instance with the Activity and the other Fragment)
    }
}

Java

public class LoginPasswordFragment extends Fragment {

    // Fields that need to be injected by the login graph
    @Inject
    LoginViewModel loginViewModel;

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);

        ((LoginActivity) getActivity()).loginComponent.inject(this);

        // Now you can access loginViewModel here and onCreateView too
        // (shared instance with the Activity and the other Fragment)
    }
}

图 3 显示了使用新的子组件的 Dagger 图表。带有白色圆点的类（UserRepository、LoginRetrofitService 和 LoginViewModel）是具有各自组件范围的唯一实例的类。

Application graph after adding the last subcomponent

图 3. Android 应用示例构建的图表的表示。

让我们分解图表的部分。

NetworkModule（因此 LoginRetrofitService）包含在 ApplicationComponent 中，因为你在组件中指定了它。
UserRepository 仍然保留在 ApplicationComponent 中，因为它属于 ApplicationComponent 的范围。如果项目发展壮大，你希望在不同的功能（例如注册）中共享同一个实例。

因为 UserRepository 是 ApplicationComponent 的一部分，所以它的依赖项（即 UserLocalDataSource 和 UserRemoteDataSource）也需要在此组件中，以便能够提供 UserRepository 的实例。
LoginViewModel 包含在 LoginComponent 中，因为它仅由 LoginComponent 注入的类需要。LoginViewModel 不包含在 ApplicationComponent 中，因为 ApplicationComponent 中没有依赖项需要 LoginViewModel。

同样地，如果你没有将 UserRepository 范围限定到 ApplicationComponent，Dagger 会自动将 UserRepository 及其依赖项作为 LoginComponent 的一部分包含，因为 UserRepository 目前仅在此处使用。

除了将对象范围限定到不同的生命周期之外，创建子组件是将应用程序的不同部分彼此隔离的良好实践。

根据应用程序的流程结构化应用程序以创建不同的 Dagger 子图，有助于在内存和启动时间方面实现更高效和可扩展的应用程序。

构建 Dagger 图表的最佳实践。

在为应用程序构建 Dagger 图表时。

当你创建一个组件时，你应该考虑哪个元素负责该组件的生命周期。在本例中，Application 类负责 ApplicationComponent，LoginActivity 负责 LoginComponent。
仅在有意义时使用范围限定。过度使用范围限定会对应用程序的运行时性能产生负面影响：只要组件在内存中，对象就在内存中，并且获取范围限定的对象成本更高。当 Dagger 提供对象时，它使用 DoubleCheck 锁定，而不是工厂类型提供者。

测试使用 Dagger 的项目。

使用 Dagger 等依赖注入框架的优势之一是它使测试代码变得更容易。

单元测试。

你不需要在单元测试中使用 Dagger。当测试使用构造函数注入的类时，你不需要使用 Dagger 来实例化该类。你可以直接调用其构造函数，将伪造或模拟依赖项直接传递进去，就像它们没有被注解一样。

例如，当测试 LoginViewModel 时。

Kotlin

@ActivityScope
class LoginViewModel @Inject constructor(
    private val userRepository: UserRepository
) { ... }

class LoginViewModelTest {

    @Test
    fun `Happy path`() {
        // You don't need Dagger to create an instance of LoginViewModel
        // You can pass a fake or mock UserRepository
        val viewModel = LoginViewModel(fakeUserRepository)
        assertEquals(...)
    }
}

Java

@ActivityScope
public class LoginViewModel {

    private final UserRepository userRepository;

    @Inject
    public LoginViewModel(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

public class LoginViewModelTest {

    @Test
    public void happyPath() {
        // You don't need Dagger to create an instance of LoginViewModel
        // You can pass a fake or mock UserRepository
        LoginViewModel viewModel = new LoginViewModel(fakeUserRepository);
        assertEquals(...);
    }
}

端到端测试。

对于集成测试，一个好的做法是创建一个专门用于测试的 TestApplicationComponent。生产和测试使用不同的组件配置。

这需要在应用程序中对模块进行更多前期设计。测试组件扩展了生产组件，并安装了一组不同的模块。

Kotlin

// TestApplicationComponent extends from ApplicationComponent to have them both
// with the same interface methods. You need to include the modules of the
// component here as well, and you can replace the ones you want to override.
// This sample uses FakeNetworkModule instead of NetworkModule
@Singleton
@Component(modules = [FakeNetworkModule::class, SubcomponentsModule::class])
interface TestApplicationComponent : ApplicationComponent {
}

Java

// TestApplicationComponent extends from ApplicationComponent to have them both
// with the same interface methods. You need to include the modules of the
// Component here as well, and you can replace the ones you want to override.
// This sample uses FakeNetworkModule instead of NetworkModule
@Singleton
@Component(modules = {FakeNetworkModule.class, SubcomponentsModule.class})
public interface TestApplicationComponent extends ApplicationComponent {
}

FakeNetworkModule 具有原始 NetworkModule 的伪造实现。你可以在其中提供你想要替换的任何内容的伪造实例或模拟。

Kotlin

// In the FakeNetworkModule, pass a fake implementation of LoginRetrofitService
// that you can use in your tests.
@Module
class FakeNetworkModule {
    @Provides
    fun provideLoginRetrofitService(): LoginRetrofitService {
        return FakeLoginService()
    }
}

Java

// In the FakeNetworkModule, pass a fake implementation of LoginRetrofitService
// that you can use in your tests.
@Module
public class FakeNetworkModule {

    @Provides
    public LoginRetrofitService provideLoginRetrofitService() {
        return new FakeLoginService();
    }
}

在集成或端到端测试中，你将使用一个 TestApplication，它创建 TestApplicationComponent 而不是 ApplicationComponent。

Kotlin

// Your test application needs an instance of the test graph
class MyTestApplication: MyApplication() {
    override val appComponent = DaggerTestApplicationComponent.create()
}

Java

// Your test application needs an instance of the test graph
public class MyTestApplication extends MyApplication {
    ApplicationComponent appComponent = DaggerTestApplicationComponent.create();
}

然后，此测试应用程序在自定义 TestRunner 中使用，你将使用它来运行仪器测试。有关此方面的更多信息，请查看在 Android 应用中使用 Dagger 代码实验室。

使用 Dagger 模块。

Dagger 模块是一种以语义方式封装如何提供对象的方法。你可以在组件中包含模块，但你也可以在其他模块内包含模块。这很强大，但很容易被误用。

一旦将模块添加到组件或其他模块中，它就已存在于 Dagger 图中；Dagger 可以在该组件中提供这些对象。在添加模块之前，请检查该模块是否已作为 Dagger 图的一部分，方法是检查它是否已添加到组件中，或编译项目并查看 Dagger 是否可以找到该模块所需的依赖项。

最佳实践规定，模块应在组件中只声明一次（除了某些高级的 Dagger 用例）。

假设你的图是这样配置的：ApplicationComponent 包含 Module1 和 Module2，而 Module1 包含 ModuleX。

Kotlin

@Component(modules = [Module1::class, Module2::class])
interface ApplicationComponent { ... }

@Module(includes = [ModuleX::class])
class Module1 { ... }

@Module
class Module2 { ... }

Java

@Component(modules = {Module1.class, Module2.class})
public interface ApplicationComponent { ... }

@Module(includes = {ModuleX.class})
public class Module1 { ... }

@Module
public class Module2 { ... }

如果现在 Module2 依赖于 ModuleX 提供的类。一种不好的做法是将 ModuleX 包含在 Module2 中，因为 ModuleX 在图中被包含了两次，如以下代码片段所示

Kotlin

// Bad practice: ModuleX is declared multiple times in this Dagger graph
@Component(modules = [Module1::class, Module2::class])
interface ApplicationComponent { ... }

@Module(includes = [ModuleX::class])
class Module1 { ... }

@Module(includes = [ModuleX::class])
class Module2 { ... }

Java

// Bad practice: ModuleX is declared multiple times in this Dagger graph.
@Component(modules = {Module1.class, Module2.class})
public interface ApplicationComponent { ... }

@Module(includes = ModuleX.class)
public class Module1 { ... }

@Module(includes = ModuleX.class)
public class Module2 { ... }

相反，你应该执行以下操作之一

重构模块并将公共模块提取到组件中。
创建一个包含两个模块共享的对象的新模块，并将它提取到组件中。

不进行这种重构会导致许多模块相互包含，没有明确的组织方式，难以查看每个依赖项的来源。

最佳实践（选项 1）：ModuleX 在 Dagger 图中声明一次。

Kotlin

@Component(modules = [Module1::class, Module2::class, ModuleX::class])
interface ApplicationComponent { ... }

@Module
class Module1 { ... }

@Module
class Module2 { ... }

Java

@Component(modules = {Module1.class, Module2.class, ModuleX.class})
public interface ApplicationComponent { ... }

@Module
public class Module1 { ... }

@Module
public class Module2 { ... }

最佳实践（选项 2）：Module1 和 Module2 中 ModuleX 的公共依赖项被提取到一个名为 ModuleXCommon 的新模块中，该模块包含在组件中。然后创建另外两个名为 ModuleXWithModule1Dependencies 和 ModuleXWithModule2Dependencies 的模块，其中包含特定于每个模块的依赖项。所有模块都在 Dagger 图中声明一次。

Kotlin

@Component(modules = [Module1::class, Module2::class, ModuleXCommon::class])
interface ApplicationComponent { ... }

@Module
class ModuleXCommon { ... }

@Module
class ModuleXWithModule1SpecificDependencies { ... }

@Module
class ModuleXWithModule2SpecificDependencies { ... }

@Module(includes = [ModuleXWithModule1SpecificDependencies::class])
class Module1 { ... }

@Module(includes = [ModuleXWithModule2SpecificDependencies::class])
class Module2 { ... }

Java

@Component(modules = {Module1.class, Module2.class, ModuleXCommon.class})
public interface ApplicationComponent { ... }

@Module
public class ModuleXCommon { ... }

@Module
public class ModuleXWithModule1SpecificDependencies { ... }

@Module
public class ModuleXWithModule2SpecificDependencies { ... }

@Module(includes = ModuleXWithModule1SpecificDependencies.class)
public class Module1 { ... }

@Module(includes = ModuleXWithModule2SpecificDependencies.class)
public class Module2 { ... }

辅助注入

辅助注入是一种 DI 模式，用于构造对象，其中一些参数可能由 DI 框架提供，而其他参数必须在创建时由用户传入。

在 Android 中，这种模式在详细信息屏幕中很常见，其中要显示的元素的 ID 只有在运行时才知道，而不是在 Dagger 生成 DI 图的编译时。要了解有关使用 Dagger 进行辅助注入的更多信息，请参阅 Dagger 文档。

结论

如果你还没有，请查看最佳实践部分。要了解如何在 Android 应用程序中使用 Dagger，请参阅在 Android 应用程序中使用 Dagger 代码实验室。