易於理解的Dagger2入門篇

樹獺非懶發表於2019-05-04

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部落格的通病，所以才動手寫這篇部落格的目的。當然，之後還會寫它的最佳實踐，那時候你就會發現它的好處和強大了。

相關文章