Dagger 2 组件中的 getter 方法的目的是什么？

Question

我正在尝试了解 Dagger 2 中的组件。这是一个示例：

@Component(modules = { MyModule.class })
public interface MyComponent {

    void inject(InjectionSite injectionSite);

    Foo foo();

    Bar bar();   

}

我了解void inject() 方法的作用。但我不明白其他 Foo foo() getter 方法的作用。这些其他方法的目的是什么？

Answer 1

Dagger 是一种连接对象及其依赖关系图的方法。作为直接调用构造函数的替代方法，您可以通过从 Dagger 请求实例来获取实例，或者通过提供您希望注入 Dagger 创建的实例的对象来获取实例。

让我们创建一家咖啡店，这取决于 Provider<Coffee> 和 CashRegister。假设您已将它们连接到一个模块中（可能是 LightRoastCoffee 和 DefaultCashRegister 实现）。

public class CoffeeShop {
  private final Provider<Coffee> coffeeProvider;
  private final CashRegister register;

  @Inject
  public CoffeeShop(Provider<Coffee> coffeeProvider, CashRegister register) {
    this.coffeeProvider = coffeeProvider;
    this.register = register;
  }

  public void serve(Person person) {
    cashRegister.takeMoneyFrom(person);
    person.accept(coffeeProvider.get());
  }
}

现在您需要获取该 CoffeeShop 的实例，但它只有一个带有其依赖项的两参数构造函数。那你怎么做呢？很简单：你告诉 Dagger 在它生成的 Component 实例上创建一个工厂方法。

@Component(modules = {/* ... */})
public interface CoffeeShopComponent {
  CoffeeShop getCoffeeShop();

  void inject(CoffeeService serviceToInject); // to be discussed below
}

当您调用 getCoffeeShop 时，Dagger 创建 Provider<Coffee> 以提供 LightRoastCoffee，创建 DefaultCashRegister，将它们提供给 Coffeeshop 构造函数，然后返回结果。恭喜，您自豪地拥有一家全连接的咖啡店。

现在，所有这些都是替代void 注入方法，它采用已创建的实例并注入其中：

public class CoffeeService extends SomeFrameworkService {
  @Inject CoffeeShop coffeeShop;

  @Override public void initialize() {
    // Before injection, your coffeeShop field is null.
    DaggerCoffeeShopComponent.create().inject(this);
    // Dagger inspects CoffeeService at compile time, so at runtime it can reach
    // in and set the fields.
  }

  @Override public void alternativeInitialize() {
    // The above is equivalent to this, though:
    coffeeShop = DaggerCoffeeShopComponent.create().getCoffeeShop();
  }
}

所以，你有了它：两种不同的样式，这两种样式都可以让你访问完全注入的对象图，而无需列出或关心它们需要哪些依赖项。您可以选择其中一种，或者更喜欢顶级工厂方法和 Android 或服务用例的成员注入，或任何其他类型的混合搭配。

(注意： 除了用作对象图的入口点之外，称为 provision 方法 的无参数 getter 也可用于公开组件依赖项的绑定，因为David Rawson 在other answer 中描述。）

Answer 2

在依赖组件中的使用

在依赖组件层次结构的上下文中，例如this example，提供方法（例如Foo foo()）用于向依赖组件公开绑定。 “公开”意味着“提供”甚至“发布”。请注意，方法本身的名称实际上是无关紧要的。一些程序员选择将这些方法命名为Foo exposeFoo()，以使方法名称反映其用途。

说明：

在 Dagger 2 中编写组件时，会将包含 @Provides 方法的模块组合在一起。这些@Provides 方法可以被认为是“绑定”，因为它们将抽象（例如，类型）与解析该类型的具体方法相关联。考虑到这一点，Foo foo() 方法使组件能够将其对 Foo 的绑定公开给依赖组件。

示例：

假设Foo 是一个应用程序Singleton，我们希望将它用作DependsOnFoo 实例的依赖项，但在一个范围更窄的组件内。如果我们在MyDependentComponent 的一个模块中编写一个简单的@Provides 方法，那么我们将获得一个新实例。相反，我们可以这样写：

@PerFragment
@Component(dependencies = {MyComponent.class }
           modules = { MyDependentModule.class })
public class MyDependentComponent {

    void inject(MyFragment frag);

}

还有模块：

@Module
public class MyDepedentModule {

    @Provides
    @PerFragment
    DependsOnFoo dependsOnFoo(Foo foo) {
        return new DependsOnFoo(foo);
    }
}

还假设DependentComponent 的注入站点包含DependsOnFoo：

public class MyFragment extends Fragment {
    
    @Inject DependsOnFoo dependsOnFoo

}

注意MyDependentComponent 只知道模块MyDependentModule。通过该模块，它知道它可以使用Foo 的实例提供DependsOnFoo，但它不知道如何自己提供Foo。这会发生尽管MyDependentComponent 是MyComponent 的依赖组件。 MyComponent 中的Foo foo() 方法允许依赖组件MyDependentComponent 使用MyComponent 对Foo 的绑定来注入DependsOnFoo。如果没有这个Foo foo() 方法，编译会失败。

用于解析绑定

假设我们想获得Foo 的实例，而不必调用inject(this)。组件内的Foo foo() 方法将允许您使用Guice 的Injector 或Castle Windsor 的Resolve 调用getInstance() 的方法。图示如下：

public void fooConsumer() {
    DaggerMyComponent component = DaggerMyComponent.builder.build();
    Foo foo = component.foo();
}