Dagger2是Dagger的升级版，是一个依赖注入框架，现在由Google接手维护。

依赖注入是面向对象编程的一种设计模式，其目的是为了降低程序耦合，这个耦合就是类之间的依赖引起的。

代码理解注入：

public class ClassA {
    ...
    ClassB b;
    ...
    public ClassA() {
        b = new ClassB();
    }
    public void do() {
        ...
        b.doSomething();
        ...
    }
}

依赖注入有一下几种方式：

通过接口注入
    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;
      }

通过Java注解
  public class ClassA {
      //此时并不会完成注入，还需要依赖注入框架的支持，如RoboGuice,Dagger2
      @inject ClassB classB;

      ...
      public ClassA() {}

在Dagger2中用的就是最后一种注入方式，通过注解的方式，将依赖注入到宿主类中。

配置Dagger2

配置apt插件(在build.gradle(Project:xxx)中添加如下代码)

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

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

  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代码：

public class MainActivity extends AppCompatActivity implements MainContract.View {
    private MainPresenter mainPresenter;
    ...
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //实例化presenter 将view传递给presenter
        mainPresenter = new MainPresenter(this);
        //调用Presenter方法加载数据
         mainPresenter.loadData();
         ...
    }
}
public class MainPresenter {
    //MainContract是个接口，View是他的内部接口，这里看做View接口即可
    private MainContract.View mView;

    MainPresenter(MainContract.View view) {
        mView = view;
    }
    public void loadData() {
        //调用model层方法，加载数据
        ...
        //回调方法成功时
        mView.updateUI();
    }
｝

使用Dagger2代码：

public class MainActivity extends AppCompatActivity implements MainContract.View {
    @Inject
    MainPresenter mainPresenter;
    ...
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
         DaggerMainComponent.builder()
                .mainModule(new MainModule(this))
                .build()
                .inject(this);
        //调用Presenter方法加载数据
         mainPresenter.loadData();
         ...
    }
}
public class MainPresenter {
    //MainContract是个接口，View是他的内部接口，这里看做View接口即可
    private MainContract.View mView;
    @Inject
    MainPresenter(MainContract.View view) {
        mView = view;
    }    
    public void loadData() {
        //调用model层方法，加载数据
        ...
        //回调方法成功时
        mView.updateUI();
    }
@Module
public class MainModule {
    private final MainContract.View mView;
    public MainModule(MainContract.View view) {
        mView = view;
    }
    @Provides
    MainView provideMainView() {
        return mView;
    }
}
@Component(modules = MainModule.class)
public interface MainComponent {
    void inject(MainActivity activity);
}