我正在尝试在我的应用程序中实现 Dagger 依赖注入(inject)，但我很难理解它是如何工作的，尤其是来自 Spring，其中 DI 更容易且更具声明性。

我想要做的是拥有一堆可以在我的应用程序中使用的准备好注入(inject)的对象，即 SharedPreferences、网络对象(OkHttp、Retrofit、Picasso...)、EventBus 和一个 SchedulerProvider 对象对于 RxJava。

This sample似乎提供了我需要的一切，但我在掌握一些概念时遇到了困难。

在此other sample在上一页中提到，他们创建了一个 GithubService，它使用 NetModule 中提供的 Retrofit 对象。为此，他们创建了一个像这样的 GithubComponent:

@UserScope
@Component(dependencies = NetComponent.class, modules = GitHubModule.class)
public interface GitHubComponent {
    void inject(MainActivity activity);
}

他们正在使用定义自己范围的 UserScope 注释。既然不能使用@Singleton，是不是意味着这个对象就不会是Singleton了呢？范围如何真正影响 DI？看起来他们只是在声明一个命名范围而没有更多效果，但我不确定。

此外，我的应用程序是使用带 fragment 的 Activity 构建的。我是否必须为应用程序中的每个 fragment 创建一个组件？即我需要在整个应用程序中使用我的 REST api 服务，我是否必须为使用它们的每个屏幕声明一个组件？这增加了所需的样板代码数量，因此听起来不是很干净。

最佳答案

组件应该是为特定范围提供一切的“大型 DI 提供者”。

例如，您可以有一个 SingletonComponent 和 @Singleton 作用域，其中添加的每个模块都至少有一个 @Singleton 作用域提供者方法。

@Singleton
@Component(modules={NetworkingModule.class, DatabaseModule.class, MapperModule.class, UtilsModule.class})
public interface SingletonComponent {
    // provision methods
    OkHttpClient okHttpClient();
    RealmHolder realmHolder();
    // etc.
}

您可以为每个模块定义配置方法。

public interface DatabaseComponent {
    RealmHolder realmHolder();
}

public interface NetworkingComponent{
    OkHttpClient okHttpClient();
}

在这种情况下你会有

@Singleton
@Component(modules={NetworkingModule.class, DatabaseModule.class, MapperModule.class, UtilsModule.class})
public interface SingletonComponent 
      extends NetworkingComponent, DatabaseComponent, MapperComponent, UtilsComponent {
    // provision methods inherited
}

在模块中，您可以指定一个工厂方法(“提供者方法”)来指定如何创建特定类型的依赖项。

例如，

@Module
public class NetworkingModule {
    @Provides
    @Singleton
    OkHttpClient okHttpClient() {
        return new OkHttpClient.Builder()./*...*/.build();
    }

    @Provides
    @Singleton
    Retrofit retrofit(OkHttpClient okHttpClient) {
        // ...
    }
}

您可以将 @Singleton 作用域想象成 Spring 为您提供的大型 DI 容器。

您还可以使用 @Inject 带注释的构造函数提供类的实例。这可以从组件接收任何类，该组件能够从该作用域组件模块(当然还有非作用域依赖项)中的提供程序方法实例化它。

@Singleton
public class MyMapper {
    @Inject
    public MyMapper(RealmHolder realmHolder, OkHttpClient okHttpClient) { // totally random constructor for demo
    }
}

或

@Singleton
public class MyMapper {
    @Inject
    RealmHolder realmHolder;

    @Inject
    OkHttpClient okHttpClient;

    @Inject
    public MyMapper() {
    }
}

那么这将在组件中可用，您甚至可以为其提供方法以使其在组件依赖项中可继承:

@Singleton 
@Component(modules={...})
public interface SingletonComponent {
    MyMapper myMapper();
}

使用 Dagger2，您还可以另外创建“子范围组件”，它继承从给定范围的组件提供的所有依赖项。

例如，您可以继承所有 @Singleton 范围内的组件，但您仍然可以在每个新范围内拥有新的范围内依赖项，例如 @ActivityScope。

@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface ActivityScope {
}

然后，您可以使用子组件或组件依赖项创建子范围组件。

• 子组件:

.

@ActivityScope
@Subcomponent(modules={MainActivityModule.class})
public interface MainActivityComponent {
    MainPresenter mainPresenter();
}

然后可以在其父作用域组件中创建它:

@Singleton 
@Component(modules={...})
public interface SingletonComponent {
    MainActivityComponent mainActivityComponent(MainActivityModule module);
}

然后你可以使用单例组件来实例化它:

SingletonComponent singletonComponent = DaggerSingletonComponent.create();
MainActivityComponent mainActivityComponent = singletonComponent.mainActivityComponent(new MainActivityModule(mainActivityHolder));

• 组件依赖:

.

@ActivityScope
@Component(dependencies={SingletonComponent.class}, modules={MainActivityModule.class})
public interface MainActivityComponent extends SingletonComponent {
    MainPresenter mainPresenter();
}

为此，您必须在超作用域组件中指定提供方法。

然后你可以像这样实例化它:

SingletonComponent singletonComponent = DaggerSingletonComponent.create();
MainActivityComponent mainActivityComponent = DaggerMainActivityComponent.builder()
                       .singletonComponent(singletonComponent)
                       .mainActivityModule(new MainActivityModule(mainActivityHolder))
                       .build();

因此，在 Dagger2 中，您可以通过以下方式获取依赖项:

• @Inject 注解构造函数参数
• @Inject 使用@Inject 注释的构造函数在类上注释字段
• 从@Component提供方法
• 通过组件中定义的手动字段注入(inject)方法(对于不能使用 @Inject 注释构造函数创建的类)

对于像 MainActivity 这样不是您自己创建的类，可能会发生手动字段注入(inject)。

手动字段注入(inject)仅注入(inject)您正在注入(inject)的特定类。基类不会自动注入(inject)，它们需要在组件上调用 .inject(this)。

它是这样工作的:

@ActivityScope
@Subcomponent(modules={MainActivityModule.class})
public interface MainActivityComponent {
    void inject(MainActivity mainActivity);
}

然后你可以这样做:

public class MainActivity extends AppCompatActivity {
    @Override
    public void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        MainActivityComponent mainActivityComponent = DaggerMainActivityComponent.builder()
                          .singletonComponent(getSingletonComponent())
                          .mainActivityModule(new MainActivityModule(this))
                          .build(); // ensure activity `holder` instead, and retain component in retained fragment or `non-configuration instance`
        mainActivityComponent.inject(this);       
    }
}

关于android - Dagger2 和 Android，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/40545075/