为每个activity声明一个单独的模块根本不是一个好主意。为每个activity声明单独的组件更糟糕。这背后的推理非常简单--您并不真正需要所有这些模块/组件（正如您自己已经看到的那样）。

但是，只有一个组件与应用程序的生命周期绑定，并将其注入所有活动也不是最佳解决方案（这是您朋友的方法）。它不是最佳的，因为：

1. 它将您限制在一个作用域(@singleton或自定义作用域）
2. 您被限制的唯一作用域使注入的对象成为“应用程序单例”，因此作用域中的错误或作用域对象的不正确使用很容易导致全局内存泄漏
3. 您也希望使用Dagger2注入服务中，但是服务可能需要与活动不同的对象（例如，服务不需要演示者，不具有FragmentManager等）。通过使用单个组件，您就可以放松为不同组件定义不同对象图的灵活性。

因此，每个activity都有一个组件是矫枉过正的，但对于整个应用程序来说，单个组件不够灵活。最优解介于这两个极端之间（通常如此）。

我使用以下方法：

1. 提供“全局”对象的单个“应用程序”组件（例如，保存全局状态的对象，该全局状态在应用程序中的所有组件之间共享）。在应用程序中实例化。
2. “Controller”是“Application”组件的子组件，它提供所有面向用户的“Controller”所需的对象（在我的体系结构中，这些对象是活动和片段)。在每个activity和片段中实例化。
“应用程序”组件的
3. “服务”子组件，提供所有服务所需的对象。在每个服务中实例化。

下面是如何实现相同方法的示例。

编辑2017年7月

我发布了一个视频教程，展示了如何在Android应用中构造Dagger依赖注入代码：Android Dagger for professional教程。

2018年2月编辑

我发表了一个关于Android中依赖注入的完整课程。

在本课程中，我将解释依赖注入的理论，并展示它是如何在Android应用程序中自然出现的。然后我演示了Dagger构造如何适合于一般的依赖注入方案。

如果您学习了这门课程，您就会明白为什么为每个activity/片段单独定义模块/组件的想法在最根本的方面是有缺陷的。

这种方法使类的“功能”集合的表现层结构映射到类的“建构”集合的结构中,从而将它们耦合在一起。这违背了依赖注入的主要目标，即保持类的“构造”集和“功能”集不相交。

适用范围：

@ApplicationScope
@Component(modules = ApplicationModule.class)
public interface ApplicationComponent {

    // Each subcomponent can depend on more than one module
    ControllerComponent newControllerComponent(ControllerModule module);
    ServiceComponent newServiceComponent(ServiceModule module);

}


@Module
public class ApplicationModule {

    private final Application mApplication;

    public ApplicationModule(Application application) {
        mApplication = application;
    }

    @Provides
    @ApplicationScope
    Application applicationContext() {
        return mApplication;
    }

    @Provides
    @ApplicationScope
    SharedPreferences sharedPreferences() {
        return mApplication.getSharedPreferences(Constants.PREFERENCES_FILE, Context.MODE_PRIVATE);
    }

    @Provides
    @ApplicationScope
    SettingsManager settingsManager(SharedPreferences sharedPreferences) {
        return new SettingsManager(sharedPreferences);
    }
}

控制器作用域：

@ControllerScope
@Subcomponent(modules = {ControllerModule.class})
public interface ControllerComponent {

    void inject(CustomActivity customActivity); // add more activities if needed

    void inject(CustomFragment customFragment); // add more fragments if needed

    void inject(CustomDialogFragment customDialogFragment); // add more dialogs if needed

}



@Module
public class ControllerModule {

    private Activity mActivity;
    private FragmentManager mFragmentManager;

    public ControllerModule(Activity activity, FragmentManager fragmentManager) {
        mActivity = activity;
        mFragmentManager = fragmentManager;
    }

    @Provides
    @ControllerScope
    Context context() {
        return mActivity;
    }

    @Provides
    @ControllerScope
    Activity activity() {
        return mActivity;
    }

    @Provides
    @ControllerScope
    DialogsManager dialogsManager(FragmentManager fragmentManager) {
        return new DialogsManager(fragmentManager);
    }

    // @Provides for presenters can be declared here, or in a standalone PresentersModule (which is better)
}

然后在activity:

public class CustomActivity extends AppCompatActivity {

    @Inject DialogsManager mDialogsManager;

    private ControllerComponent mControllerComponent;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getControllerComponent().inject(this);

    }

    private ControllerComponent getControllerComponent() {
        if (mControllerComponent == null) {

            mControllerComponent = ((MyApplication)getApplication()).getApplicationComponent()
                    .newControllerComponent(new ControllerModule(this, getSupportFragmentManager()));
        }

        return mControllerComponent;
    }
}

有关依赖注入的其他信息：

Dagger 2镜

Android中的依赖注入