说明

• Dagger2 是谷歌推出的一个依赖注入框架，现在网络上有很多关于Dagger2 的使用说明，但是，我发现，其实他们大多数都是按照Java中的使用方式在Android开发中使用，这样使用是很不方便的，因为你无法将Dagger2 的初始化放到BaseActivity中，每个你需要使用依赖注入的Activity或者Fragment中，你都要手动调用来进行依赖注入，很有可能在你需要使用依赖注入的时候却忘记了调用，这样的开发效率无疑是很低的。那么，接下来，我就会告诉大家，如何在Android开发中使用Dagger2。

添加依赖

• 首先，使用一个第三方第一件事必然是添加依赖，Dagger2 官方Github上给的是这样的：

    dependencies {
      compile 'com.google.dagger:dagger:2.x' // Dagger2
      annotationProcessor 'com.google.dagger:dagger-compiler:2.x' // 注解处理器
    }
  

• 但是，这个依赖实际上实在Java开发中使用的，如果在Android开发中使用，应该是这样：

  dependencies {
    compile 'com.google.dagger:dagger-android:2.10-rc4' // Dagger2 Android包
    // 如果使用支持包， 上面的Android包可以省略，支持包里面已经包含了
    compile 'com.google.dagger:dagger-android-support:2.10-rc4' // Dagger2 Android 支持包，用于支持v4、v7下的控件
    annotationProcessor 'com.google.dagger:dagger-compiler:2.10-rc4' // 注解处理器
  }
  

• <b>注意：在使用最新正式版2.10时，需要在android节点下配置</b>

    android{
        ... ...
        configurations.all {
            resolutionStrategy.force 'com.google.code.findbugs:jsr305:1.3.9'
        }
    }
  

Dagger2 使用

• 依赖添加完了，那么接下来就是使用了，在使用的过程中，笔者踩过很多坑，但最终都得到了解决。

• 首先，在BaseActivity的onCreate(@Nullable Bundle savedInstanceState) 方法中， super.onCreate(savedInstanceState)前添加：AndroidInjection.inject(this)

  @Override
  protected void onCreate(@Nullable Bundle savedInstanceState) {
      // Dagger2 依赖注入，放在onCreate()前
      AndroidInjection.inject(this);
      super.onCreate(savedInstanceState);
  }
  

• 虽然在Dagger2 的Android support 包中为我们提供了DaggerAppCompatActivity类，但是实际开发中我们并不能直接去继承他使用，因为在他提供的类中，注入了两个Injector：

  @Inject DispatchingAndroidInjector<Fragment> supportFragmentInjector; // v4包下Fragment
  @Inject DispatchingAndroidInjector<android.app.Fragment> frameworkFragmentInjector; // app包下Fragment
  

• 一个是v4包下的Fragment依赖注入，一个是app包下的Fragmnet依赖注入，所以，除非你的项目中，同时用到了这两种Fragment，否则，不要继承Dagger2提供的DaggerAppCompatActivity。

• 接下来就是BaseFragment，这个可以继承Dagger2提供的DaggerFragment，当然啦，也要注意，v4包下的Fragment要继承support包下的DaggerFragment， app包下的要继承android包下的DaggerFragment。

• 这个实际上也只是在onAttach(Context context)方法中，在super.onAttach(context)前添加了AndroidInjection.inject(this) 或者 AndroidSupportInjection.inject(this)

  @Override
  public void onAttach(Context context) {
    AndroidSupportInjection.inject(this); // v4 Fragment
    super.onAttach(context);
  }
  
  @Override
  public void onAttach(Context context) {
    AndroidInjection.inject(this); // Fragment
    super.onAttach(context);
  }
  

• 接下来要做的就是编写Activity、Fragment的组件、模块了。新建

  MainActivitySub.java
  @Subcomponent // 每一个Activity都有与之对应的Sub类
  public interface MainActivitySub extends AndroidInjector<MainActivity> {
      @Subcomponent.Builder
     abstract class Builder extends AndroidInjector.Builder<MainActivity> {
     }
  }
  
  ActivityModule.java
  @Module(subcomponents = {MainActivitySub.class, Main2AcitivitySub.class ...}) // 用于注入Activity，将每个Activity的Sub类添加到数组
  public abstract class ActivityModule {
  
      @Binds
      @IntoMap
      @ActivityKey(MainActivity.class) // 提供每一个Activity
      abstract AndroidInjector.Factory<? extends Activity>
      bindMainActivity(MainActivitySub.Builder builder);
  
      @Binds
      @IntoMap
      @ActivityKey(Main2Activity.class) // 提供每一个Activity
      abstract AndroidInjector.Factory<? extends Activity>
      bindMain2Activity(Main2ActivitySub.Builder builder);
  
      ... ...
  }
  

• 同样的，Fragment也是这样：

  MainFragmentSub.java
  @Subcomponent // 每一个Fragment都有与之对应的Sub类
  public interface MainFragmentSub extends AndroidInjector<MainFragment> {
      @Subcomponent.Builder
     abstract class Builder extends AndroidInjector.Builder<MainFragment> {
     }
  }
  
  FragmentModule.java
  @Module(subcomponents = {MainFragmentSub.class, Main2FragmentSub.class ...}) // 用于注入Fragment，将每个Fragment的Sub类添加到数组
  public abstract class FragmentModule {
  
      @Binds
      @IntoMap
      @FragmentKey(MainActivity.class) // 提供每一个Fragment，注意：这里的FragmentKey是根据Fragment选择的，v4 下使用support包下的
      abstract AndroidInjector.Factory<? extends Fragment>
      bindMainFragment(MainFragmentSub.Builder builder);
  
      @Binds
      @IntoMap
      @FragmentKey(Main2Fragment.class) // 提供每一个Activity
      abstract AndroidInjector.Factory<? extends Fragment>
      bindMain2Fragment(Main2FragmentSub.Builder builder);
  
      ... ...
  }
  

• 最后，新建

  ApplicationSub.java // 使用Component注解，将ActivityModule和FragmentModule添加到数组
  @Component(modules = {ActivityModule.class, FragmentModule.class})
  public interface ApplicationSub {
      void inject(MyApplication app); // 注入MyApplication
  }
  

• 这样，Dagger2的配置就基本完成了，现在只需要完成MyApplication的配置：

  public class MyApplication extends Application
              implements HasDispatchingActivityInjector,  // 实现Activity、Fragment注入接口
                    HasDispatchingSupportFragmentInjector {
  
     /** Dagger2 Activity Injector */
      @Inject
      DispatchingAndroidInjector<Activity> activityInjector;
      /** Dagger2 Fragment Injector*/
      @Inject
      DispatchingAndroidInjector<Fragment> fragmentInjector;
  
      @Override
      public void onCreate() {
          super.onCreate();
          // DaggerApplicationSub在编译后生成
          DaggerApplicationSub.create().inject(this);
      }
  
      @Override
      public DispatchingAndroidInjector<Activity> activityInjector() {
          return activityInjector;
      }
  
      @Override
      public DispatchingAndroidInjector<Fragment> supportFragmentInjector() {
          return fragmentInjector;
      }
  }
  

最后

• 好了，就这样Dagger2的配置就完成了，你可以在你的项目里尽情的使用Dagger2依赖注入了，只需要让你的Activity、Fragment继承BaseActivity、BaseFragment，不必再重复的调用Daggerxxxxxx.create().inject(this)了。
• Dagger2使用指南
• 项目Github地址