Android @Singleton注释类上的Dagger 2未注入

Question

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

• 图书馆
• 应用（取决于库）

在我的库项目中，我定义了一个类，稍后将其插入到库以及应用程序项目中的其他需要该类的类（活动和常规类）中。

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

现在-例如在我的“片段”或“活动”或常规类中，我将上述Singleton注入如下：

public class SomeClass{

  @Inject
  MyManager myManager;
}

大概我想，因为实际上myManager始终为null。显然，它的构造函数也从未被调用过，所以我想我一定缺少配置方面的东西吗？还是我误解了文档，这根本不是要这样工作吗？MyManager类的目的是成为应用程序范围内可访问的组件累积实体-
这就是为什么我选择@Singleton。

更新

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

当我开始添加@Component时，由于我的dagger2安装不正确，我遇到了一些编译器问题-
请查看有关如何正确设置dagger2的非常有用的线程：http://codingdict.com/questions/117438

更新2

这是我根据G. Lombard的建议更新的代码-我将代码更改如下-原始Singleton在库项目中：

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

引导项目类也在库项目中：

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

然后，在活动中使用上述Bootstrap类（在我的具体应用中， 不在
库项目中！在库中也有类/活动，这些类/活动将访问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);

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

如果我没看错的话，那意味着我需要在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多个类之一，似乎没有编译时检查？它只是行不通-即在运行时崩溃应用程序。

Answer 1

您正在使用中而犯了一个错误

DaggerBootstrap.create().initialize(this);

在您的活动中，因为范围不在多个组件实例之间共享。我建议使用自定义应用程序类

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

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

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

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

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