Dagger2 - 生成的组件类中的“未使用”模块-Java 学习之路

我的Dagger2 Component类包含3个模块，我试图用它们将字段依赖项注入到Android Activity类中 . 生成的Component文件包含所有模块未使用的注释，链接此page以获取更多信息 .

我的Activity类正在调用Component的inject（Activity）方法，并且模块提供了注释用于注入的字段，因此我不确定为什么生成的Component文件没有任何Providers来执行此注入 .

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

Generated Component Class:

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

Non-Generated Component Class ：

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

Module Classes ：让一个模块提供一个对象依赖于属于同一个Component的另一个模块提供的另一个对象是否有任何问题？

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

}

Application Class:

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 Class:

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

1 回答

Question 1: 为什么我的模块被标记为"unused"？

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

void inject(Activity activity);

至：

void inject(MyActivity myActivity);

Question 2:

让一个模块提供一个对象，该对象依赖于属于同一个Component的另一个模块提供的另一个对象，是否存在任何问题？

不，这完全没问题 . 为了说明，我们来看一个简单的对象图：

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

回复于 2024-05-13T09:49:56+08:00

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

1 回答

相关问题