Dagger2 分析【1】

说明

本次示例是基于：

compile 'com.google.dagger:dagger:2.11'
annotationProcessor 'com.google.dagger:dagger-compiler:2.11'

该章节主要分析基本的注入代码

注入代码

这里我们先从最基础的注入方式开始：
Inject:

public class Engine {
    @Inject
    public Engine() {}
}

public class Car {
  @Inject
  public Car(Engine engine) {}
}

Component:

@Component
public interface ManComponent {
    void injectMan(ManActivity manActivity);  // 注入 man 所需要的依赖
}

public class ManActivity extends AppCompatActivity {

    @Inject
    Car mCar;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_man);
        DaggerManComponent.create().inject(this);
        Log.d("Car", mCar.toString());

        DaggerManComponent.builder().build().inject(this);
        Log.d("Car", mCar.toString());
    }
}

这里我们先运行起来，看看打印出来的日志：

07-08 11:00:32.461 9953-9953/com.whyalwaysmea.dagger2 D/Car: com.whyalwaysmea.dagger2.bean.Car@850a3f9
07-08 11:00:32.461 9953-9953/com.whyalwaysmea.dagger2 D/Car: com.whyalwaysmea.dagger2.bean.Car@27e1df3e

可以发现，Car的地址变了，说明两次注入是生成的不同的对象。

生成代码分析

我们这里先从DaggerManComponent开始看， DaggerManComponent是直接apt生成的代码：

public final class DaggerManComponent implements ManComponent {
  private Provider carProvider;

  private MembersInjector manActivityMembersInjector;

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

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

  public static ManComponent create() {
    return new Builder().build();
  }

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

    this.carProvider = Car_Factory.create(Engine_Factory.create());

    this.manActivityMembersInjector = ManActivity_MembersInjector.create(carProvider);
  }

  @Override
  public void inject(ManActivity mainActivity) {
    manActivityMembersInjector.injectMembers(mainActivity);
  }

  public static final class Builder {
    private Builder() {}

    public ManComponent build() {
      return new DaggerManComponent(this);
    }
  }
}

可以看到，这里是有一个Builder类，我们在注入的时候，调用DaggerManComponent.create();和DaggerManComponent.builder().build();其实是等价的。
都是调用了ManComponent的构造函数，返回了一个ManComponent,同时也调用了initialize(),initialize就是得到了一个MembersInjector对象，injectMan其实也是调用的MembersInjector.injectMembers()
所以我们这里先看看initialize：

private void initialize(final Builder builder) {
  this.carProvider = Car_Factory.create(Engine_Factory.create());

  this.manActivityMembersInjector = ManActivity_MembersInjector.create(carProvider);
}

这里又涉及到了，其他三个由apt生成的java类，分别是ManActivity_MembersInjector和Car_Factory， Engine_Factory

public final class Engine_Factory implements Factory {
  private static final Engine_Factory INSTANCE = new Engine_Factory();

  @Override
  public Engine get() {
    return new Engine();
  }

  public static Factory create() {
    return INSTANCE;
  }
}

public final class Car_Factory implements Factory {
  private final Provider engineProvider;

  public Car_Factory(Provider engineProvider) {
    assert engineProvider != null;
    this.engineProvider = engineProvider;
  }

  @Override
  public Car get() {
    return new Car(engineProvider.get());
  }

  public static Factory create(Provider engineProvider) {
    return new Car_Factory(engineProvider);
  }
}

首先可以看到Factory继承了Provider接口，里面有一个get方法。
其次，这里的Car_Factory.create()其实就是直接new了一个Car_Factory对象出来。get就是new一个Car对象。

@Generated(
  value = "dagger.internal.codegen.ComponentProcessor",
  comments = "https://google.github.io/dagger"
)
public final class ManActivity_MembersInjector implements MembersInjector {
  private final Provider mCarProvider;

  public ManActivity_MembersInjector(Provider mCarProvider) {
    assert mCarProvider != null;
    this.mCarProvider = mCarProvider;
  }

  public static MembersInjector create(Provider mCarProvider) {
    return new ManActivity_MembersInjector(mCarProvider);
  }

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

  public static void injectMCar(ManActivity instance, Provider mCarProvider) {
    instance.mCar = mCarProvider.get();
  }
}

首先这里是实现了一个MembersInjector接口， 里面有一个injectMembers()方法，这个方法主要就是返回实例对象的。
从这里可以得知，我们注入的时候，是不能用private来修饰注入对象的，因为那样的话在生成的代码中是无法获取到对象的。

小结

通过分析生成的代码，我们知道了三个接口Factory和MembersInjector，Factory又是继承于Provider。

Factory可以理解成是生产实例对象的地方：
构造方法由@Inject修饰过的类XX，会生成一个实现了Factory的类XX_Factory，该类中主要是通过get()方法来获取对象。

MembersInjector可以理解成是需要注入对象的成员：
在示例中，是ManActivity需要Car,所以这里是生成了ManActivity_MembersInjector implements MembersInjector
该类中主要是通过injectMembers(ManActivity instance)方法，将Provider.get()获取到的对象赋值给了ManActivity.T

最后再来小结一下DaggerXXXComponent，该类是直接实现了XXXComponent接口的。
Component一直被认为是Dagger2中依赖注入的桥梁。这里由于没有涉及到Module，所以Component也没有起到很大的作用。
所以也就有了第三种注入的方式：

ManActivity_MembersInjector.create(Car_Factory.create()).injectMembers(this);

这一节只用来了最简单的方式来注入，所以生成的代码也是很好理解的。
打算一步一步的深入分析，同时也加深对于Dagger2的理解。
如果有错误的地方还请大家提出，共同讨论。

Dagger2分析 【2】