android - Dagger2 - 生成的组件类中的 "Unused"模块

Question

我的 Dagger2 组件类包含 3 个模块，我试图使用它们将字段依赖项注入(inject) Android Activity 类。生成的组件文件有注释说所有模块都未使用，链接此 page获取更多信息。

我的 Activity 类正在调用 Component 的 inject(Activity) 方法，并且具有由模块提供的注入(inject)注释字段，所以我不确定为什么生成的 Component 文件没有任何 Provider 来执行此注入(inject)。

我的代码在下面，感谢您的帮助!

生成的组件类:

public final class DaggerMainComponent implements MainComponent {
      private DaggerMainComponent(Builder builder) {
        assert builder != null;
      }

  public static Builder builder() {
    return new Builder();
  }

  public static MainComponent create() {
    return builder().build();
  }

  @Override
  public void inject(Activity activity) {
    MembersInjectors.<Activity>noOp().injectMembers(activity);
  }

  public static final class Builder {
    private Builder() {}

    public MainComponent build() {
      return new DaggerMainComponent(this);
    }

    /**
     * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://google.github.io/dagger/unused-modules.
     */
    @Deprecated
    public Builder daoModule(DaoModule daoModule) {
      Preconditions.checkNotNull(daoModule);
      return this;
    }

    /**
     * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://google.github.io/dagger/unused-modules.
     */
    @Deprecated
    public Builder repositoryModule(RepositoryModule repositoryModule) {
      Preconditions.checkNotNull(repositoryModule);
      return this;
    }

    /**
     * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://google.github.io/dagger/unused-modules.
     */
    @Deprecated
    public Builder portableModule(PortableModule portableModule) {
      Preconditions.checkNotNull(portableModule);
      return this;
    }
  }
}

非生成的组件类:

@Component(modules={DaoModule.class,RepositoryModule.class,PortableModule.class})
public interface MainComponent {
    void inject(Activity activity);
}

模块类: 让一个模块提供的对象依赖于属于同一组件的另一个模块提供的另一个对象是否有任何问题？

@Module
public class DaoModule {

    private DatabaseHelper databaseHelper;

    public DaoModule(DatabaseHelper databaseHelper){
        this.databaseHelper = databaseHelper;
    }

    @Provides
    public Dao<Player,Integer> providePlayerDao(){
        return databaseHelper.getPlayerDao();
    }

    @Provides
    public Dao<GamePlayed,Integer> provideGamePlayedDao() {
        try {
            return databaseHelper.getDao(GamePlayed.class);
        } catch (SQLException e) {
            return null;
        }
    }

    @Provides
    public Dao<GamePlayer,Integer> provideGamePlayerDao() {
        try {
            return databaseHelper.getDao(GamePlayer.class);
        } catch (SQLException e) {
            return null;
        }
    }
}

...

@Module
public class RepositoryModule {

    @Provides
    public IGameResultRepository provideGameResultRepository(
            Dao<Player,Integer> playerDao,
            Dao<GamePlayed,Integer> gameDao,
            Dao<GamePlayer, Integer> gamePlayerDao)
    {
        return new OrmliteGameResultRepository(playerDao,gameDao,gamePlayerDao);
    }
}

@Module
public class PortableModule {

    @Provides
    public GameResultListener provideGameResultListener(IGameResultRepository gameResultRepository){
        return new GameResultListener(gameResultRepository);
    }

}

应用类:

public class AppStart extends Application {

    private MainComponent mainComponent;

    @Override
    public void onCreate() {
        super.onCreate();

        DatabaseHelper databaseHelper = new DatabaseHelper(getApplicationContext());

        mainComponent = DaggerMainComponent.builder()
                .daoModule(new DaoModule(databaseHelper))
                .build();
    }

    public MainComponent getMainComponent(){
        return mainComponent;
    }
}

Activity 类:

public class MyActivity extends Activity {

    @Inject GameResultListener gameResultListener;
    @Inject Dao<Player,Integer> dao;
    @Inject IGameResultRepository repository;


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

        ((AppStart)this.getApplication()).getMainComponent().inject(this);

Answer 1

问题 1:为什么我的模块被标记为“未使用”？

您没有提供正确的注入(inject)部位!就目前而言，您的组件界面是一个具有 android.app.Activity 唯一注入(inject)站点的界面。由于 android.app.Activity 在其字段上没有 @Inject 注释，因此您将获得一个无操作成员注入(inject)器。同样，您的模块被标记为未使用，因为它们实际上都没有被用作 android.app.Activity 的依赖项来源。要解决此问题，请在您的组件中更改:

void inject(Activity activity);

到:

void inject(MyActivity myActivity);

问题 2:

Is there any issue with having one module provide an object with a dependency on another object provided by another module belonging to the same Component?

不，这完全没问题。为了说明，让我们看一个简单的对象图:

public class Foo {

    public Foo(FooDependency fooDependency) {}
}

public class FooDependency {

    FooDependency(String name) {}
}

我们想使用 Dagger 将它注入(inject)到以下类中:

public class FooConsumer {

    @Inject Foo foo;

    private FooConsumer() {}
}

我们想重用一个模块绑定(bind)FooDependency，所以我们将编写两个单独的模块:

@Module
public class FooModule {

    @Provides
    Foo foo(FooDependency fooDependency) {
        return new Foo(fooDependency);
    }
}

@Module
public class FooDependencyModule {

    @Provides
    FooDependency fooDependency() {
        return new FooDependency("name");
    }
}

以及以下组件接口(interface):

@Component(modules = {FooModule.class, FooDependencyModule.class})
public interface FooComponent {
    void inject(FooConsumer fooConsumer);
}

生成的组件 DaggerFooComponent 包含以下代码，这些代码将正确使用来自单独模块 FooDependencyModule 的 FooDependency 来注入(inject) Foo:

  @SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {

    this.fooDependencyProvider =
        FooDependencyModule_FooDependencyFactory.create(builder.fooDependencyModule);

    this.fooProvider = FooModule_FooFactory.create(builder.fooModule, fooDependencyProvider);

    this.fooConsumerMembersInjector = FooConsumer_MembersInjector.create(fooProvider);
  }