Android 上的 Dagger 2 @Singleton 注释 class 未被注入

Question

我目前正在尝试将 Dagger 2 集成到 Android 应用程序中。我的项目设置如下：

图书馆
应用程序（取决于图书馆）

在我的图书馆项目中，我定义了一个 class，稍后我将把它注入图书馆中其他需要它的 classes（活动和常规 classes）作为应用程序项目。

@Singleton
public class MyManager{
  @Inject
  public MyManager(){
    //Do some initializing
  }
}

现在 - 例如在我的片段或活动或常规 classes 中，我将按如下方式注入上述单例：

public class SomeClass{

  @Inject
  MyManager myManager;
}

我大概是这么想的，因为实际上 myManager 总是空的。显然它的构造函数也从未被调用过，所以我想我一定是在配置方面遗漏了一些东西？或者也许我误解了文档并且它根本不应该以这种方式工作？ MyManager class 的目的是成为一个应用程序范围内可访问的组件累积实体——这就是我选择 @Singleton 的原因。

更新

为避免混淆：我认为我在评论中的某处提到了我的组件 - 这是指 "component based design" 意义上的组件，与匕首无关。我拥有的基于匕首的代码都在上面列出 - 我的代码中没有其他与匕首相关的内容。

当我开始添加 @Component 时遇到了一些编译器问题，因为我的 dagger2 没有正确设置 - 查看这个关于如何正确设置 dagger2 的非常有用的帖子：

更新 2

这是我更新的代码，基于 G. Lombard 的建议 - 我更改了代码如下 - 原始的 Singleton 在库项目中：

@Singleton
public class MyManager{
  @Inject
  public MyManager(){
    //Do some initializing
  }
}

库项目中还有 bootstrap class:

@Singleton
@Component
public interface Bootstrap {
    void initialize(Activity activity);
}

然后我在我的 activity 中使用上面的 Bootstrap class（在我的具体应用程序中，NOT 在库项目中！我但是在库中也有 Classes/Activities 可以访问 Bootstrap 来注入 MyManager):

public class MyActivity extends Activity{

    @Inject
    MyManager manager;


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

        //DONT DO THIS !!! AS EXPLAINED BY EpicPandaForce
        DaggerBootstrap.create().initialize(this);
    }
}

但即使在这一行之后：

        DaggerBootstrap.create().initialize(this);

管理器实例仍然为空，即未注入。

我刚找到这个：

如果我没看错的话，这意味着我需要在 Bootstrap class 中指定每个 class 将使用 @Inject 来注入东西。遗憾的是 - 这不是一个选择，因为我有 40 多个 classes 和活动我必须这样做。

意味着我的 Bootstrap 界面显然必须看起来像这样：

@Singleton
@Component
public interface Bootstrap {
    void initialize(ActivityA activity);
    void initialize(ActivityB activity);
    void initialize(ActivityC activity);
    void initialize(ActivityD activity);
    void initialize(ActivityE activity);
    void initialize(ActivityF activity);
    //and so on and so forth...
}

如果以上内容属实，那对于我的用例来说就不值得了。另外：似乎没有编译时检查，如果我忘记在这里指定我的 40+ classes 之一？它只是行不通 - 即在运行时使应用程序崩溃。

Answer 1

很难说出你的问题是什么，因为你没有显示你的 Component 是什么样子以及你是否有多个组件等。

假设这个逻辑结构：

/app
   MainComponent
   SomeClass    // where MyManager is to be injected
   MainActivity // where SomeClass is to be injected
/library
   LibraryComponent
   MyManager    // Singleton

然后您的 classes 将使用以下配置正确注入：

@Singleton
@Component
public interface LibraryComponent {
    MyManager getMyManager();
}

和应用程序级组件将依赖项注入 activity:

@ActivityScope
@Component(dependencies = LibraryComponent.class)
public interface MainComponent {
    void inject(MainActivity mainActivity);
}

注意MainComponent依赖于LibraryComponent，但是因为后者有单例作用域，所以你需要为另一个定义一个作用域，我是用"activity scope" 这里。（或者如果满足您的需要，您也可以将 MainComponent 设为单例并完全摆脱 LibraryComponent。）

最后像这样全部注入activity:

@Inject
SomeClass someClass;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    DaggerMainComponent.builder()
            .libraryComponent(DaggerLibraryComponent.create())
            .build()
            .inject(this);

    someClass.doSomething();
}

我放了一个工作样本here on GitHub

更新 1：

如果我对你的设置理解正确，那么你到目前为止只在列出的两个 class 上使用了 @Singleton 和 @Inject 注释（MyManager 和 SomeClass)，并且你的项目中没有其他与 Dagger 相关的代码。

在这种情况下，您的 MyManager 没有被注入的原因是 Dagger 不知道如何 provide/instantiate 依赖项。这就是我上面提到的 "components" 的用武之地。如果没有任何 Dagger 2 组件（使用 @Component 注释的接口或抽象 class），您的依赖项将不会自动注入。

我不知道您是否有依赖注入概念的经验，但假设您没有，我将逐步介绍您需要了解的最低限度基础知识，以便将您的 MyManager 注入SomeClass:

首先：使用DI时，需要了解"newables"和"injectables"的区别。 This blogpost Misko Hevery 解释了细节。

这意味着，您无法 new 提高 SomeClass。这行不通：

mSomeClass = new SomeClass();

因为如果你这样做（比如在 activity 或片段中），Dagger 将不知道你期望将依赖项注入 SomeClass 并且它没有机会注入任何东西.

为了注入其依赖项，您还必须通过 Dagger 实例化（或注入）SomeClass 自身。

换句话说，在您的 Activity 中使用 SomeClass，您将需要：

@Inject
SomeClass mSomeClass;

接下来，您需要一个 Dagger 组件来执行实际的注入。要创建一个组件，您可以创建一个接口，该接口的方法将您的根对象（比如 MainActivity）作为参数，例如：

@Singleton
@Component
public interface Bootstrap {
    void initialize(MainActivity activity);
}

现在，当您构建项目时，Dagger 2 会生成一个名为 DaggerBootstrap 的 class 来实现此接口。你使用这个生成的 class 来执行注入，比如在你的 activity 的 onCreate:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    DaggerBootstrap.create().initialize(this);

    mSomeClass.doSomething();
}

我相信这个生成的组件是您缺少的关键部分。以上 here.

的完整代码

一些有用的 Dagger 2 资源：

更新二：

似乎最后一块缺失的拼图是您的组件为 Activity 基础 class 提供了一个注入方法，但没有为您的实际具体 activity.

不幸的是，Dagger 2 需要一个用于 each activity 或您要注入的其他 class 的注入方法。

如您所述，当您的应用程序中有许多不同的活动时，这会很烦人。有一些可能的解决方法，搜索 "dagger 2 inject base class"，例如@EpicPandaForce 的建议：Dagger 2 base class injections

另请注意，正如@EpicPandaForce 在评论中指出的那样，在我的简单示例中，我每次都调用 DaggerLibraryComponent.create() 这可能不是您想要的，因为该组件应该提供您的单例，所以你最好从其他地方获取现有实例，比如从你的应用程序实例。

Answer 2

你犯了一个错误，因为你正在使用

DaggerBootstrap.create().initialize(this);

在您的 Activity 中，因为范围不在多个组件实例之间共享。我推荐的是使用自定义应用程序 class

public class CustomApplication extends Application {
    @Override
    public void onCreate() {
         super.onCreate();
         Bootstrap.INSTANCE.setup();
    }
}

@Component
@Singleton
public interface _Bootstrap {
    void initialize(ActivityA activityA);
    //void initiali...
}

public enum Bootstrap {
    INSTANCE;

    private _Bootstrap bootstrap;

    void setup() {
        bootstrap = Dagger_Bootstrap.create();
    }

    public _Bootstrap getBootstrap() {
        return bootstrap;
    }
}

那么你可以称它为

Bootstrap.INSTANCE.getBootstrap().initialize(this);

这样，您就可以在 class 中共享该组件。我个人将 Bootstrap 命名为 injector，将 _Bootstrap 命名为 ApplicationComponent，所以它看起来像这样：

Injector.INSTANCE.getApplicationComponent().inject(this);

但这只是我的典型设置。名字并不重要。

编辑：对于你的最后一个问题，你可以通过子范围和组件依赖来解决这个问题。

您的库项目应该只能看到 classes 库，对吗？在那种情况下，你所做的就是

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

@Component(modules={LibraryModule.class})
@LibraryScope
public interface LibraryComponent {
    LibraryClass libraryClass(); //provision method for `MyManager`
}

@Module
public class LibraryModule {
    @LibraryScope
    @Provides
    public LibraryClass libraryClass() { //in your example, LibraryClass is `MyManager`
        return new LibraryClass(); //this is instantiation of `MyManager`
    }
}

public enum LibraryBootstrap {
    INSTANCE;

    private LibraryComponent libraryComponent;

    static {
        INSTANCE.libraryComponent = DaggerLibraryComponent.create();
    }

    public LibraryComponent getLibraryComponent() {
        return libraryComponent;
    }
}

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

@Component(dependencies={LibraryComponent.class}, modules={AdditionalAppModule.class})
@ApplicationScope
public interface ApplicationComponent extends LibraryComponent {
    AdditionalAppClass additionalAppClass();

    void inject(InjectableAppClass1 injectableAppClass1);
    void inject(InjectableAppClass2 injectableAppClass2);
    void inject(InjectableAppClass3 injectableAppClass3);
}

@Module
public class AdditionalAppModule {
    @ApplicationScope
    @Provides
    public AdditionalAppClass additionalAppClass() { //something your app shares as a dependency, and not the library
        return new AdditionalAppClass();
    }
}

public enum ApplicationBootstrap {
    INSTANCE;

    private ApplicationComponent applicationComponent;

    void setup() {
        this.applicationComponent = DaggerApplicationComponent.builder()
                                        .libraryComponent(LibraryBootstrap.INSTANCE.getLibraryComponent())
                                        .build();
    }

    public ApplicationComponent getApplicationComponent() {
        return applicationComponent;
    }
}

然后

@Inject
LibraryClass libraryClass; //MyManager myManager;

...
    ApplicationBootstrap.INSTANCE.getApplicationComponent().inject(this);

Android 上的 Dagger 2 @Singleton 注释 class 未被注入

Dagger 2 on Android @Singleton annotated class not being injected

java

android

dagger

dagger-2