易于理解的Dagger2入门篇

Dagger2是什么

Dagger2是一款基于Java注解来实现的完全在编译阶段完成依赖注入的开源库，主要用于模块间解耦、提高代码的健壮性和可维护性。Dagger2在编译阶段通过apt利用Java注解自动生成Java代码，然后结合手写的代码来自动帮我们完成依赖注入的工作。

Dagger 2 is the first to implement the full stack with generated code.

概念有点官方抽象，上面提到的依赖注入是什么东西呢？

依赖注入(Dependency Injection)

在类A中要用到一个B的对象（A依赖B），需要通过新建B的实例或其他一些主动的方式来获取对象，然后才能调用。而通过外部的方式自动将B的对象分配给A（注入），实现被动方式来获取对象，这个过程称为依赖注入。

你可以先简单的理解Dagger2就是让你不需要初始化对象了，任何对象声明完了就可以直接使用。

使用前的准备

添加apt插件

build.gradle(project)

 dependencies {
        classpath 'com.android.tools.build:gradle:3.3.2'
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
    }

引入dagger2依赖

bulid.gradle(app)

implementation 'com.google.dagger:dagger:2.6'
annotationProcessor 'com.google.dagger:dagger-compiler:2.6'

注意：上面的两个版本尽量一致，要不然可能会抛异常
dagger.Provides missing element type

初步使用

写一个栗子：构造一个汽车

不用Dagger2的普通写法：

轮胎

public class Tyre {

    @Override
    public String toString() {
        return "我是轮胎";
    }
}

汽车类

public class Car {

    Tyre tyre; //轮胎

    public Car(){
        tyre = new Tyre();
    }

    public Tyre getTyre() {
        return tyre;
    }

    public void setTyre(Tyre tyre) {
        this.tyre = tyre;
    }

    @Override
    public String toString() {
        return "Car{" +
                "tyre=" + tyre +
                '}';
    }
}

MainActivity

public class MainActivity extends AppCompatActivity {
    Car mCar;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mCar = new Car();
        System.out.println(mCar.toString());
    }
} 

运行结果：Car{tyre=我是轮胎}

可见不用Dagger2的普通写法，我们是需要主动创建汽车对象，也就是说要通过实例化汽车对象来实现依赖。

那么使用Dagger2就不需要在依赖的类中通过new来创建依赖，也就是说不需要 mCar = new Car() 这一步了。

使用Dagger2更改之前先看这几个注解：

• @inject：声明依赖注入的对象
• @Moudle：依赖提供方，负责提供依赖中所需要的对象
• @Component：依赖注入组件，负责将依赖注入到依赖需求方。
• @Provides：会根据返回值类型在有此注解的方法中寻找应调用的方法

使用Dagger2改写

添加一个汽车Module类

用于提供对象，需要用到@Module和@Providers注解

@Module
public class CarModule {
    @Provides
    public Car getCar(){
        return new Car();
    }
}

添加一个MainComponent接口

用于表示给哪些类注入哪些对象。需要用到@Component

比如这里我的MainActivity类需要用到Car对象，那么就可以新建一个接口，在接口上添加注解@Component，并把刚刚写好的的CarModule加上。并在接口下的新增一个注入方法，把需要使用该对象的类作为参数传入进来。

@Component(modules = CarModule.class)
public interface MainComponent  {
    void inject(MainActivity mainActivity);
}

修改MainActivity

去掉主动创建Car对象的方式，需要使用@Inject

public class MainActivity extends AppCompatActivity {

    @Inject
    Car mCar;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        MainComponent mainComponent = DaggerMainComponent.create();
        mainComponent.inject(this);
        System.out.println(mCar.toString());
    }
}

在运行之前，需要先Build > Make Project

apt会自动生成一个DaggerMainComponent类（这个类在app->build->generated->source->apt->debuge->com.xxxx.xxxx包下），我们就可以利用这个类来实现依赖注入。之后简单的分析一下这个类如何工作的。

分析自动生成的辅助代码

apt生成的辅助类做了什么实现类这些依赖注入的呢？

public final class DaggerMainComponent implements MainComponent {
  private Provider getCarProvider;
  private MembersInjector mainActivityMembersInjector;

  private DaggerMainComponent(Builder builder) {
    assert builder != null;
    initialize(builder);
  }

  public static Builder builder() {
    return new Builder();
  }

  public static MainComponent create() {
    return builder().build();
  }

  @SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {

    this.getCarProvider = CarModule_GetCarFactory.create(builder.carModule);

    this.mainActivityMembersInjector = MainActivity_MembersInjector.create(getCarProvider);
  }

  //注入依赖的具体实现
  @Override
  public void inject(MainActivity mainActivity) {
    mainActivityMembersInjector.injectMembers(mainActivity);
  }

  public static final class Builder {
    private CarModule carModule;

    private Builder() {}

    public MainComponent build() {
      if (carModule == null) {
        this.carModule = new CarModule();
      }
      return new DaggerMainComponent(this);
    }

    public Builder carModule(CarModule carModule) {
      this.carModule = Preconditions.checkNotNull(carModule);
      return this;
    }
  }
}

通过建造者设计模式创建了DaggerMainComponent和CarModule对象，然后具体实现了inject方法：通过一个注射器将需要该依赖对象的类对象（这里是MainActivity对象）注入进去。

注入后会调用injectMembers方法，可以看出来Car对象在这里就被赋值创建了。

 public void injectMembers(MainActivity instance) {
    if (instance == null) {
      throw new NullPointerException("Cannot inject members into a null reference");
    }
    instance.mCar = mCarProvider.get();
  }

这里的instance就是MainActivity 的实例对象，而mCar就是我们在MainActivity声明的Car对象。之后调用mCarProvider的get方法会调用下面的方法：

//调用carModule的getCar方法获取Car的实例对象
public Car get() {
    return Preconditions.checkNotNull(
        module.getCar(), "Cannot return null from a non-@Nullable @Provides method");
  }

看到 module.getCar() 就知道它调用了CarModule的getCar方法创建了Car对象。

总结

到这里你可能有点哭笑不得，一句new就可以完成的功能怎么让你玩的这么复杂了呢，没这么写必要吧。其实，这里笔者是为了让你好理解，Dagger2还是挺难上手的，如果一开始就用特别复杂的例子来解释会让观众大大看起来云里雾里。这也是笔者看了很多写Dagger博客的通病，所以才动手写这篇博客的目的。当然，之后还会写它的最佳实践，那时候你就会发现它的好处和强大了。