Android Dagger2+MVP使用步骤及生成代码分析

1.添加依赖：

dependencies {
 	...
    //dagger2
    implementation 'com.google.dagger:dagger:2.11'
    annotationProcessor 'com.google.dagger:dagger-compiler:2.11'
    //kapt 'com.google.dagger:dagger-compiler:2.11' //如果是kotlin开发环境用这个，否则不会根据注解生成相关类
   	...
}

2.创建Component类

@Component()
public interface ActivityComponent {
    void inject(MainActivity activity);
}

3.创建view、presenter、model类

public class MainActivity extends BaseDrawerActivity{
    @Inject
    MainPresenter presenter;
    @Override
    protected int findLayoutId() {
        return R.layout.activity_main;
    }
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }
}

public class MainPresenter {
    @Inject
    MainModel model;
    @Inject
    public MainPresenter() {
    }
}

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

4.build->Rebuild Project

5.成功后会看到如下生成类，我是kotlin环境下，如果是Java环境下就会在apt路径下。

6.调用注入：

public class MainActivity extends AppCompatActivity {
    @Inject
    MainPresenter presenter;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        DaggerActivityComponent.builder().build().inject(this);
    }
}

如此activity绑定了presenter对象，presenter绑定了model对象。
下边是Component流程图：

整个component的作用就是组合注入关系。
首先根据Inject创建一个model的工厂类，然后在工厂类里面调用get方法会创建一个model。

public final class MainModel_Factory implements Factory<MainModel> {
  private static final MainModel_Factory INSTANCE = new MainModel_Factory();
	//主动调用四、new 一个model对象。
  @Override
  public MainModel get() {
    return new MainModel();
  }

  public static Factory<MainModel> create() {
    return INSTANCE;
  }
}

然后根据吧modelfactory注入到PresenterMembersInjector中。

public final class MainPresenter_MembersInjector implements MembersInjector<MainPresenter> {
  private final Provider<MainModel> modelProvider;
	//2.modelfactory成为成员变量
  public MainPresenter_MembersInjector(Provider<MainModel> modelProvider) {
    assert modelProvider != null;
    this.modelProvider = modelProvider;
  }
	//1.component调用，在这里传入modelfactory，然后根据modelfactory生成一个presenter成员管理对象。
  public static MembersInjector<MainPresenter> create(Provider<MainModel> modelProvider) {
    return new MainPresenter_MembersInjector(modelProvider);
  }
	//主动调用三、初始化presenter中的model对象
  @Override
  public void injectMembers(MainPresenter instance) {
    if (instance == null) {
      throw new NullPointerException("Cannot inject members into a null reference");
    }
    instance.model = modelProvider.get();
  }
  public static void injectModel(MainPresenter instance, Provider<MainModel> modelProvider) {
    instance.model = modelProvider.get();
  }
}

然后根据PresenterMembersInjector（model注入对象）生成presenterfactory：

public final class MainPresenter_Factory implements Factory<MainPresenter> {
  private final MembersInjector<MainPresenter> mainPresenterMembersInjector;
	//2.把model注入对象保存到工厂中
  public MainPresenter_Factory(MembersInjector<MainPresenter> mainPresenterMembersInjector) {
    assert mainPresenterMembersInjector != null;
    this.mainPresenterMembersInjector = mainPresenterMembersInjector;
  }
	//根据mainPresenterMembersInjector和新建的Mainpresenter生成一个包含调用关系的Mainpresenter对象
	//主动调用二、返回一个包含model调用关系的presenter
  @Override
  public MainPresenter get() {
    return MembersInjectors.injectMembers(mainPresenterMembersInjector, new MainPresenter());
  }
	//1.根据绑定model注入对象新建一个presenterfactory
  public static Factory<MainPresenter> create(
      MembersInjector<MainPresenter> mainPresenterMembersInjector) {
    return new MainPresenter_Factory(mainPresenterMembersInjector);
  }
}

根据view和presenterfactory生成view的注入对象。

public final class MainActivity_MembersInjector implements MembersInjector<MainActivity> {
  private final Provider<MainPresenter> presenterProvider;
	//2.保存presenter工厂
  public MainActivity_MembersInjector(Provider<MainPresenter> presenterProvider) {
    assert presenterProvider != null;
    this.presenterProvider = presenterProvider;
  }
	//1.新建注入对象（presenter工厂）
  public static MembersInjector<MainActivity> create(Provider<MainPresenter> presenterProvider) {
    return new MainActivity_MembersInjector(presenterProvider);
  }
	//主动调用一、确定view中inject的presenter对象的值
  @Override
  public void injectMembers(MainActivity instance) {
    if (instance == null) {
      throw new NullPointerException("Cannot inject members into a null reference");
    }
    instance.presenter = presenterProvider.get();
  }

  public static void injectPresenter(
      MainActivity instance, Provider<MainPresenter> presenterProvider) {
    instance.presenter = presenterProvider.get();
  }
}

写的可能有点乱，在自动生成的代码中主要两个功能：

1. 一个绑定关系（model->presenter->view）
2. 一个关联初始化过程(view->presenter->model)