Dagger2 使用全解析
Dagger是一个注入工具，何为注入，我们要生产一批机器人，每个机器人都有一个控制器，我们可以在机器人内部 new 出一个控制器：
class Robot {
val controller = Controller()
}上面的代码 Robot 和 Controller 耦合，修改一下上面的代码，从外部传入控制器，这就叫注入：
class Robot(val controller: Controller)这样做的好处就是修改了控制器，但是不用修改机器人的代码，一般情况下，我们需要把控制器声明为接口，这样一个机器人就可以兼容不同的控制器
interface Controller {
fun move()
fun stop()
}
class BasicController : Controller {
override fun move() {
// ...
}
override fun stop() {
// ...
}
}
class AdvancedController : Controller {
override fun move() {
// ...
}
override fun stop() {
// ..
}
}
class Robot(val controller: Controller)
fun createRobot(controller: Controller) = Robot(controller)
fun test() {
val basicRobot = createRobot(BasicController())
val advancedRobot = createRobot(AdvancedController())
}上面的代码就是精简版的Dagger，当然结构天差地别，但是思路差不多，下面开始讲Dagger。
Dagger是个注入框架，帮助我们来实现注入的功能，拿上面的例子来说，我们写好了 Robot 和 各种 Controller 的代码，Dagger 帮我们将他们联系起来，也就是实现函数 createRobot 的功能。
Dagger2 的功能是通过编译器生成中间代码来实现的，编译器可以为我们生成代码，但是要生成什么代码是需要我们指定的，拿上面的例子来说，我们需要为 Robot 注入一个 Controller，我们需要指定：
- Controller 的构造方法
- 需要注入的成员变量
- 在什么地方注入
未使用 Dagger 之前，代码是这样的：
class Controller
class Robot(val controller: Controller)
// ...
val controller = Controller()
val robot = Robot(controller)现在我们来改写代码，首先要指定 Controller 的构造方法，在 Controller 的构造函数添加 @Inject 注解：
class Controller @Inject constructor()指定需要注入的变量
class Robot {
@Inject lateinit var controller: Controller
} 现在编译一下，等待 Dagger 生成中间代码，Dagger为我们生成以下的代码：
Controller_Factory.java
public final class Controller_Factory implements Factory<Controller> {
private static final Controller_Factory INSTANCE = new Controller_Factory();
@Override
public Controller get() {
return new Controller();
}
public static Factory<Controller> create() {
return INSTANCE;
}
}Robot_MembersInjector.java
public final class Robot_MembersInjector implements MembersInjector<Robot> {
private final Provider<Controller> controllerProvider;
public Robot_MembersInjector(Provider<Controller> controllerProvider) {
assert controllerProvider != null;
this.controllerProvider = controllerProvider;
}
public static MembersInjector<Robot> create(Provider<Controller> controllerProvider) {
return new Robot_MembersInjector(controllerProvider);
}
@Override
public void injectMembers(Robot instance) {
if (instance == null) {
throw new NullPointerException("Cannot inject members into a null reference");
}
instance.controller = controllerProvider.get();
}
}非常好，Dagger 为我们生成了一个 Controller 的构造类 Controller_Factory，我们可以通过
Controller_Factory.create()获取一个单例的 Controller 对象，或者通过：
Controller_Factory().get()
// or
Controller_Factory.create().get()创建一个新的 Controller 对象，如果要注入到 Robot，需要使用 Robot_MembersInjector 的 injectMembers 的函数，改造后的最终代码是
class Controller @Inject constructor()
class Robot {
@Inject lateinit var controller: Controller
constructor() {
val factory = Controller_Factory.create()
val injector = Robot_MembersInjector.create(factory)
injector.injectMembers(this)
}
}现在添加一个注入的成员变量 power：
class Controller @Inject constructor()
class Power @Inject constructor()
class Robot {
@Inject lateinit var controller: Controller
@Inject lateinit var power: Power
constructor() {
val controllerFactory = Controller_Factory.create()
val powerFactory = Power_Factory.create()
val injector = Robot_MembersInjector.create(controllerFactory, powerFactory)
injector.injectMembers(this)
}
}这时应该祭出 Componet 了，我们来声明一个 AppComponet：
@Component
interface AppComponent {
fun inject(robot: Robot)
}然后使用 Component 来注入变量，Dagger 会根据 AppComponent 生成一个 DaggerAppComponent：
class Robot {
@Inject lateinit var controller: Controller
@Inject lateinit var power: Power
constructor() {
DaggerAppComponent.builder().build().inject(this)
}
}我们来分析一下 DaggerAppComponent 的源码：
public final class DaggerAppComponent implements AppComponent {
private MembersInjector<Robot> robotMembersInjector;
private DaggerAppComponent(Builder builder) {
assert builder != null;
initialize(builder);
}
public static Builder builder() {
return new Builder();
}
public static AppComponent create() {
return new Builder().build();
}
@SuppressWarnings("unchecked")
private void initialize(final Builder builder) {
this.robotMembersInjector =
Robot_MembersInjector.create(Controller_Factory.create(), Power_Factory.create());
}
@Override
public void inject(Robot robot) {
robotMembersInjector.injectMembers(robot);
}
public static final class Builder {
private Builder() {}
public AppComponent build() {
return new DaggerAppComponent(this);
}
}
}DaggerAppComponent 为我们构造了 Robot_MembersInjector ，在 public void inject(Robot robot) 调用了 injectMembers 方法，如果我们把 Robot 的代码复制一遍，新建一个 Robot2 类，AppComponet 修改为：
@Component
interface AppComponent {
fun inject(robot: Robot)
fun inject(robot: Robot2)
}DaggerAppComponent 有什么变化呢？它会多一个 robot2MembersInjector 成员变量，
@SuppressWarnings("unchecked")
private void initialize(final Builder builder) {
this.robotMembersInjector =
Robot_MembersInjector.create(Controller_Factory.create(), Power_Factory.create());
this.robot2MembersInjector =
Robot2_MembersInjector.create(Controller_Factory.create(), Power_Factory.create());
}
@Override
public void inject(Robot robot) {
robotMembersInjector.injectMembers(robot);
}
@Override
public void inject(Robot2 robot) {
robot2MembersInjector.injectMembers(robot);
}同理，在 Componet 添加多个 inject，会生成对应的 MembersInjector。现在我们注入的 Power 和 Controller 是不是单例的呢？不是的。来看 Robot_MembersInjector 的 injectMembers 函数：
@Override
public void injectMembers(Robot instance) {
if (instance == null) {
throw new NullPointerException("Cannot inject members into a null reference");
}
instance.controller = controllerProvider.get();
instance.power = powerProvider.get();
}对应的 MembersInjector 的 get 方法都是 new 出一个对象。现在我们想把 Power 注入变成单例的，先加个 *@Singleton*：
@Singleton
class Power @Inject constructor()编译一下，报错了...
Error:(11, 2) 错误: com.sw926.dagger2example.AppComponent (unscoped) may not reference scoped bindings:
@dagger.Component()
^
@Singleton class com.sw926.dagger2example.PowerComponent 是连接 Provider 和 Injector 的桥梁，*@Singleton* 是作用域，不在一个域看来不让连接，那么给 Component 也加上注解：
@Singleton
@Component
interface AppComponent {
fun inject(robot: Robot)
}编译通过了，再来看 DaggerAppComponent 的源码，powerProvider 部分改变了，变成了
this.powerProvider = DoubleCheck.provider(Power_Factory.create());DoubleCheck 的源码不用贴了，作用就是能保证 Provider get 的时候返回的是单例，而且是安全的，而是是懒加载的，很完美。
作为一个严谨的程序，一个 Power 哪里够用，我们需要一个备用的，也就是说，需要两个单例的 Power，现在 Module 要登场了。Module 是构造方法的仓库，我们把 Power 的注解去掉，改为在 Module 中提供构造方法，然后在 Component 中指定 Module
class Power
@Module
class AppModule {
@Provides
@Singleton
fun providePower() = Power()
}
@Singleton
@Component(modules = [(AppModule::class)])
interface AppComponent {
fun inject(robot: Robot)
}现在添加一个 BackUp Power
class Power(val name: String)
// 添加一个 BackUp 注解
@Qualifier
@Documented
@Retention(RUNTIME)
public @interface BackUp {
}
// ...
@Module
class AppModule {
@Singleton
@Provides
fun providePower(): Power = Power("main")
@BackUp
@Singleton
@Provides
fun provideBackUpPower(): Power = Power("backup")
}
class Robot {
@Inject lateinit var controller: Controller
@Inject lateinit var power: Power
@field:[Inject BackUp] lateinit var backUpPower: Power
constructor() {
DaggerAppComponent.builder().build().inject(this)
}
}在注入 Power的时候，默认是 main, 如果添加了 @BackUp 注解，就是 backup，Robot_MembersInjector 会有三个 Provider
@Override
public void injectMembers(Robot instance) {
if (instance == null) {
throw new NullPointerException("Cannot inject members into a null reference");
}
instance.controller = controllerProvider.get();
instance.power = powerProvider.get();
instance.backUpPower = backUpPowerProvider.get();
}是时候来验证一下是否是单例了，我们来创建两个 Robot ，看他们的 Power 和 BackUpPower 是否一样：
val robot1 = Robot()
val robot2 = Robot()
Log.d("Dagger2Test", "robot1 :(${robot1.power}, ${robot1.backUpPower}), \nrobot2: (${robot2.power}, ${robot2.backUpPower}")运行结果
robot1 :(com.sw926.dagger2example.Power@5f1ad48, com.sw926.dagger2example.Power@862e7e1),
robot2: (com.sw926.dagger2example.Power@dc97906, com.sw926.dagger2example.Power@24c8bc7说好的单例呢，怎么能骗人呢？大神们当然不会骗人，那肯定是我们的使用方式不对了，我们再来看看代码：
@Singleton
@Provides
fun providePower(): Power = Power("main")
// ...
@Singleton
@Component(modules = [(AppModule::class)])
interface AppComponent {
fun inject(robot: Robot)
}我们把注入分为三个部分：
- 提供者（Provider）
- 接受者，Robot 中的成员变量 power
- 提供者和接受者直接的桥梁、纽带，也就 AppComponent
Dagger 中，使用 Scope 注解的 Provider 提供的对象在作用域内唯一，这个唯一性由谁来控制呢？当然是 Component，每个 Component 只能确保自己注入时的作用域唯一，上面的例子每个 Robot 都创建了一个 AppComponent，所以注入的对象不相同，如果我们把 AppComponent 放在 Application 中创建，
那么注入的对象就是全局唯一对象了：
class App : Application() {
companion object {
lateinit var appComponent: AppComponent
}
override fun onCreate() {
super.onCreate()
appComponent = DaggerAppComponent.builder().build()
}
}
// ...
class Robot {
@Inject lateinit var controller: Controller
@Inject lateinit var power: Power
@field:[Inject BackUp] lateinit var backUpPower: Power
constructor() {
App.appComponent.inject(this)
}
}运行结果
robot1 :(com.sw926.dagger2example.Power@862e7e1, com.sw926.dagger2example.Power@dc97906),
robot2: (com.sw926.dagger2example.Power@862e7e1, com.sw926.dagger2example.Power@dc97906如果同一个作用域内希望获取两个 Power，那么必须要起个名字区分一下，Qualifier 就是用来区别作用域内的两个对象，我们也可以用 @Named，相当于为第二个 Power起了一个名字：
@Module
class AppModule {
@Singleton
@Provides
fun providePower(): Power = Power("main")
@Named("backup")
@Provides
@Singleton
fun provideBackUpPower(): Power = Power("backup")
}
class Robot {
@Inject lateinit var controller: Controller
@Inject lateinit var power: Power
@field:[Inject Named("backup")] lateinit var backUpPower: Power
constructor() {
App.appComponent.inject(this)
}
}现在我们有了一个全局的 AppComponent，放在 Application 里面，管理 App 全局唯一的对象，现在我想有一个 Activity 生命周期的 Component，放在 每个 Activity 里面，Activity 的生命周期肯定在 App 的声明周期里面，所以 ActivityComponent 需要能够注入 AppComponent 注入的对象，现在 AppComponent 能够注入 Power BackUpPower，那么 ActivityComponent 也需要能够注入，这是需要用到 dependencies：
@ForActivity
@Component(dependencies = [(AppComponent::class)], modules = [(ActivityModule::class)])
interface ActivityComponent {
fun inject(mainActivity: MainActivity)
}我们为 ActivityComponent 设置了一个作用域 @ForActivity，ActivityComponent 依赖于 AppComponent，现在来看看这样做有什么用。
注入一个对象需要一个 Provider，Provider 有以下几种形式：
- 指定类的构造函数
kotlin class Controller @Inject constructor() - 使用 Provider 函数
kotlin @Singleton @Provides fun providePower(): Power = Power("main") - 从 dependencies 读取
前两种不用说了，来说说第三种，ActivityComponent 的 module 是 ActivityModule
@Module
class ActivityModule {
@ForActivity
@Provides
fun providePowerName(@Named("backup") power: Power): String {
return power.name
}
}在 providePowerName 需要参数 *@Named("backup") power: Power*，这个 power 哪里找？当然是 Dagger 帮我们找，Provider 的三种形式，第一种没有，ActivityModule 里面没有，AppModule 里面有，但是怎么建立连接呢，很简单，在 AppComponent 写一个函数就行
@Singleton
@Component(modules = [(AppModule::class)])
interface AppComponent {
fun inject(robot: Robot)
@Named("backup")
fun getBackUpPower(): Power
}为什么写一个函数就行，源码我也没看过，就当做这是 Dagger 的协议吧，编译后会生成对应的函数
@Override
public Power getBackUpPower() {
return provideBackUpPowerProvider.get();
}现在 ActivityComponent 的 module ActivityModule 找到了对应的 Provider，就可以正常提供 Power Name 了。
有了 AppComponent、ActivityComponent，下面就要添加 FragmentComponent了，Fragment 依赖于 Activity，那么我们这样做，FragmentComponent 只能由 ActivityComponent 创建，这就要用到 SubComponent，FragmentComponent 使用 @Subcomponent 注解，同时必须注明一个 Builder：
@ForFragment
@Subcomponent(modules = [(FragmentModule::class)])
interface FragmentComponent {
@Subcomponent.Builder
interface Builder {
fun build(): FragmentComponent
}
}ActivityComponent 改写为：
@ForActivity
@Component(dependencies = [(AppComponent::class)], modules = [(ActivityModule::class)])
interface ActivityComponent {
fun inject(mainActivity: MainActivity)
fun fragmentComponent(): FragmentComponent.Builder
}在 ActivityModule 里面指明 subcomponents ：
@Module(subcomponents = [(FragmentComponent::class)])
class ActivityModule {
@ForActivity
@Provides
fun providePowerName(@Named("backup") power: Power): String {
return power.name
}
}编译完成之后我们就可以使用 ActivityComponent 创建一个 FragmentComponent 了：
val activityComponent = DaggerActivityComponent.builder().appComponent(App.appComponent).build()
activityComponent.inject(this)
val fragmentComponent = activityComponent.fragmentComponent().build()最后说一下 Module 的 includes，也就是一个 Module 可以包含一组 Module
@Module
class ActivityModule2 {
@Provides
fun provideException(): Exception {
return Exception("test Exception ")
}
}
@Module(subcomponents = [(FragmentComponent::class)], includes = [(ActivityModule2::class)])
class ActivityModule {
@ForActivity
@Provides
fun providePowerName(@Named("backup") power: Power): String {
return power.name
}
}
class MainActivity : AppCompatActivity() {
@Inject lateinit var exception: Exception
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val activityComponent = DaggerActivityComponent.builder().appComponent(App.appComponent).build()
activityComponent.inject(this)
Log.d("Dagger2Test", "Exception: $exception")
}
}运行结果：
D/Dagger2Test: Exception: java.lang.Exception: test Exception 以上，使用 Dagger 好几年了，终于把思路理的比较清晰了，在此抛砖引玉，如果错误，欢迎指正。
