Dagger 2 在 Android 上的使用（五）

2019-01-19

本文介绍了Dagger 2 中@Scope和@Subcomponent的使用。

《清明》
清明时节雨纷纷，路上行人欲断魂。
借问酒家何处有，牧童遥指杏花村。
-唐，杜牧

Dagger 2 在 Android 上的使用（一）
Dagger 2 在 Android 上的使用（二）
Dagger 2 在 Android 上的使用（三）
Dagger 2 在 Android 上的使用（四）
Dagger 2 在 Android 上的使用（五）

生命周期

我们可以使用注解@Scope来管理依赖的生命周期。它和注解@Qualifier一样是用来自定义注解的，注解@Scope的默认实现是@Singleton，用于在Component实例中保持单例。如果我们在Application类中持有Component的引用，就实现了应用内保持单例。注意需要在Component上和提供实例的方法上同时添加@Scope注解才会起作用。接下来看一个使用的例子：

首先需要在Component类添加注解@Singleton：

@Singleton
@Component(modules = PeopleModule.class)
public interface PeopleComponent {

    void inject(PeopleActivity activity);

}

然后在Module类提供实例的方法上也需要添加注解@Singleton：

@Module
public abstract class PeopleModule {

    @Binds
    @Study
    @Singleton
    abstract People bindStudent(Student student);

}

在Activity中同时注入两个成员变量：

public class PeopleActivity extends Activity {

    @Inject
    @Study
    People student;

    @Inject
    @Study
    People student2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        DaggerPeopleComponent.create().inject(this);
        Log.d("debug", student.toString());
        Log.d("debug", student2.toString());
    }
}

可以看到注入了两个变量，是同一个实例，打印日志输出：

1
2

2018-12-12 17:57:50.287 30809-30809/io.github.yuweiguocn.dagger D/debug: 1io.github.yuweiguocn.dagger.test.Student@be59fd9
2018-12-12 17:57:50.287 30809-30809/io.github.yuweiguocn.dagger D/debug: 2io.github.yuweiguocn.dagger.test.Student@be59fd9

生成的代码：

public final class DaggerPeopleComponent implements PeopleComponent {
  private Provider<People> bindStudentProvider;

  private DaggerPeopleComponent(Builder builder) {
    initialize(builder);
  }
  ...

  @SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {
    this.bindStudentProvider = DoubleCheck.provider((Provider) Student_Factory.create());
  }
  ...

  private PeopleActivity injectPeopleActivity(PeopleActivity instance) {
    PeopleActivity_MembersInjector.injectStudent(instance, bindStudentProvider.get());
    PeopleActivity_MembersInjector.injectStudent2(instance, bindStudentProvider.get());
    return instance;
  }
  ...
}

这里和Lazy注入一样，都是使用DoubleCheck类保证了实例的唯一。
通常我们会根据实例的生命周期自定义Scope，例如：ApplicationScope、ActivityScope和FragmentScope等。

注解@Subcomponent

Component类只能应用一个@Scope注解，如果我们想使用多个@Scope注解时，可以使用@SubComponent实现，使用Subcomponent的另一原因是用于拆分层级。

首先自定义两个Scope：

@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface AppScope {
}

@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface ActivityScope {
}

然后使用@Subcomponent注解定义两个子组件，添加自定义的@ActivityScope注解，指定Module类，提供Activity的注入方法：

@ActivityScope
@Subcomponent(modules = WorkerModule.class)
public interface WorkerComponent {
    void inject(WorkerActivity activity);
}

@ActivityScope
@Subcomponent(modules = StuModule.class)
public interface StuComponent {
    void inject(StuActivity activity);
}

在父组件中暴露子组件，添加自定义的@AppScope注解，注意子组件不能与父组件应用相同的@Scope注解，子组件的生命周期严格小于父组件的生命周期，兄弟组件可以使用相同的@Scope注解（但实际上具有不同的生命周期实例）：

@AppScope
@Component
public interface PeopleComponent {

    StuComponent student();

    WorkerComponent teacher();

    @Component.Builder
    interface Builder{
        PeopleComponent build();

        @BindsInstance
        Builder application(Application application);
    }
}

在子组件指定的Module中提供实例的方法上添加自定义的@ActivityScope注解：

@Module
public abstract class StuModule {

    @Binds
    @ActivityScope
    abstract People bindStudent(Student student);
}

@Module
public abstract class WorkerModule {

    @Binds
    @ActivityScope
    abstract People bindWroker(Worker worker);
}

在子组件指定的Module提供的实例添加对父组件提供实例的依赖：

public class Student extends People {

    private Application app;

    @Inject
    public Student(Application app) {
        this.app = app;
    }

    @Override
    String doWhat() {
        return "study app: " + app.toString();
    }
}

public class Worker extends People {

    private Application app;

    @Inject
    public Worker(Application app) {
        this.app = app;
    }

    @Override
    String doWhat() {
        return "work app: " + app.toString();
    }
}

在Application中构建父组件：

public class App extends Application {

    private static App app;
    private PeopleComponent component;

    @Override
    public void onCreate() {
        super.onCreate();
        app = this;
        component = DaggerPeopleComponent.builder().application(this).build();
    }

    public static App getApp() {
        return app;
    }

    public PeopleComponent getComponent() {
        return component;
    }
}

最后在Activity中使用Application构建的父组件中提供的子组件进行注入：

public class StuActivity extends Activity {

    @Inject
    Student student;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        App.getApp().getComponent().student().inject(this);
        Log.d("debug", student.doWhat());
    }
}

public class WorkerActivity extends AppCompatActivity {

    @Inject
    Worker worker;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        App.getApp().getComponent().teacher().inject(this);
        Log.d("debug", worker.doWhat());
    }
}

总结

可以使用注解@Scope管理依赖的生命周期，@Scope的默认实现是@Singleton，可以在Component中保持单例，需要在Component上和提供实例的方法上同时添加注解才会起作用。原理是通过DoubleCheck类保证了实例的唯一。通常使用多个@Scope时会根据实例生命周期自定义，如：AppScope、ActivityScope、FragmentScope等。
Component类只能应用一个@Scope注解，如果需要使用多个@Scope，可以使用@Subcomponent实现，使用@Subcomponent的另一原因是用于拆分层级。
子组件Subcomponent不能和父组件使用相同的@Scope注解，子组件的生命周期严格小于父组件的生命周期，兄弟组件可以使用相同的@Scope注解（但实际上具有不同生命周期的实例）。

于卫国

Dagger 2 在 Android 上的使用（五）

生命周期

注解@Subcomponent

总结

参考