Android Dagger (一) Inject、Module、Component、使用及原理

前言

首先推荐一些文章

dagger2 相比其他框架入门成本较高，但是因业务复杂，我们还是学习下

推荐文章

Android_Dagger2篇——从小白最易上手的角度

https://www.jianshu.com/p/22c397354997/

demo

声明 inject

public class Car {
    @Inject
    Person person;

    @Inject
    public Car(){
    }

    public String go(){
        return person.getName() + " -> 这车是我的";
    }
}

声明 module

@Module
public class DemoModule {
    @Provides
    Person providePerson(){
        return new Person();
    }
}

声明 component

@Component(modules = DemoModule.class)
public interface DemoComponent {
    void inject(DemoActivity activity);
}

在 DemoActivity 使用

请先rebuild, 下面我们将会讲解原理

public class DemoActivity extends AppCompatActivity {
    @Inject
    Person person;
    @Inject
    Car car;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_demo);
        DaggerDemoComponent.create().inject(this);
        // 显示结果
        // person -> Person{name="张三",age = 13}
        // car -> 张三 -> 这车是我的
        ((TextView)findViewById(R.id.tv_content)).setText(
                "person -> " + person.toString() + "\n"
              + "car -> " + car.go()
        );
    }
}

原理分析

源码路径

app/build/generated/source/kapt

上面那些代码就完成了最基本的依赖注入，是不是觉得很神奇，那么我们先看源码分析一波

如果不看最基本的原理分析，后面的教程将会云里雾里的，至少我是~现在开始进入正题

先公布答案，因为大脑先有个蓝图

https://www.processon.com/view/link/5b6daeabe4b053a09c2f2cea

了解区别

DaggerDemoComponent.create().inject(this);
// create 方法其实内部是
new Builder().build()  // 稍微记下，后面需要理解

inject

如果 上面的 Car类不传实例

// 在代码中构建 将会变为
  private DemoActivity injectDemoActivity(DemoActivity instance) {
    // MembersInjector我们后面再解释
    // 对的 如果无参 Car 就是简单直接new 并 赋值给 DemoActivity 成员变量 car
    DemoActivity_MembersInjector.injectCar(instance, new Car());
    return instance;
  }

当然我们是传值的，而且这个值来之 Module 注解, 看完后面我们就知道了

module

class DaggerDemoComponent{
  ...
  public static final class Builder {
    private DemoModule demoModule;

    private Builder() {}

    // 上面build时
    public DemoComponent build() {
      if (demoModule == null) {
      // 对的这里直接创建了
        this.demoModule = new DemoModule();
      }
      return new DaggerDemoComponent(this);
    }

    public Builder demoModule(DemoModule demoModule) {
      this.demoModule = Preconditions.checkNotNull(demoModule);
      return this;
    }
  }
}

对的直接new了，就这么简单？ 当然不是
还记得我们 module 里面 provide 对外提供的方法吗

编译出了 DemoModule_ProvidePersonFactory.java
因为我们 provide了一个方法，如果是多个方法，当然就是多个类了
格式 模块名_方法名Factory，如 DemoModule_ProvidePersonFactory

public final class DemoModule_ProvidePersonFactory implements Factory<Person> {
  private final DemoModule module;

  public DemoModule_ProvidePersonFactory(DemoModule module) {
    this.module = module;
  }
   // 这里面每个方法，其实最终都是 做了一样的事情
     public static Person proxyProvidePerson(DemoModule instance) {
        // 原句不是这样，这里为了帮助分析，只认结果
        // 直接 调用了 module.providePerson()
        // 也就是 我们最早期声明 module 提供出来的方法
        return instance.providePerson()
  } 
}

Component

class DaggerDemoComponent{
  private DemoActivity injectDemoActivity(DemoActivity instance) {
    DemoActivity_MembersInjector.injectXXXX(instance, XXXX实例)
    return instance;
  }
}

DemoActivity_MembersInjector
也就是最终负责注入的成员，操作类