翻译Dagger 2在安卓中使用

官方文档链接：https://google.github.io/dagger/android.html

1.前言

Dagger 2相比其它依赖注入框架的主要优势之一，严格的代码生成（没有反射），意味着可以在安卓应用中使用。但是，在安卓中使用，仍然有些事项需注意。

2.设计思想

虽然安卓是用Java编写的，但两者就风格而言完全不一样，因为得考虑移动平台独特的表现方式。许多常见的用于Java代码的模式无法用于安卓代码，甚至许多《Effective Java》书中的建议在安卓看来都是不恰当的。

为了达到既符合语言习惯又轻量的代码目标，Dagger依靠混淆来接着处理编译后的字节码。Dagger通过使用不同的工具链产生在两种环境下都有效执行的字节码，使代码在服务器和安卓上不管是看还是感觉都很自然。此外，Dagger有个明确的目标，确保生成的Java代码总能支持混淆优化（假设在安卓上使用混淆）。

当然，不是所有问题都能用那样的方式解决，但这是能提供安卓特有兼容的主要机制。

3.基本使用

使用Dagger编写安卓应用的主要困难之一，许多安卓框架类由系统自身初始化，像Activity和Fragment。但只有在Dagger创建所有的注入对象时，它才能完美工作。这导致需要在生命周期方法中完成对象注入，将有许多类像下面这样：

public class FrombulationActivity extends Activity {
  @Inject Frombulator frombulator;

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // DO THIS FIRST. Otherwise frombulator might be null!
    ((SomeApplicationBaseType) getContext().getApplicationContext())
        .getApplicationComponent()
        .newActivityComponentBuilder()
        .activity(this)
        .build()
        .inject(this);
    // ... now you can write the exciting code
  }
}

这有几个问题（dagger.android包中的类提供了简化这种模式的方法）：

样板代码使以后重构变得困难。随着越来越多的开发者复制粘贴这段代码，越来越少的人知道它实际作用。
更严重的是，它需要请求注入的对象（FrombulationActivity）知道注入器。即使这是通过接口代替实体类，但仍打破了依赖注入的核心原则：一个类不应该知道任何关于如何被注入的。

4.给Activity注入对象

为Application级的Component添加AndroidInjectionModule来确保Dagger必要的所有基础类型依赖是有效的。

从创建@Subcomponent注解的接口继承AndroidInjector<YourActivity>和@Subcomponent.Builder注解的内部类继承AndroidInjector.Builder<YourActivity>：

@Subcomponent(modules = ...)
public interface YourActivitySubcomponent extends AndroidInjector<YourActivity> {
  @Subcomponent.Builder
  public abstract class Builder extends AndroidInjector.Builder<YourActivity> {}
}

定义Subcomponent之后，通过定义个Module依赖Subcomponent及其Builder，并将它添加到Application级的Component中，来添加Subcomponent到Component层次结构中：
```
@Module(subcomponents = YourActivitySubcomponent.class)
abstract class YourActivityModule {
  @Binds
  @IntoMap
  @ActivityKey(YourActivity.class)
  abstract AndroidInjector.Factory<? extends Activity>
      bindYourActivityInjectorFactory(YourActivitySubcomponent.Builder builder);
}

@Component(modules = {..., YourActivityModule.class})
interface YourApplicationComponent {}
```
如果Subcomponent及其Builder没有其它的方法，可以使用@ContributesAndroidInject注解帮助生成样板代码。在Module中添加抽象方法返回需要的Activity，并用@ContributesAndroidInject注解，且指定Subcomponent依赖的模块，来取代上述的2、3步。如果Subcomponent需要作用域，可以给方法使用作用域注解。
```
@ActivityScope
@ContributesAndroidInjector(modules = { /* modules to install into the subcomponent */ })
abstract YourActivity contributeYourActivityInjector();
```

接着，使Application实现HasActivityInjector，且用@Inject注解一个DispatchingAndroidInjector<Activity>对象去让activityInjector()方法返回：

public class YourApplication extends Application implements HasActivityInjector {
  @Inject DispatchingAndroidInjector<Activity> dispatchingActivityInjector;

  @Override
  public void onCreate() {
    super.onCreate();
    DaggerYourApplicationComponent.create()
        .inject(this);
  }

  @Override
  public AndroidInjector<Activity> activityInjector() {
    return dispatchingActivityInjector;
  }
}

最后，在需要的Activity的onCreate()方法中，于super.onCreate()方法之前调用AndroidInjection.inject(this)方法：

public class YourActivity extends Activity {
  public void onCreate(Bundle savedInstanceState) {
    AndroidInjection.inject(this);
    super.onCreate(savedInstanceState);
  }
}

工作原理？（此处可以参考另一篇博客，有更详细的分析）

通过AndroidInjection.inject()方法从Application中获取DispatchingAndroidInjector<Activity>对象，同时将Activity传入inject(Activity)方法中。DispatchingAndroidInjector<Activity>对象通过Activity类查询AndroidInjector.Factory（就是YourActivitySubcomponent.Builder），创建ActivityInjector（就是YourActivitySubcomponent），并将Activity传入它的inject(Activity)方法中。

5.给Fragment注入对象

给Fragment注入和给Activity注入一样简单。以同样的方式定义Subcomponent，将参数中的Activity替换为Fragment，把@ActivityKey替换为@FragmentKey，以及HasActivityInjector替换为HasFragmentInjector。注入过程发生的地方，也由Activity的onCreate()方法替换为Fragment的onAttach()方法。

不像为Activity绑定Module，可以选择在哪为Fragment绑定Module。可以让某Fragment级的Component作为另一个Fragment级（也可以是Activity级或者Application级）Component的Subcomponent，这都取决于Fragment需要的其它依赖关系。当决定Fragment级Component的位置之后，使相关Fragment实现HasFragmentInjector。举个例子，假设Fragment需要成为YourActivitySubcomponent的依赖，代码将如下所示：

public class YourActivity extends Activity
    implements HasFragmentInjector {
  @Inject DispatchingAndroidInjector<Fragment> fragmentInjector;

  @Override
  public void onCreate(Bundle savedInstanceState) {
    AndroidInjection.inject(this);
    super.onCreate(savedInstanceState);
    // ...
  }

  @Override
  public AndroidInjector<Fragment> fragmentInjector() {
    return fragmentInjector;
  }
}

public class YourFragment extends Fragment {
  @Inject SomeDependency someDep;

  @Override
  public void onAttach(Activity activity) {
    AndroidInjection.inject(this);
    super.onAttach(activity);
    // ...
  }
}

@Subcomponent(modules = ...)
public interface YourFragmentSubcomponent extends AndroidInjector<YourFragment> {
  @Subcomponent.Builder
  public abstract class Builder extends AndroidInjector.Builder<YourFragment> {}
}

@Module(subcomponents = YourFragmentSubcomponent.class)
abstract class YourFragmentModule {
  @Binds
  @IntoMap
  @FragmentKey(YourFragment.class)
  abstract AndroidInjector.Factory<? extends Fragment>
      bindYourFragmentInjectorFactory(YourFragmentSubcomponent.Builder builder);
}

@Subcomponent(modules = { YourFragmentModule.class, ... }
public interface YourActivityOrYourApplicationComponent { ... }

6.基本类型

因为DispatchingAndroidInjector在运行时通过类查询相关的AndroidInjector.Factory，可以定义基本类型实现HasActivityInjector/HasFragmentInjector/etc，同时调用AndroidInjection.inject()方法，那它们的子类只需要添加相应的@Subcomponent注解的依赖。如果没有复杂的类层级结构，可使用Dagger提供的基类，例如DaggerActivity和DaggerFragment。Dagger还提供了DaggerApplication，只要继承它且重写applicationInjector()方法，返回应该注入Application中Component。基本类型还有下面这些：

DaggerService和DaggerIntentService
DaggerBroadcastReceiver
DaggerContentProvider

只有当BroadcastReceiver在清单文件中被注册，DaggerBroadcastReceiver才可以使用。若BroadcastReceiver在代码中注册，建议使用构造函数注入。

7.支持的库

对于使用安卓支持库的用户，有相似的类型存在于dagger.android.support包中。若使用支持库中的Fragment，依赖关系为AndroidInjector.Factory<? extends android.support.v4.app.Fragment>；若使用支持库中的AppCompatActivity，应该继续实现AndroidInjector.Factory<? extends Activity>而不是<? extends AppCompatActivity>（或者FragmentActivity）。

8.Dagger的安卓库

在build.gradle中添加以下内容：

dependencies {
  compile 'com.google.dagger:dagger-android:2.x'
  compile 'com.google.dagger:dagger-android-support:2.x' // if you use the support libraries
  annotationProcessor 'com.google.dagger:dagger-android-processor:2.x'
}

9.什么时候注入

尽可能优先使用构造函数注入，因为javac将确保属性在被设置前没有被引用，以避免空指针异常，所以越早注入越好。为了这个原因，DaggerActivity在onCreate()方法中，于super.onCreate()方法前调用AndroidInjection.inject()；DaggerFragment在onAttach()方法中同样如此，还能避免Fragment重连后对象不一致。

对于Activity而言，在super.onCreate()方法之前调用AndroidInjection.inject()方法是很重要的，因为当配置更改时，会调用super去连接之前Activity关联的Fragment，并依次注入。为了保证Fragment成功注入，Activity必须已经注入。若使用ErrorProne工具，可在编译时发现调用顺序上的错误。

10.AndroidInjector.Factory作用域

AndroidInjector.Factory有意成为无状态（无属性）的接口，那样就不需要管理被注入对象状态。DispatchingAndroidInjector通过Provider（注解的方法）获取AndroidInjector.Factory对象，那样就不需要明确持有Factory实例。因为AndroidInjector.Builder的实现由Dagger生成，持有待被注入的Activity/Fragment/etc实例。若给提供注入对象的方法加上作用域，将会导致编译时错误。如果也认同AndroidInjector.Factory不该持有被注入对象实例，需要使用@SuppressWarnings("dagger.android.ScopedInjectoryFactory")注解Module中的方法来忽略这个问题。

11.总结

Dagger 2在安卓中使用的关键点就是不让被注入的类知道注入的细节。部分地方由于不理解，只能照着语义翻译，若有人发现翻译错误的，还望在评论中指出，谢了！