android dagger用法 android dagger2原理

Dagger2原理

Dagger2是什么

Dagger2是一个Android和Java中的快速注射器。

什么是依赖注入

依赖注入是一种面向对象的编程模式，它的出现是为了降低耦合性，所谓耦合就是类之间依赖关系，所谓降低耦合就是降低类和类之间依赖关系。可能有的人说自己之前并没有使用过依赖注入，其实真的没有使用过吗？当我们在一个类的构造函数中通过参数引入另一个类的对象，或者通过set方法设置一个类的对象其实就是使用的依赖注入。

通常依赖注入有以下几种方式

通过接口注入

interface ClassBInterface { 
        void setB(ClassB b);
}
public class ClassA implements ClassBInterface { 
        ClassB classB; 
        @override 
        void setB(ClassB b) { 
                classB = b; 
        }
}

通过set注入

public class ClassA { 
        ClassB classB;  
        public void setClassB(ClassB b) { 
                classB = b; 
        }
}

通过构造注入

public class ClassA { 
        ClassB classB; 
        public void ClassA(ClassB b) { 
                classB = b; 
        }
}

通过注解注入

public class ClassA { 
//此时并不会完成注入，还需要依赖注入框架的支持，如Dagger2 
        @inject  
        ClassB classB; 
        public ClassA() {
        }
}

引入Dagger2

添加插件

dependencies { 
        classpath 'com.android.tools.build:gradle:2.1.2' //添加apt插件 
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8' 
}

添加依赖(在build.gradle中添加如下代码)

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' 
       ...
}

使用Dagger2

在项目中绝大多数的使用都是Dagger结合MVP架构使用的，在MVP中使用是非常典型的降低耦合的使用，采用MVP架构设计通过Dagger2进行解耦合

为什么要选择在MVP模式中使用Dagger2呢？
因为在MVP模式中Activity持有presenter的引用，同时presenter也持有view的引用，这样便于更新UI界面，这样Activity就和presenter紧紧的耦合在一起了，而Dagger2是依赖注入框架就是解耦合的，所以子MVP中使用Dagger2也就再好不过了，直接上代码

activity持有了presenter的引用并且创建了该对象，但是如果presenter的构造函数发生改变则这里也需要改变，其实所有和presenter构造函数相关的代码都要改变。

但是如果我们使用Dagger2依赖框架该如何使用呢？

public abstract class BaseActivity<P extends IPresenter> extends FragmentActivity implements IActivity, IView {

    @Inject
    protected P p;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(bondLayout());
        initInject();
        initView();
        initData();

    }
}

public class BasePresenter<M extends IModel,V extends IView> implements IPresenter {
    @Inject
    protected M m;
    @Inject
    protected V v;
    }

只有上述两个注解还无法完成依赖注入，还需要如下两个新增类新增的MainModule类

@Module
public class MainModules {

    private MainContract.MainView mainView;

    public MainModules(MainContract.MainView mainView) {
        this.mainView = mainView;
    }
    @Provides
    public MainContract.MainView provideMainView(){
        return mainView;
    }

    @Provides
    public MainContract.MainModel provideMainModel(MainModel mainModel){
        return mainModel;
    }

}

新增的MainComponent接口

@Component(modules = MainModules.class)
public interface MainCompont {
		//这里实现injectActivity();
}

通过直接注解和上述两个接口类即可完成Dagger2的依赖注入。在Activity中是通过

DaggerMainComponent.builder().mainModule(new MainModule(this)).build().inject(this)

完成依赖注入的。看完上面的代码后，一脸的懵逼，WTF(what the fuck)，这TM是什么，这么复杂，还不如之前的简单呢，新增了两个类还有这么多代码，得不偿失呀！
每一个刚接触Dagger2的人可能都会这样想，因为我们只看到了表面。
不错，表面上我们是多了一个类和接口也多了很多代码，但是这样的组合其实是可以理解的。因为通常简单的代码具有耦合性，而要想降低这样的耦合就需要其他的辅助代码，其实少代码量和低耦合这两者并不能同时兼顾，古人云：鱼和熊掌不可兼得。我们作为堂堂聪明绝顶的程序猿怎么可能会输给古人呢。

下面来认真讲解Dagger2是如何完成依赖注入的。

首先我们来看看提取封装的BaseActivity代码中有这么一段代码

@Inject
    protected P p;

同样在BasePresenter中也有这么一段代码

@Inject
    protected M m;
    @Inject
    protected V v;

之所以挑出这两段代码是因为它们都添加了@Inject注解。
在Activity中其实只有这么一句提到Presenter，在接下来的代码中并没有对其进行初始化。那loginPresenter是如何进行初始化的呢（此处注意添加@Inject注解的变量不能被private修饰）

直观上我们可以这样理解，被@Inject注解的代码存在某种联系，当代码执行到@Inject的时候程序会自动进入到这个类的构造方法中，如果正巧这个构造方法也被@Inject修饰了，那么系统就会帮我们自动创建对象。
这只是表面的理解，这其中肯定还有很多我们没有看到的“猫腻”。这俩不会无缘无故的有联系，肯定还有第三者，通过这个第三者这两个被@Inject注解修饰的代码才会产生联系。
这个第三者是谁呢？
自然的我们就会想到我们添加的这个类和接口。
首先我们来分析MainComponent接口代码如下

@Component(modules = MainModule.class)
public interface MainComponent { 
       // public void inject(MainActivity activity) ;
}

MainComponent是一个接口（也可以是一个抽象类），在这个接口中我们定义了一个inject()方法，其中参数是MainActivity对象，同时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)

中我们看到还有一个MainModule，这个是我们自己创建的一个类MainModule代码如下

@Module
public class MainModules {

    private MainContract.MainView mainView;

    public MainModules(MainContract.MainView mainView) {
        this.mainView = mainView;
    }
    @Provides
    public MainContract.MainView provideMainView(){
        return mainView;
    }

    @Provides
    public MainContract.MainModel provideMainModel(MainModel mainModel){
        return mainModel;
    }

}

我们可以看到这个类被@Module注解修饰，内部有一个MainView 的变量和一个构造方法还有一个被@Provides修饰的provideMainView方法。

在MainComponent接口中我们看到这么一个注解@Component(modules = MainModule.class)，这里用到了MainModule，可见MainComponent需要MainModule一起才能完成工作。其实这个类我们可以理解成提供参数的，也就是提供参数依赖的，如何理解呢？
在MainModule中我们为什么要提供MainView类型的对象？为什么不是其他的呢？这是因为BasePresenter的构造函数需要这么一个参数，所以我们在这里提供这么一个相同的参数，并通过被@Provides注解修饰的方法将其返回出去，如果BasePresenter还需要其他的参数，同样我们也可以在这里添加对应类型的参数然后通过另一个被@Provides注解修饰的方法返回出去。在MainComponent接口中提供的inject()方法的参数是MainActivity，这个参数的含义是MainPresenter要在什么地方注入。

了解了各个类的功能后我们来总结一下

• @Inject 程序会将Dagger2会将带有此注解的变量或者构造方法参与到依赖注入当中，Dagger2会实例化这个对象- @Module
  带有该注解的类需要对外提供依赖，其实就是提供实例化需要的参数，Dagger2在实例化的过程中发现一些参数，Dagger2就会到该类中寻找带有@Provides注解的以provide开头的需找对应的参数
• @Component带有该注解的接口或抽象类起到一个关联桥梁的作用，作用就是将带有@Inject的方法或对象和带有@Module的类进行关联，只有通过该接口或抽象类才可以在实例化的时候到带有@Module中类中去寻找需要的参数，也就是依赖注入。

捋捋思路。

DaggerMainComponent.builder().mainModule(new MainModule(this)).build().inject(this);

Build类

Build类用来管理一个mainModule，并实例化DaggerMainComponent类。

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;
    }
  }

而mainModule负责管理一个view，别的类可以通过他的get()方法得到他管理的view(activity)。

这里就完成了把view(activity)依附到一个mainModule上，再实例化一个Build类管理mainModule，最后用这个Build来实例化DaggerMainComponent

而DaggerMainComponent用来管理三个成员

provideMainViewProvider ： 如名字所说，管理着mainview，可以从中得到mainview

mainPresenterProvider： 如名字所说，管理着mainPresenter，可以从中得到mainPresenter=

public final class DaggerMainComponent implements MainComponent {
  private Provider<MainContract.View> provideMainViewProvider;

  private Provider<MainPresenter> mainPresenterProvider;

  private MembersInjector<MainActivity> mainActivityMembersInjector;

  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.provideMainViewProvider = MainModule_ProvideMainViewFactory.create(builder.mainModule);

    this.mainPresenterProvider = MainPresenter_Factory.create(provideMainViewProvider);

    this.mainActivityMembersInjector = MainActivity_MembersInjector.create(mainPresenterProvider);
  }

  @Override
  public void inject(MainActivity activity) {
    mainActivityMembersInjector.injectMembers(activity);
  }

  ...
}

调用了Dagger的inject方法
最终实现Dagger2的依赖注入

感谢观看