Dagger2 @Component 和@SubComponent 区别解惑

前言

当前很多blog和技术网站，很多文章都在讲Dagger2 的使用，一般都是在Application中生成一个AppComponent，然后其他的功能模块的Component依赖于AppComponent，但是有些文章中使用的方式是@Component(modules = PreseterModule.class, dependencies = AppComponent.class)，也有使用@Subcomponent(modules = PreseterModule.class)方式提供Component的，那么两者之间有什么明显区别？本文就来详细解释一下。

Module 代码

AppModule.java

@Module
public class AppModule {
    @Provides
    public SomeClassA1 provideSomeClassA1() {
        return new SomeClassA1();
    }

    @Provides
    public SomeHideClassA1 provideSomeHideClassA1() {
        return new SomeHideClassA1();
    }
}

PresenterModule.java

@Module
public class PresenterModule {
    @Provides
    public SomeClassB1 provideSomeClassB1(SomeClassA1 someClassA1) {
        // SomeClassB1 依赖 SomeClassA1
        return new SomeClassB1(someClassA1);
    }
}

provider 提供的实际类

public class SomeClassA1 {
    public SomeClassA1() {}
}

public class SomeHideClassA1 {
    public SomeHideClassA1() {}
}

public class SomeClassB1 {
    private SomeClassA1 someClassA1;

    public SomeClassB1(SomeClassA1 someClassA1) {
        this.someClassA1 = someClassA1;
    }
}

@Component 方式

AppComponent.java

@Component(modules = AppModule.class)
public interface AppComponent {
      //将AppModule中的SomeClassA1暴露出来，以便于其他依赖于AppComponent的Component调用
      SomeClassA1 someClassA1();
}

PresenterComponent.java

    @Component(modules = PresenterModule.class, dependencies = AppComponent.class)
    public interface PresenterComponent {
        void inject(UseDagger userDagger);
    }

使用

public class UseDagger {
  @Inject
  SomeClassA1 classA1;

  @Inject
  SomeClassB1 classB1;

  //无法编译通过，因为SomeHideClassA1 在AppComponent 中没有显示的
  //@Inject
  //SomeHideClassA1 hideClassA1;

  public static void main(String[] args) {
        AppModule AppModule = new AppModule();
        AppComponent AppComponent = DaggerAppComponent.builder()
                .AppModule(AppModule)
                .build();

        PreseterModule PreseterModule = new PreseterModule();
        PresenterComponent PresenterComponent = DaggerPresenterComponent.builder()
                .AppComponent(AppComponent)
                .PreseterModule(PreseterModule)
                .inject(this);
        System.out.println("classA1 is -->" + classA1);
        System.out.println("classB1 is -->" + classB1);
    }
}

这种Component依赖方案

优势

1. 可以很清晰的看到PresenterComponent生成时依赖于AppComponent
2. 有两个独立的DaggerXXXXComponent类

需注意

1. 依赖Component(PresenterComponent) 仅继承 被依赖Component(AppComponent) 中显示提供的依赖，如果不提供，则无法使用@Inject注入被依赖的Component(AppComponent)中的对象

看图说话更明白

@SubComponent

AppComponent.java

@Component(modules = AppModule.class)
public interface AppComponent {
    //需要将SubComponent 追加到 被依赖的Component中
    PresenterComponent addSub(PresenterModule PresenterModule);
}

PresenterComponent.java

@Subcomponent(modules = PresenterModule.class)
public interface PresenterComponent {
    void inject(UserDagger userDagger);
}

使用

public class UseDagger {
  @Inject
  SomeClassA1 classA1;

  @Inject
  SomeClassB1 classB1;

  //可以直接注入，不会报错
  @Inject
  SomeHideClassA1 hideClassA1;

  public static void main(String[] args) {
         AppModule appModule = new AppModule();
         PresenterModule presenterModule = new PresenterModule();
         AppComponent appComponent = DaggerAppComponent.builder()
                 .AppModule(appModule)
                 .build();

         PresenterComponent PresenterComponent = appComponent.addSub(PresenterModule).inject(this);
        }
}

这种Component依赖方案

优势

1. 不需要在被依赖的Component显示提供依赖
2. 不需要使用更多的DaggerXXXXComponent对象来创建依赖，仅需要在被依赖Component中增加 XXXComponent addSub(XXXModule) 方法

看图说话更明白

Scope

关于Scope的问题，也是@Component dependencies 和 @SubComponent最值得关注的区别。
1、两个拥有依赖关系的 Component 是不能有相同 @Scope 注解的！使用@SubComponent 则可以使用相同的@Scope注解。 （很重要！！！！）

需注意

1. 依赖不明确，需要查询被依赖Component
2. 多人开发，被依赖Component容易造成冲突
3. 务必在被依赖Component中创建XXXComponent addSub(XXXModule) 方法，并在被依赖Component的DaggerXXXComponent的实例化对象中调用addSub方法，将被依赖Component转化为依赖Component
4. SubComponent 完全继承Component中的全部依赖