Android @Singleton注释类中的Dagger 2没有被注入

时间：2015-07-14 21:33:20

标签： java android dagger dagger-2

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

  • 文库
  • app（取决于图书馆）

在我的库项目中，我定义了一个类，我稍后会在库中以及app项目中注入需要它的其他类（活动和常规类）。

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

现在 - 例如在我的片段或活动或常规课程中，我按如下方式注入上述单身人士：

public class SomeClass{

  @Inject
  MyManager myManager;
}

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

更新

为了避免混淆：我在评论中提到了我的组件，我认为 - 这是指基于组件的设计意义上的组件＆＃34;与匕首毫无关系。我上面列出了基于匕首的代码 - 我的代码中没有任何与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);
}

然后我在我的活动中使用上面的Bootstrap类（在我的具体应用中，在库项目中 NOT ！但是我也在库中有类/活动，可以访问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);

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

我刚发现：https://stackoverflow.com/a/29326023/1041533

如果我没有误读，这意味着我需要在Bootstrap类中指定将使用@Inject注入内容的每个类。可悲的是 - 这不是一个选择，因为我有超过40个课程和活动，我必须这样做。

这意味着我的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多个课程之一，似乎没有编译时检查？它不会工作 - 即在运行时崩溃应用程序。

2 个答案:

答案 0 :(得分：10)

你正在使用

犯错误 
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);

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

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

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

编辑：对于你的上一个问题，你可以通过subscoping和组件依赖来解决这个问题。

您的图书馆项目应该只能看到图书馆类，对吗？在这种情况下，你所做的只是

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

答案 1 :(得分：7)

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

假设这个逻辑结构：

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

然后列出的类将正确注入以下配置：

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

以及将依赖项注入活动的应用程序级组件：

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

请注意，MainComponent取决于LibraryComponent，但由于后者具有单一范围，因此您需要为另一个范围定义范围，我使用的是＆＃34;活动范围＆ ＃34;这里。 （或者您也可以将MainComponent设置为单例，并在符合您需要的情况下完全删除LibraryComponent。）

最后，所有人都注入了这样的活动：

@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：

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

在这种情况下，你的MyManager没有被注入的原因是因为Dagger不知道如何提供/实例化依赖关系。这就是＆＃34;组件＆＃34;进来，我上面提到过。如果没有任何Dagger 2组件（用@Component注释的接口或抽象类），您的依赖项将不会自动注入。

我不知道您是否具有依赖注入概念的经验，但假设您没有，我将逐步完成您需要了解的最低基础知识以获取您的{ {1}}已注入MyManager：

首先：当你使用DI时，你需要了解＆＃34; newables＆＃34;和＃34;注射剂＆＃34;。 Misko Hevery的This blogpost解释了细节。

这意味着，您无法SomeClass提升您的new。这不会起作用：

SomeClass

因为如果你这样做（比如在一个活动或片段中），Dagger就不会想到你想要一个依赖注入mSomeClass = new SomeClass(); 并且它没有机会注入任何东西。

为了注入依赖项，你必须通过Dagger实例化（或注入）SomeClass本身。

换句话说，在您使用SomeClass的活动中，您需要：

SomeClass

接下来，您需要一个Dagger组件来执行实际注射。要创建组件，可以使用将根对象（例如@Inject SomeClass mSomeClass; ）作为参数的方法创建一个接口，例如：

MainActivity

现在，当您构建项目时，Dagger 2会生成一个名为@Singleton @Component public interface Bootstrap { void initialize(MainActivity activity); } 的类来实现此接口。您可以使用此生成的类来执行注入，例如在您的活动中创建：

DaggerBootstrap

我相信这个生成的组件是您错过的关键部分。以上here的完整代码。

一些有用的Dagger 2资源：

更新2：

似乎拼图的最后一个缺失部分是你的组件为@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); DaggerBootstrap.create().initialize(this); mSomeClass.doSomething(); } 基类提供了一个注入方法，但不是你实际的具体活动。

不幸的是，Dagger 2需要为每个活动或您要注入的其他类注入方法。

正如您所提到的，当您的应用中有许多不同的活动时，这会很烦人。有一些可行的解决方法，搜索＆＃34; dagger 2注入基类＆＃34;，例如@EpicPandaForce的这个建议：Dagger 2 base class injections

另请注意，正如@EpicPandaForce在评论中指出的那样，在我的简单示例中，我每次调用Activity都可能不是您想要的，因为该组件应该提供您的单身，所以您和＃39;最好从其他地方获取现有实例，例如从Application实例获取。

相关问题
最新问题