java - Android 上的 Dagger 2 @Singleton 注释类未被注入(inject)

Question

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

• 图书馆
• 应用程序(取决于图书馆)

在我的库项目中，我定义了一个类，稍后我会将其注入(inject)到库以及应用程序项目中需要它的其他类( Activity 和常规类)中。

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

现在 - 例如在我的 Fragments 或 Activity 或常规类中，我将按如下方式注入(inject)上述 Singleton:

public class SomeClass{

  @Inject
  MyManager myManager;
}

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

更新

为避免混淆:我认为我在评论中的某处提到了我的组件 - 这是指“基于组件的设计”意义上的组件，与 Dagger 无关。我拥有的基于 Dagger 的代码都在上面列出 - 我的代码中没有其他与 Dagger 相关的内容。

当我开始添加 @Component 时，我遇到了一些编译器问题，因为我的 dagger2 没有正确设置 - 查看这个关于如何正确设置 dagger2 的非常有用的线程:https://stackoverflow.com/a/29943394/1041533

更新 2

这是我根据 G. Lombard 的建议更新的代码 - 我按如下方式更改了代码 - 原始的 Singleton 在库项目中:

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

库项目中还有 Bootstrap 类:

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

然后我在我的 Activity 中使用上面的 Bootstrap 类(在我的具体应用程序中，不在库项目中!但是我在库中也有类/Activity ，它们将访问 Bootstrap 以注入(inject)我的经理):

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);

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

我刚找到这个:https://stackoverflow.com/a/29326023/1041533

如果我没看错的话，这意味着我需要指定 Bootstrap 类中的每个类，这些类将使用 @Inject 来注入(inject)内容。遗憾的是——这不是一个选择，因为我有 40 多个类(class)和 Activity 需要这样做。

这意味着我的 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 多个类之一？它只是行不通 - 即在运行时使应用程序崩溃。

Answer 1

你在使用时犯了一个错误

DaggerBootstrap.create().initialize(this);

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

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);

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

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

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

@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);