Dagger基础知识

根据项目的规模，在 Android 应用中使用手动依赖项注入或服务定位器可能会出现问题。您可以通过使用Dagger来管理依赖项，从而限制项目在扩展时的复杂性。

Dagger 自动生成模拟您原本需要手动编写的代码的代码。由于代码是在编译时生成的，因此它比其他基于反射的解决方案（例如Guice）更易于追踪且性能更高。

使用 Dagger 的好处

Dagger 通过以下方式让您免于编写冗长且容易出错的样板代码：

  • 生成您在手动 DI 部分手动实现的AppContainer 代码（应用程序图）。

  • 为应用程序图中可用的类创建工厂。这就是内部满足依赖项的方式。

  • 通过使用作用域来决定是重用依赖项还是创建新实例。

  • 使用 Dagger 的子组件创建特定流程的容器，就像您在上一节中对登录流程所做的那样。这可以通过在不再需要对象时释放内存中的对象来提高应用的性能。

只要您声明类的依赖项并指定如何使用注解来满足这些依赖项，Dagger 就会在构建时自动执行所有这些操作。Dagger 生成的代码与您手动编写的代码类似。在内部，Dagger 创建一个对象图，它可以引用该对象图来查找提供类实例的方法。对于图中的每个类，Dagger都会生成一个工厂类型类，它在内部使用该类来获取该类型的实例。

在构建时，Dagger 会遍历您的代码并：

  • 构建并验证依赖关系图，确保

    • 每个对象的依赖关系都能得到满足，从而避免运行时异常。
    • 不存在依赖循环，从而避免无限循环。

  • 生成在运行时用于创建实际对象及其依赖关系的类。

Dagger 中的一个简单用例：生成工厂

为了演示如何使用 Dagger，让我们为下图所示的UserRepository类创建一个简单的工厂

定义UserRepository如下

Kotlin

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

Java

public class UserRepository {

    private final UserLocalDataSource userLocalDataSource;
    private final UserRemoteDataSource userRemoteDataSource;

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

    ...
}

在UserRepository构造函数中添加@Inject注解，以便 Dagger 知道如何创建UserRepository

Kotlin

// @Inject lets Dagger know how to create instances of this object
class UserRepository @Inject constructor(
    private val localDataSource: UserLocalDataSource,
    private val remoteDataSource: UserRemoteDataSource
) { ... }

Java

public class UserRepository {

    private final UserLocalDataSource userLocalDataSource;
    private final UserRemoteDataSource userRemoteDataSource;

    // @Inject lets Dagger know how to create instances of this object
    @Inject
    public UserRepository(UserLocalDataSource userLocalDataSource, UserRemoteDataSource userRemoteDataSource) {
        this.userLocalDataSource = userLocalDataSource;
        this.userRemoteDataSource = userRemoteDataSource;
    }
}

在上面的代码片段中，您告诉 Dagger

  1. 如何使用带有@Inject注解的构造函数来创建UserRepository实例。

  2. 它的依赖关系是什么：UserLocalDataSource和UserRemoteDataSource。

现在 Dagger 知道如何创建UserRepository的实例，但它不知道如何创建其依赖项。如果您也对其他类添加注解，Dagger 就会知道如何创建它们。

Kotlin

// @Inject lets Dagger know how to create instances of these objects
class UserLocalDataSource @Inject constructor() { ... }
class UserRemoteDataSource @Inject constructor() { ... }

Java

public class UserLocalDataSource {
    @Inject
    public UserLocalDataSource() { }
}

public class UserRemoteDataSource {
    @Inject
    public UserRemoteDataSource() { }
}

Dagger 组件

Dagger 可以创建项目中依赖项的图形，它可以使用该图形来找出在需要时应该从哪里获取这些依赖项。要让 Dagger 执行此操作，您需要创建一个接口并使用@Component对其进行注解。Dagger 会创建一个容器，就像您使用手动依赖注入那样。

在@Component接口内，您可以定义返回所需类实例的函数（即UserRepository）。@Component告诉 Dagger 生成一个包含满足其公开类型的所需所有依赖项的容器。这称为*Dagger 组件*；它包含一个图形，该图形由 Dagger 知道如何提供的对象及其各自的依赖项组成。

Kotlin

// @Component makes Dagger create a graph of dependencies
@Component
interface ApplicationGraph {
    // The return type  of functions inside the component interface is
    // what can be provided from the container
    fun repository(): UserRepository
}

Java

// @Component makes Dagger create a graph of dependencies
@Component
public interface ApplicationGraph {
    // The return type  of functions inside the component interface is
    // what can be consumed from the graph
    UserRepository userRepository();
}

构建项目时，Dagger 会为您生成ApplicationGraph接口的实现：DaggerApplicationGraph。借助其注解处理器，Dagger 创建了一个依赖关系图，该图由三个类（UserRepository、UserLocalDatasource和UserRemoteDataSource）之间的关系组成，只有一个入口点：获取UserRepository实例。您可以按如下方式使用它

Kotlin

// Create an instance of the application graph
val applicationGraph: ApplicationGraph = DaggerApplicationGraph.create()
// Grab an instance of UserRepository from the application graph
val userRepository: UserRepository = applicationGraph.repository()

Java

// Create an instance of the application graph
ApplicationGraph applicationGraph = DaggerApplicationGraph.create();

// Grab an instance of UserRepository from the application graph
UserRepository userRepository = applicationGraph.userRepository();

每次请求UserRepository时，Dagger 都会创建一个新的实例。

Kotlin

val applicationGraph: ApplicationGraph = DaggerApplicationGraph.create()

val userRepository: UserRepository = applicationGraph.repository()
val userRepository2: UserRepository = applicationGraph.repository()

assert(userRepository != userRepository2)

Java

ApplicationGraph applicationGraph = DaggerApplicationGraph.create();

UserRepository userRepository = applicationGraph.userRepository();
UserRepository userRepository2 = applicationGraph.userRepository();

assert(userRepository != userRepository2)

有时，您需要在容器中拥有依赖项的唯一实例。您可能出于多种原因需要这样做

  1. 您希望其他将此类型作为依赖项的类型共享同一个实例，例如在登录流程中使用同一个LoginUserData的多个ViewModel对象。

  2. 创建对象成本很高，您不希望每次将其声明为依赖项时都创建一个新实例（例如，JSON 解析器）。

在本例中，您可能希望在图形中拥有UserRepository的唯一实例，以便每次请求UserRepository时，始终获得相同的实例。这在您的示例中非常有用，因为在具有更复杂应用程序图的实际应用程序中，您可能有多个ViewModel对象依赖于UserRepository，并且您不希望每次需要提供UserRepository时都创建UserLocalDataSource和UserRemoteDataSource的新实例。

在手动依赖注入中，您可以通过将UserRepository的相同实例传递到 ViewModel 类的构造函数中来实现此目的；但在 Dagger 中，由于您不是手动编写该代码，因此必须让 Dagger 知道您要使用相同的实例。这可以使用*作用域注解*来完成。

使用 Dagger 进行作用域限定

您可以使用作用域注解将对象的生存期限制在其组件的生存期内。这意味着每次需要提供该类型时，都会使用同一依赖项实例。

要在请求ApplicationGraph中的存储库时拥有UserRepository的唯一实例，请对@Component接口和UserRepository使用相同的作用域注解。您可以使用@Singleton注解，该注解已包含在 Dagger 使用的javax.inject包中。

Kotlin

// Scope annotations on a @Component interface informs Dagger that classes annotated
// with this annotation (i.e. @Singleton) are bound to the life of the graph and so
// the same instance of that type is provided every time the type is requested.
@Singleton
@Component
interface ApplicationGraph {
    fun repository(): UserRepository
}

// Scope this class to a component using @Singleton scope (i.e. ApplicationGraph)
@Singleton
class UserRepository @Inject constructor(
    private val localDataSource: UserLocalDataSource,
    private val remoteDataSource: UserRemoteDataSource
) { ... }

Java

// Scope annotations on a @Component interface informs Dagger that classes annotated
// with this annotation (i.e. @Singleton) are scoped to the graph and the same
// instance of that type is provided every time the type is requested.
@Singleton
@Component
public interface ApplicationGraph {
    UserRepository userRepository();
}

// Scope this class to a component using @Singleton scope (i.e. ApplicationGraph)
@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;
    }
}

或者，您可以创建和使用自定义作用域注解。您可以按如下方式创建作用域注解

Kotlin

// Creates MyCustomScope
@Scope
@MustBeDocumented
@Retention(value = AnnotationRetention.RUNTIME)
annotation class MyCustomScope

Java

// Creates MyCustomScope
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface MyCustomScope {}

然后，您可以像以前一样使用它

Kotlin

@MyCustomScope
@Component
interface ApplicationGraph {
    fun repository(): UserRepository
}

@MyCustomScope
class UserRepository @Inject constructor(
    private val localDataSource: UserLocalDataSource,
    private val service: UserService
) { ... }

Java

@MyCustomScope
@Component
public interface ApplicationGraph {
    UserRepository userRepository();
}

@MyCustomScope
public class UserRepository {

    private final UserLocalDataSource userLocalDataSource;
    private final UserRemoteDataSource userRemoteDataSource;

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

在这两种情况下，都使用与用于注解@Component接口相同的作用域来提供对象。因此，每次调用applicationGraph.repository()时，您都会获得UserRepository的同一实例。

Kotlin

val applicationGraph: ApplicationGraph = DaggerApplicationGraph.create()

val userRepository: UserRepository = applicationGraph.repository()
val userRepository2: UserRepository = applicationGraph.repository()

assert(userRepository == userRepository2)

Java

ApplicationGraph applicationGraph = DaggerApplicationGraph.create();

UserRepository userRepository = applicationGraph.userRepository();
UserRepository userRepository2 = applicationGraph.userRepository();

assert(userRepository == userRepository2)

结论

在更复杂的场景中使用 Dagger 之前，务必了解 Dagger 的优点和基本工作原理。

在下一页中，您将学习如何将 Dagger 添加到 Android 应用程序。