Dagger2 - 生成的组件类中的“未使用”模块

Question

我的 Dagger2 组件类包含 3 个模块，我试图使用这些模块将字段依赖项注入到 Android Activity 类中。生成的组件文件有 cmets 表示所有模块都未使用，链接此page 以获取更多信息。

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

我的代码如下，谢谢帮助！

生成的组件类：

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

活动类：

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：为什么我的模块被标记为“未使用”？

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

void inject(Activity activity);

到：

void inject(MyActivity myActivity);

问题 2：

让一个模块提供的对象依赖于属于同一组件的另一个模块提供的另一个对象有什么问题吗？

不，这很好。为了说明，我们来看一个简单的对象图：

public class Foo {

    public Foo(FooDependency fooDependency) {}
}

public class FooDependency {

    FooDependency(String name) {}
}

我们想使用 Dagger 将其注入到以下类中：

public class FooConsumer {

    @Inject Foo foo;

    private FooConsumer() {}
}

我们想重用模块绑定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");
    }
}

还有如下组件接口：

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

生成的组件DaggerFooComponent包含以下代码，这些代码将正确使用来自单独模块FooDependencyModule的FooDependency注入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);
  }