版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/a820703048/article/details/81151012
一、背景
现在Dagger2在项目中被广泛使用特别是结合MVP架构使用，非常典型的降低耦合，因为在MVP模式只能中Activity持有presenter的引用，同时presenter又持有view的引用，这样便于更新UI界面，这样Activity和Presenter就耦合在一起了，而dagger注入可以有效解耦合，所以在MVP中使用是再好不过了
添加依赖
apply plugin: 'com.android.application'
//添加如下代码，应用apt插件
apply plugin: 'com.neenbedankt.android-apt'
...
dependencies {
...
compile 'com.google.dagger:dagger:2.4'
apt 'com.google.dagger:dagger-compiler:2.4'
//java注解
compile 'org.glassfish:javax.annotation:10.0-b28'
...
}
二、基础使用
这里是使用了dagger的activity
public class LoginActivity extends AppCompatActivity implements ILoginView,View.OnClickListener{
//注意此处使用了注解
@Inject
LoginPresenterCompl loginPresenter ;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mLogin = (Button) findViewById(R.id.btn_login);
mClear = (Button) findViewById(R.id.btn_clear);
mName = (EditText) findViewById(R.id.et_name);
mPassWord = (EditText) findViewById(R.id.et_password);
mLogin.setOnClickListener(this);
mClear.setOnClickListener(this);
DaggerMainComponent.builder().mainModule(new MainModule(this)).build().inject(this);
}
}使用了dagger P层
public class LoginPresenterCompl implements ILoginPresenter {
private ILoginView loginView ;
private User user ;
//注意此处使用了注解
@Inject
public LoginPresenterCompl(ILoginView view){
loginView = view ;
user = new User("张三","123456") ;
}
......
}model 层 中使用dagger
@Module
public class MainModule {
private final ILoginView view ;
public MainModule(ILoginView view){
this.view = view ;
}
@Provides
ILoginView provideILogView(){
return view ;
}
}新增一个接口
@Component(modules = MainModule.class)
public interface MainComponent {
public void inject(LoginActivity activity) ;
}看完上面的代码后，一脸的懵逼，WTF(what the fuck)，这TM是什么，这么复杂，还不如之前的简单呢，新增了两个类还有这么多代码，得不偿失呀！
同志们，如果你们第一眼看到后是这样想的话，说明和我想的一样，呵呵。每一个刚接触Dagger2的人可能都会这样想，因为我们只看到了表面。
不错，表面上我们是多了一个类和接口也多了很多代码，但是这样的组合其实是可以理解的。因为通常简单的代码具有耦合性，而要想降低这样的耦合就需要其他的辅助代码，其实少代码量和低耦合这两者并不能同时兼顾，古人云：鱼和熊掌不可兼得。我们作为堂堂聪明绝顶的程序猿怎么可能会输给古人呢。
三、表层猜测分析
好！下面来认真讲解Dagger2是如何完成依赖注入的。
首先我们来看看LoginActivity代码
@Inject
LoginPresenterCompl loginPresenter ;同样在LoginPresenterCompl中也有这么一段代码
@Inject
public LoginPresenterCompl(ILoginView view){
loginView = view ;
user = new User("张三","123456") ;
}之所以挑出这两段代码是因为它们都添加了@Inject注解。
在LoginActivity中其实只有这么一句提到loginPresenter，在接下来的代码中并没有对其进行初始化。
那loginPresenter是如何进行初始化的呢（此处注意添加@Inject注解的变量不能被private修饰）？
直观上我们可以这样理解，被@Inject注解的代码存在某种联系，当代码执行到@Inject的时候程序会自动进入到这个类的构造方法中，如果正巧这个构造方法也被@Inject修饰了，那么系统就会帮我们自动创建对象。
这只是表面的理解，这其中肯定还有很多我们没有看到的“猫腻”。这俩不会无缘无故的有联系，肯定还有第三者，通过这个第三者这两个被@Inject注解修饰的代码才会产生联系。
这个第三者是谁呢？自然的我们就会想到我们添加的这个类和接口。
首先我们来分析MainComponent接口
MainComponent是一个接口（也可以是一个抽象类），在这个接口中我们定义了一个inject()方法，其中参数是LoginActivity对象，同时MainComponent还被@Component注解着，注解中modules的值是MainModule.class，这个内容会在接下来的地方进行说明，暂时先放一放。
此时在Android studio中，如果我们rebuild的一下项目就会有新的发现。在项目的build/generated/source/apt/debug/项目包名/dragger目录下生成对应的包其中包含DaggerMainComponent类，这个类名其实不是固定的，是根据我们上面写的MainComponent，加了Dagger前缀生成的DaggerMainComponent。
其实在这个时候我们就已经完成了present的依赖注入
但是在
DaggerMainComponent.builder().mainModule(new MainModule(this)).build().inject(this)
DaggerMainComponent.builder().mainModule(new MainModule(this)).build().inject(this);中我们看到还有一个MainModule，这个是我们自己创建的一个类
我们可以看到这个类被@Module注解修饰，内部有一个ILoginView的变量和一个构造方法还有一个被@Provides修饰的provideILogView方法。
看到这还是一脸懵逼，这个类是干嘛的？
在MainComponent接口中我们看到这么一个注解@Component(modules = MainModule.class)，这里用到了MainModule，可见MainComponent需要MainModule一起才能完成工作。
其实这个类我们可以理解成提供参数的，也就是提供参数依赖的，如何理解呢？
在MainModule中我们为什么要提供ILoginView类型的对象？为什么不是其他的呢？
这是因为LoginPresenterCompl的构造函数需要这么一个参数，所以我们在这里提供这么一个相同的参数，并通过被@Provides注解修饰的方法将其返回出去，如果LoginPresenterCompl还需要其他的参数，同样我们也可以在这里添加对应类型的参数然后通过另一个被@Provides注解修饰的方法返回出去。
在MainComponent接口中提供的inject()方法的参数是LoginActivity，这个参数的含义是LoginPresenter要在什么地方注入。
了解了各个类的功能后我们来总结一下
@Inject 程序会将Dagger2会将带有此注解的变量或者构造方法参与到依赖注入当中，Dagger2会实例化这个对象
@Module 带有该注解的类需要对外提供依赖，其实就是提供实例化需要的参数，Dagger2在实例化的过程中发现一些参数，Dagger2就会到该类中寻找带有@Provides注解的以provide开头的需找对应的参数
@Component 带有该注解的接口或抽象类起到一个关联桥梁的作用，作用就是将带有@Inject的方法或对象和带有@Module的类进行关联，只有通过该接口或抽象类才可以在实例化的时候到带有
@Module中类中去寻找需要的参数，也就是依赖注入。
OK，下面我们来捋捋思路。
1、在这个示例代码中，LoginActivity中需要LoginPresenterCompl，所以在LoginActivity中定义了该对象并且通过@Inject将其注解，同时到LoginPresenterCompl的构造方法中也通过@Inject将其注解，
表明这些是需要依赖注入的。
2、因为在LoginPresenterCompl的构造方法需要ILoginView类型的参数，所以需要通过依赖将获取这些参数，所以就需要带有@Module注解的类用于获取需要的参数，
在@Module注解的类中通过被@Provides注解的以provide开头的方法对外提供需要的参数，一般而言有几个参数就需要有几个带有@Provides的方法。
3、此时还需要一个桥梁将两者联系到一起，带有@Component的接口或抽象类就起到这个桥梁的作用。注解中有一个module的值，这个值指向需要依赖的Module类，同时其中有一个抽象方法
inject()，其中的参数就是我们需要在哪个类中实例化LoginPreserentCompl，因为我们需要在LoginActivity中实例化，所以参数类型就是LoginActivity类型。
然后在Android studio中rebuild我们的项目，就会生成DaggerMainComponent类，通过
DaggerMainComponent.builder().mainModule(new MainModule(this)).build().inject(this);
完成我们需要的依赖注入。
原理解析
通过在Android studio中通过执行Build->Rebuild Project，app/build/generated/source/apt目录下发现生成了
LoginPresenterComp_Factory类
public final class LoginPresenterCompl_Factory implements Factory<LoginPresenterCompl> {
private final Provider<ILoginView> viewProvider;
public LoginPresenterCompl_Factory(Provider<ILoginView> viewProvider) {
assert viewProvider != null;
this.viewProvider = viewProvider;
}
@Override
public LoginPresenterCompl get() {
return new LoginPresenterCompl(viewProvider.get());
}
public static Factory<LoginPresenterCompl> create(Provider<ILoginView> viewProvider) {
return new LoginPresenterCompl_Factory(viewProvider);
}
}
为了对比把LoginPresenterCompl的代码也找了出来
代码如下
public class LoginPresenterCompl implements ILoginPresenter {
@Inject
public LoginPresenterCompl(ILoginView view){
loginView = view ;
user = new User("张三","123456") ;
}
......
}仔细看看LoginPresenterCompl_Factory这个类，发现其中有三个方法
构造方法
构造方法中的参数viewProvider一个Provider类型的，而Provider的泛型参数是ILoginView，这个参数就是我们实例化LoginPresenterCompl需要的参数。
get()方法
在该方法中初始化了我们正在需要的LoginPresenterCompl对象
create()方法
在该方法中实例化了LoginPresenterCompl_Factory本类对象
既然上面的viewProvider是由MainModule提供的，那么就来看看MainModule对应的注入类吧
MainModule_ProvideILogViewFactory
public final class MainModule_ProvideILogViewFactory implements Factory<ILoginView> {
private final MainModule module;
public MainModule_ProvideILogViewFactory(MainModule module) {
assert module != null;
this.module = module;
}
@Override
public ILoginView get() {
return Preconditions.checkNotNull(
module.provideILogView(), "Cannot return null from a non-@Nullable @Provides method");
}
public static Factory<ILoginView> create(MainModule module) {
return new MainModule_ProvideILogViewFactory(module);
}
对应的MainModule代码如下
@Module
public class MainModule {
private final ILoginView view ;
public MainModule(ILoginView view){
this.view = view ;
}
@Provides
ILoginView provideILogView(){
return view ;
}
}从结构中不难看出被@Provider注解修饰的方法会对应的生成Factory 类，这个类中最主要的方法是get()方法，在该方法中调用了MainModule的provideILogView方法，而该方法是为了我们提供LoginPresenterCompl实例化参数的，LoginPresenterCompl的实例化是在LoginPresenterCompl_Factory的get()方法中完成的。
实例化代码如下
@Override
public LoginPresenterCompl get() {
return new LoginPresenterCompl(viewProvider.get());
}在代码中可以看出实例化过程中参数是由viewProvider.get()提供的。咦！！！！
在MainModule_ProvideILogViewFactory中的get()方法其实返回了我们实例化的参数。
那么这个viewProvider是不是我们的MainModule_ProvideILogViewFactory呢？
viewProvider是一个Provider类型，而MainModule_ProvideILogViewFactory实现了Factory接口，那Provider和Factory有没有联系呢？
看这段代码
public interface Factory<T> extends Provider<T> {
}发现Factory接口继承了Provider接口，所以其实viewProvider就是MainModule_ProvideILogViewFactory类型。
看到这里终于明白了LoginPresenterCompl_Factory类和MainModule_ProvideILoginViewFactory类的关系了，也明白了实例化过程了。
但是这些类的初始化和相关方法是如何被调用的，在哪里被调用的呢？
还有两个重要的类小明没有看到。MainComponent和对应的DaggerMainComponent。
代码如下
MainComponent代码
@Component(modules = MainModule.class)
public interface MainComponent {
public void inject(LoginActivity activity) ;
}DaggerMainComponent代码
public final class DaggerMainComponent implements MainComponent {
private Provider<ILoginView> provideILogViewProvider;
private Provider<LoginPresenterCompl> loginPresenterComplProvider;
private MembersInjector<LoginActivity> loginActivityMembersInjector;
private DaggerMainComponent(Builder builder) {
assert builder != null;
initialize(builder);
}
public static Builder builder() {
return new Builder();
}
@SuppressWarnings("unchecked")
private void initialize(final Builder builder) {
this.provideILogViewProvider = MainModule_ProvideILogViewFactory.create(builder.mainModule);
this.loginPresenterComplProvider = LoginPresenterCompl_Factory.create(provideILogViewProvider);
this.loginActivityMembersInjector =
LoginActivity_MembersInjector.create(loginPresenterComplProvider);
}
@Override
public void inject(LoginActivity activity) {
loginActivityMembersInjector.injectMembers(activity);
}
public static final class Builder {
private MainModule mainModule;
private Builder() {}
public MainComponent build() {
if (mainModule == null) {
throw new IllegalStateException(MainModule.class.getCanonicalName() + " must be set");
}
return new DaggerMainComponent(this);
}
public Builder mainModule(MainModule mainModule) {
this.mainModule = Preconditions.checkNotNull(mainModule);
return this;
}
}
通过上面代码可以看出DaggerMainComponent实现了MainComponent接口并实现了其中的inject()方法。同时也提供了其他的辅助方法。
DaggerMainComponent.builder().mainModule(new MainModule(this)).build().inject(this);还记得在LoginActivity中添加的这个方法吗，分析DaggerMainComponent就从这段代码入手。
1、DaggerMainComponent调用了builder方法
小明找到builder()方法看看这个方法到底做了什么事
public static Builder builder() {
return new Builder();
}现这个方法创建并返回了Builder对象
Builder是什么东东呢？仔细看代码Build是DaggerMainCompone的内部类。
2、DaggerMainComponent.builder().mainModule(new MainModule(this))
紧接着又调用了mainModule并将MainModule的对象传了进来。
mainModule()方法是Builder中的一个方法，代码如下
public Builder mainModule(MainModule mainModule) {
this.mainModule = Preconditions.checkNotNull(mainModule);
return this;
}其中做了什么事呢？就是将传进来的MainModule对象赋值给本类的mainModule对象，并返回本类对象
3、DaggerMainComponent.builder().mainModule(new MainModule(this)).build()
紧接着又调用了Builder的build()方法
public MainComponent build() {
if (mainModule == null) {
throw new IllegalStateException(MainModule.class.getCanonicalName() + " must be set");
}
return new DaggerMainComponent(this);该方法通过new DaggerMainComponent(this)创建了DaggerMainComponent对象并将其返回。
那么new DaggerMainComponent(this)做了什么事呢？
private DaggerMainComponent(Builder builder) {
assert builder != null;
initialize(builder);
}其中调用了initialize方法并将builder对象传入。
initialize()方法如下
private void initialize(final Builder builder) {
this.provideILogViewProvider = MainModule_ProvideILogViewFactory.create(builder.mainModule);
this.loginPresenterComplProvider = LoginPresenterCompl_Factory.create(provideILogViewProvider);
this.loginActivityMembersInjector = LoginActivity_MembersInjector.create(loginPresenterComplProvider);在initialize方法中小明终于看到了MainModule_ProvideILogViewFactory和LoginPresenterCompl_Factory的create方法被调用了。
首先通过传入的MainModule对象创建MainModule_ProvideILogViewFactory对象
provideILogViewProvider，然后将provideILogViewProvider对象作为参数来创建
LoginPresenterCompl_Factory对象。
前面已经讲过，MainModule_ProvideILogViewFactory是一个Factory对象，
而LoginPresenterCompl_Factory创建对象需要一个Provider对象，同时Factory继承了Provider，所以可以将其传入。
所以LoginPresenterComp_Factory的viewProvider对象
是一个MainModule_ProvideILogViewFactory对象，
这个概念前面也讲过，这里得到认证。
在这段代码中小明发现了LoginActivity_MembersInjector类，于是小明又将这个类找了出来
public final class LoginActivity_MembersInjector implements MembersInjector<LoginActivity> {
private final Provider<LoginPresenterCompl> loginPresenterProvider;
public LoginActivity_MembersInjector(Provider<LoginPresenterCompl> loginPresenterProvider) {
assert loginPresenterProvider != null;
this.loginPresenterProvider = loginPresenterProvider;
}
public static MembersInjector<LoginActivity> create(
Provider<LoginPresenterCompl> loginPresenterProvider) {
return new LoginActivity_MembersInjector(loginPresenterProvider);
}
@Override
public void injectMembers(LoginActivity instance) {
if (instance == null) {
throw new NullPointerException("Cannot inject members into a null reference");
}
instance.loginPresenter = loginPresenterProvider.get();
}
public static void injectLoginPresenter(
LoginActivity instance, Provider<LoginPresenterCompl> loginPresenterProvider) {
instance.loginPresenter = loginPresenterProvider.get();
}
}该类的cereate()方法需要一个Provider泛型是LoginPresenterCompl类型的参数，通过构造函数将其传入赋值给loginPresenterProvider变量。就这么简单。
DaggerMainComponent.builder().mainModule(new MainModule(this)).build().inject(this)最后调用了inject()方法
@Override
public void inject(LoginActivity activity) {
loginActivityMembersInjector.injectMembers(activity);
}在该方法中调用了LoginActivityMembersInjector中的injectMembers()方法。
injectMembers()方法内容如下
@Override
public void injectMembers(LoginActivity instance) {
if (instance == null) {
throw new NullPointerException("Cannot inject members into a null reference");
}
instance.loginPresenter = loginPresenterProvider.get();
}