说明
本次示例是基于：
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<Car> carProvider;
private MembersInjector<ManActivity> 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<ManActivity>对象，injectMan其实也是调用的MembersInjector<ManActivity>.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<Engine> {
private static final Engine_Factory INSTANCE = new Engine_Factory();
@Override
public Engine get() {
return new Engine();
}
public static Factory<Engine> create() {
return INSTANCE;
}
}
public final class Car_Factory implements Factory<Car> {
private final Provider<Engine> engineProvider;
public Car_Factory(Provider<Engine> engineProvider) {
assert engineProvider != null;
this.engineProvider = engineProvider;
}
@Override
public Car get() {
return new Car(engineProvider.get());
}
public static Factory<Car> create(Provider<Engine> engineProvider) {
return new Car_Factory(engineProvider);
}
}
首先可以看到Factory<T>继承了Provider<T>接口，里面有一个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<ManActivity> {
private final Provider<Car> mCarProvider;
public ManActivity_MembersInjector(Provider<Car> mCarProvider) {
assert mCarProvider != null;
this.mCarProvider = mCarProvider;
}
public static MembersInjector<ManActivity> create(Provider<Car> 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<Car> mCarProvider) {
instance.mCar = mCarProvider.get();
}
}
首先这里是实现了一个MembersInjector<T>接口， 里面有一个injectMembers()方法，这个方法主要就是返回实例对象的。
从这里可以得知，我们注入的时候，是不能用private来修饰注入对象的，因为那样的话在生成的代码中是无法获取到对象的。
小结
通过分析生成的代码，我们知道了三个接口Factory<T>和MembersInjector<T>，Factory<T>又是继承于Provider<T>。
Factory<T>可以理解成是生产实例对象的地方：
构造方法由@Inject修饰过的类XX，会生成一个实现了Factory的类XX_Factory，该类中主要是通过get()方法来获取对象。
MembersInjector<T>可以理解成是需要注入对象的成员：
在示例中，是ManActivity需要Car,所以这里是生成了ManActivity_MembersInjector implements MembersInjector<ManActivity>
该类中主要是通过injectMembers(ManActivity instance)方法，将Provider<T>.get()获取到的对象赋值给了ManActivity.T
最后再来小结一下DaggerXXXComponent，该类是直接实现了XXXComponent接口的。
Component一直被认为是Dagger2中依赖注入的桥梁。这里由于没有涉及到Module，所以Component也没有起到很大的作用。
所以也就有了第三种注入的方式：
ManActivity_MembersInjector.create(Car_Factory.create()).injectMembers(this);
这一节只用来了最简单的方式来注入，所以生成的代码也是很好理解的。
打算一步一步的深入分析，同时也加深对于Dagger2的理解。
如果有错误的地方还请大家提出，共同讨论。
