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：

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

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

2018-12-12 17:57:50.287 30809-30809/io.github.yuweiguocn.dagger D/debug: 1io.github.yuweiguocn.dagger.test.Student@be59fd92018-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等。
如果是通过在构造方法添加@Inject注解这种方法提供的实例，可以在对应类上添加@Scope注解管理依赖的生命周期，例如：

@Singletonpublic class Student extends People {    @Inject
    public Student() {
    }    @Override
    String doWhat() {        return "study";
    }
}

注解@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@Componentpublic interface PeopleComponent {    StuComponent student();    WorkerComponent worker();    @Component.Builder    interface Builder{        PeopleComponent build();        @BindsInstance
        Builder application(Application application);
    }
}

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

@Modulepublic abstract class StuModule {    @Binds
    @ActivityScope
    abstract People bindStudent(Student student);
}@Modulepublic 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().worker().inject(this);
        Log.d("debug", worker.doWhat());
    }
}

总结

• 可以使用注解@Scope管理依赖的生命周期，@Scope的默认实现是@Singleton，可以在Component中保持单例，需要在Component上和提供实例的方法上同时添加注解才会起作用。原理是通过DoubleCheck类保证了实例的唯一。通常使用多个@Scope时会根据实例生命周期自定义，如：AppScope、ActivityScope、FragmentScope等。

• 通过在构造方法添加@Inject注解提供实例的，可以在对应类上添加@Scope注解管理依赖生命周期。

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

• 子组件Subcomponent不能和父组件使用相同的@Scope注解，子组件的生命周期严格小于父组件的生命周期，兄弟组件可以使用相同的@Scope注解（但实际上具有不同生命周期的实例）。

作者：于卫国
链接：https://www.jianshu.com/p/3989aa7800a4