易於理解的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<Car> getCarProvider;
  private MembersInjector<MainActivity> 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博客的通病，因此才動手寫這篇博客的目的。固然，以後還會寫它的最佳實踐，那時候你就會發現它的好處和強大了。