如何使用Dagger2（2.15）在Android模块间注入依赖

我来给你梳理一下在多模块Android项目里用Dagger 2.15实现这些注入需求的具体方案，步骤清晰且符合Dagger的最佳实践：

一、全局依赖配置 #

首先，所有需要使用Dagger的模块都要添加依赖。在每个模块的build.gradle中加入以下配置：

Android模块（Main App、Module A/B/D） #

dependencies {
    implementation 'com.google.dagger:dagger:2.15'
    annotationProcessor 'com.google.dagger:dagger-compiler:2.15'
}

Java模块（Module C） #

dependencies {
    implementation 'com.google.dagger:dagger:2.15'
    annotationProcessor 'com.google.dagger:dagger-compiler:2.15'
}

二、分模块实现Dagger组件与模块 #

1. Java Module C（纯Java模块，提供实例给Main App） #

因为是纯Java模块，无需Android相关组件，直接创建Dagger Module提供实例：

@Module
public class ModuleC {
    // 用@Singleton保证全局单例，若不需要可替换为自定义Scope
    @Provides
    @Singleton
    public C provideCInstance() {
        return new C(); // C为你的目标类
    }
}

2. Android Module B（提供实例给Module A） #

Module B需要暴露自身实例给Module A，所以要创建对应的Module和Component：

Step 1: 提供实例的Module

@Module
public class ModuleB {
    // 这里用@PerActivity作为示例Scope，你也可以自定义@PerModuleB
    @Provides
    @PerActivity
    public B provideBInstance() {
        return new B(); // B为你的目标类
    }
}

Step 2: 暴露实例的Component接口

// Scope必须与Module中的Scope一致
@PerActivity
@Component(modules = ModuleB.class)
public interface BComponent {
    // 暴露B实例，让依赖此Component的其他组件能获取
    B getB();
}

3. Android Module A（注入Module B，同时暴露给Main App） #

Module A的Component需要依赖BComponent，同时提供自身实例给Main App：

Step 1: 提供A实例的Module（依赖B）

@Module
public class ModuleA {
    @Provides
    @Singleton
    public A provideAInstance(B b) {
        // Dagger会自动从BComponent获取B实例注入
        return new A(b); // A为你的目标类，构造方法传入B
    }
}

Step 2: 关联BComponent并暴露A的Component

@Singleton
@Component(modules = ModuleA.class, dependencies = BComponent.class)
public interface AComponent {
    // 暴露A实例给Main App的Component
    A getA();
}

4. Android Module D（提供实例给Main App） #

类似Module B，创建Module和Component暴露实例：

@Module
public class ModuleD {
    @Provides
    @Singleton
    public D provideDInstance() {
        return new D(); // D为你的目标类
    }
}

@Singleton
@Component(modules = ModuleD.class)
public interface DComponent {
    // 暴露D实例给Main App
    D getD();
}

5. Main App模块（注入A、C、D） #

Main App的Component需要整合所有依赖的组件/模块，并完成注入：

Step 1: 全局AppComponent

@Singleton
@Component(modules = ModuleC.class, dependencies = {AComponent.class, DComponent.class})
public interface AppComponent {
    // 定义注入目标：比如Application、MainActivity
    void inject(MyApplication application);
    void inject(MainActivity mainActivity);
}

Step 2: 在Application中初始化所有组件

public class MyApplication extends Application {
    private AppComponent appComponent;

    @Override
    public void onCreate() {
        super.onCreate();
        // 初始化顺序：先初始化被依赖的组件，再初始化依赖它的组件
        BComponent bComponent = DaggerBComponent.create();
        AComponent aComponent = DaggerAComponent.builder()
                .bComponent(bComponent)
                .build();
        DComponent dComponent = DaggerDComponent.create();
        
        // 构建最终的AppComponent
        appComponent = DaggerAppComponent.builder()
                .aComponent(aComponent)
                .dComponent(dComponent)
                .build();
    }

    public AppComponent getAppComponent() {
        return appComponent;
    }
}

Step 3: 在MainActivity中完成注入

public class MainActivity extends AppCompatActivity {
    // 声明需要注入的实例
    @Inject
    A moduleA;
    @Inject
    C moduleC;
    @Inject
    D moduleD;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        // 执行注入
        ((MyApplication) getApplicationContext()).getAppComponent().inject(this);
        
        // 现在可以直接使用moduleA、moduleC、moduleD了
    }
}

三、关键注意事项 #

• Scope匹配：Component的Scope必须与Module中@Provides方法的Scope一致，否则Dagger会抛出编译错误。
• 模块依赖顺序：在项目的build.gradle中要正确配置模块间的依赖：

  // Main App的build.gradle
  implementation project(':moduleA')
  implementation project(':moduleC')
  implementation project(':moduleD')
  
  // Module A的build.gradle
  implementation project(':moduleB')
  

• 组件暴露规则：只有在Component中显式声明的实例（如getB()、getA()）才能被其他依赖的Component获取，否则无法注入。

内容的提问来源于stack exchange，提问作者Hector