Dagger 2应用于Android的完美扩展库-dagger.android
Dagger系列：
- Dagger 2从浅到深(一)
- Dagger 2从浅到深(二)
- Dagger 2从浅到深(三)
- Dagger 2从浅到深(四)
- Dagger 2从浅到深(五)
- Dagger 2从浅到深(六)
- Dagger 2从浅到深(七)
- Dagger 2应用于Android的完美扩展库-dagger.android
Demo地址：https://github.com/teaphy/DaggerLearn
Demo地址： Kotlin-Dagger-2-Retrofit-Android-Architecture-Components
概述
在使用Dagger开发Android时，不可避免的一个问题是，许多Android的类都是由系统实例化的，比如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
}
}
从而引发了，不可避免的问题：
- 复制代码使得以后很难重构。 随着越来越多的开发人员复制粘贴该块，更少的知道它实际上做了什么。
- 更重要的是，它要求注射类型（FrombulationActivity）知道其注射器。 即使这是通过接口而不是具体类型完成的，它打破了依赖注入的核心原则：一个类不应该知道如何注入它。
自从Googgle接手Dagger维护以来，大神们脑洞全开，如何能让Dagger完美的与Android系统兼容?确实是个头疼的问题。dagger.android也就这时候应运而生了。Dagger.Android库是Dagger库的补充，dagger.android中的类提供了一种简化此模式的方法，从而在一定程度上避免了上述问题的发生。
核心类
- AndroidInjection：注入Android核心库的基本类型的实例
- AndroidInjector
:注入Android库的类型的接口, T为Android库的基本类型T,比如Activity、Fragment、BroadcastReceive等； - AndroidInjector.Factory
：AndroidInjector 的工厂类接口 - DispatchingAndroidInjector
:其为AndroidInjector 接口的实现类，将Android核心库的的基本类型T的实例注入Dagger，该操作是由Android核心库的类的实例本身执行，而不是Dagger。
注入实例
由于DispatchingAndroidInjector在运行时由类查找相应的AndroidInjector.Factory，那么，在基类中，实现HasActivityInjector/HasFragmentInjector接口，在相应的声明周期(onCreate()或者onAttach())内调用AndroidInjection.inject()方法，注入相应的实例。所有每个子类都需要做的是绑定相应的@Subcomponent，从而没有必要在每个实例类中调用AndroidInjection.inject()方法。
在dagger.android库中，Dagger提供了一些基本类型，比如DaggerActivity和DaggerFragment。对于Appliaction,还提供了DaggerApplication，继承其后，只需重写applicationInjectoer()方法来返回AndroidInjector&lxtXxApplication>.
Dagger提供的基本类型：
- DaggerActivity
- DaggerFragment
- DaggerService
- DaggerIntentService
- DaggerBroadcastReceiver
- DaggerContentProvider
下面，我们来了解Dagger所提供的基本类型的用法：
注入Activity实例
1.注入AndroidInjectionModule：在应用程序的ApplicationComponent中，注入AndroidInjectionModule，以确保Android的类(Activity、Fragment、Service、BroadcastReceiver及ContentProvider等)可以绑定。 一般把AndroidInjectionModule放在ApplicationCoponent中，其他的Component依赖Application即可。
@Component(modules = AndroidInjectionModule.class)
public interface TodoComponent {
void inject(TodoApplication application);
}
2. 创建子组件 - MainSubcomponent：其继承自AndroidInjector，在该子组件中含有一个抽象类Builder，
该Builder继承自AndroidInjector.Builder，并由@Subcomponent.Builder注解
@Subcomponent(modules = AndroidInjectionModule.class)
public interface MainSubcomponent extends AndroidInjector {
@Subcomponent.Builder
public abstract class Builder extends AndroidInjector.Builder{
}
}
3. 创建Module - MainModule：定义子组件MainActivitySubcomponent后，定义该子组件的Module - MainctivityModule,通过将该Module注入到AppComponentd的modules列表中，以便将MainActivitySubcomponent.Builder添加到组件层次机构中。
@Module(subcomponents = MainSubcomponent.class)
public abstract class MainModule {
@Binds
@IntoMap
@ActivityKey(MainActivity.class)
abstract AndroidInjector.Factory
bindYourActivityInjectorFactory(MainSubcomponent.Builder builder);
}
@Component(modules = {..., YourActivityModule.class})
interface YourApplicationComponent {}
注意：
- 如果在Module中提供依赖实例，@Provides方法必须为静态方法，否则编译不通过。
4. 自定义Application，并实现HasActivityInjector接口，同时注入(@Inject)DispatchingAndroidInjector
public class TodoApplication extends Application implements HasActivityInjector {
@Inject
DispatchingAndroidInjector dispatchingActivityInjector;
@Override
public void onCreate() {
super.onCreate();
DaggerTodoComponent.create()
.inject(this);
}
/**
* Returns an {@link AndroidInjector} of {@link Activity}s.
*/
@Override
public AndroidInjector activityInjector() {
return dispatchingActivityInjector;
}
}
5. 在MainActivity.onCreat()方法中，在调用super.onCreate()之前调用AndroidInjection.inject(this)
public class MaiActivity extends Activity {
public void onCreate(Bundle savedInstanceState) {
AndroidInjection.inject(this);
super.onCreate(savedInstanceState);
}
}
注入Fragment实例
注入Fragment实例， 与注入Activity实例一样，以相同的方式定义子组件。不同的是：
- 需使用Fragment替换Activity类型参数；
- 将@ActivityKey替换为@FragmentKey；
- 将HasActivityInjector替换为HasFragmentInjector；
- AndroidInjection.inject(Fragment)方法,在Fragment的onAttach()中调用，而不是在onCreate()中；
- Fragment的Module的添加位置，与Activity定义的Module添加不同，其取决于Fragment内部所需要的其他绑定的依赖注入；
与为Activity定义的模块不同，您可以选择为Fragment添加模块的位置。 您可以使您的Fragment组件成为另一个Fragment组件，一个Activity组件或Application组件的子组件，这一切都取决于片段需要哪个其他绑定。确定组件位置后，使相应的类型实现HasFragmentInjector。
比如，FragmentA中，绑定了Apple实例，而在Fragment所在的ActivityA的Module中，提供了该实例的，那么只需要将FragmenA的Module添加至ActivityA的Component即可：
@Subcomponent(modules = { FragmentAModule.class, ... }
public interface ActivityAComponent { ... }
下面，以FruitActivity中添加OrangeFragment为例，其中OrangeFragment中绑定AppleBean实例，该实例由FruitModule提供，而FruitModule为FruitActivity的Module，示例代码如下：
创建Fragment - OrangeFragment,在onAttach()方法中，super.onAttach(context)方法前调用AndroidSupportInjection.inject(this)。
public class OrangeFragment extends Fragment{ *** @Inject AppleBean mAppleBean; @Override public void onAttach(Context context) { AndroidSupportInjection.inject(this); super.onAttach(context); } @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View rootView = inflater.inflate(R.layout.fragment_orange, container, false); ButterKnife.bind(this, rootView); // AppleBean{name='这是一个苹果'} Log.d("testTodo", mAppleBean.toString()); *** return rootView; } }
注意:- 如果使用v4包中的Fragment，在onAttach()方法中，应调用AndroidSupportInjection.inject(this);
- 如果使用普通的Fragment(即android.app.Fragment)，在onAttach()方法中，应调用AndroidInjection.inject(this);
创建子组件 - OrangeSubcomponent,其继承自AndroidInjector，在该子组件中含有一个抽象类Builder，
该Builder继承自AndroidInjector.Builder，并由@Subcomponent.Builder注解@Subcomponent public interface OrangeSubcomponent extends AndroidInjector{ @Subcomponent.Builder public abstract class Builder extends AndroidInjector.Builder { } } 创建Module - OrangeModule：定义该Fragment的Module，通过将该Module注入到相应的Fragment、Activity、AppComponent的Module中，具体注入到哪个Module中，依据绑定的实例的依赖关系
@Module(subcomponents = OrangeSubcomponent.class) public abstract class OrangeModule { @Binds @IntoMap @FragmentKey(OrangeFragment.class) abstract AndroidInjector.Factory bind(FruitSubcomponent.Builder builder); }
注意:- 如果使用v4包中的Fragment，必须绑定AndroidInjector.Factory<？ extends android.support.v4.app.Fragment>;
- 如果使用v4包中的Fragment，必须绑定AndroidInjector.Factory<？ extends android.support.v4.app.Fragment>;
将OrangeModule注入到FruitComponent中，即将OrangeModule添加至FruiltCoponent的modules属性中
@Subcomponent(modules = OrangeModule.class) public interface FruitSubcomponent extends AndroidInjector{ @Subcomponent.Builder abstract class Builder extends AndroidInjector.Builder { } }
注入BroadcastReceiver实例
这里我们先看看如何动态注册一个广播。动态注册需要在代码中动态的指定广播地址并注册，通常我们是在Activity或Service注册一个广播，下面我们就来看一下注册的代码：
CoffeeReceiver receiver = new CoffeeReceiver();
IntentFilter filter = new IntentFilter();
filter.addAction("android.intent.action.MY_BROADCAST");
registerReceiver(receiver, filter);
registerReceiver是android.content.ContextWrapper类中的方法，Activity和Service都继承了ContextWrapper，所以可以直接调用。在实际应用中，我们在Activity或Service中注册了一个BroadcastReceiver，当这个Activity或Service被销毁时如果没有解除注册，系统会报一个异常，提示我们是否忘记解除注册了。所以，记得在特定的地方执行解除注册操作：
@Override
protected void onDestroy() {
super.onDestroy();
unregisterReceiver(receiver);
}
执行这样行代码就可以解决问题了。注意，这种注册方式与静态注册相反，不是常驻型的，也就是说广播会跟随程序的生命周期。
我们可以根据以上任意一种方法完成注册，当注册完成之后，这个接收者就可以正常工作了。我们可以用以下方式向其发送一条广播：
@OnClick(R.id.acb_coffee)
public void onViewClicked() {
Intent intent = new Intent();
intent.setAction(CoffeeReceiver.ACTION_COFFEE);
sendBroadcast(intent);
}
这样，就完成了一次简单的广播的简单注册，看起来也不算太复杂。接下来，让我们来看看使用Dager2依赖注入广播实例：
创建BroadcastReceiver - CoffeeReceiver,其继承自DaggerBroadcastReceiver。在CoffeeReceiver中，依赖注入AppleBean实例。
public class CoffeeReceiver extends DaggerBroadcastReceiver { public static final String ACTION_COFFEE = "com.todo.daggerlearn.coffee"; @Inject AppleBean mAppleBean; @Override public void onReceive(Context context, Intent intent) { super.onReceive(context, intent); if (TextUtils.equals(intent.getAction(), ACTION_COFFEE)) { Toast.makeText(context, "这是一杯" + mAppleBean.getName() + "味咖啡", Toast.LENGTH_SHORT).show(); } } }在AndroidManifest.xml中声明CoffeeReceiver
创建子组件 - CoffeeReceiverSubcomponent
@Subcomponent public interface CoffeeReceiverSubcomponent extends AndroidInjector{ @Subcomponent.Builder public abstract class Builder extends AndroidInjector.Builder { } } 创建Module - CoffeeModule
@Module(subcomponents = CoffeeReceiverSubcomponent.class) public abstract class CoffeeModule { @Binds @IntoMap @BroadcastReceiverKey(CoffeeReceiver.class) abstract AndroidInjector.Factory bind(CoffeeReceiverSubcomponent.Builder builder); }将CoffeeModule添加至ApplicationComponent的modules属性中
@Component(modules = {AndroidInjectionModule.class, CoffeeModule.class，...}) public interface TodoComponent extends AndroidInjector{ @Component.Builder abstract class Builder extends AndroidInjector.Builder {} } 在DringkActivity中发送广播
public class DrinkActivity extends AppCompatActivity { @BindView(R.id.toolBar) Toolbar mToolbar; @BindView(R.id.acb_coffee) AppCompatButton mAcbCoffee; *** @OnClick(R.id.acb_coffee) public void onViewClicked() { Intent intent = new Intent(); intent.setAction(CoffeeReceiver.ACTION_COFFEE); sendBroadcast(intent); } }
注意：
- 只有当BroadcastReceiver在AndroidManifest.xml中注册时，才能使用DaggerBroadcastReceiver。 当在动态注册BroadcastReceiver时，推荐使用构造函数注入。
一看前面的代码，使用Dagger2注入广播时，步骤显得复杂了。而，原生动态注册广播也没有几行代码。不过，值得注意的是，使用原生动态注册广播时，每次都得重复的new和注册等操作，而Dagger只要提供依赖关系即可。
关于Dagger的使用流程
对于其他的基本类型，不再举例子，创建模式基本是一样的，比较呆瓜式流程如下：
在ApplicationComponent中注入AndroidInjectionModule,如果项目中用到v4包的Fragment，还需注入AndroidSupportInjectionModule.建议把两个Module都注入XxComponent中，说不定哪位同仁和你想法一样呢…
@Component(modules = {AndroidInjectionModule.class, AndroidSupportInjectionModule,...}) public interface XxComponent { void inject(XxApplication application); }创建Android库的核心类(Activity、Fragment、Service、IntentService、BroadcasReceiver)，需要注意的就是：AndroidInjection.inject(T)方法的调用位置
- 在Activity、Service及IntentService的onCreate()中，super.onCreate()方法以前。
- 在Fragment中onAttach()中，super.onAttach()方法以前。如果是v4包的Fragment，应调用AndroidInjection.inject()方法。
在BroadcastReceiver的onReceive()中，super.onReceive之前调用。
public class CoffeeReceiver extends DaggerBroadcastReceiver { public static final String ACTION_COFFEE = "com.todo.daggerlearn.coffee"; @Inject AppleBean mAppleBean; @Override public void onReceive(Context context, Intent intent) { super.onReceive(context, intent); if (TextUtils.equals(intent.getAction(), ACTION_COFFEE)) { Toast.makeText(context, "这是一杯" + mAppleBean.getName() + "味咖啡", Toast.LENGTH_SHORT).show(); } } }
创建子组件 - @Subcomponent，其继承自AndroidInjector
,而T就是step2创建的Android库的类型 @Subcomponent public interface CoffeeReceiverSubcomponent extends AndroidInjector{ @Subcomponent.Builder public abstract class Builder extends AndroidInjector.Builder { } }
注意：如果该Activity或者Fragment中，含有子Fragment，可以其modules属性中注入其子Fragment的Module。当然这样这也限制了子Fragment的依赖关系。
@Subcomponent(modules = OrangeModule.class) public interface FruitSubcomponent extends AndroidInjector{ @Subcomponent.Builder abstract class Builder extends AndroidInjector.Builder { } }
创建Module，其subcomponents属性值就是step3创建的子组件。在其内必须声明一个抽象方法，该抽象方法返回AndroidInjector.Factory<？>实例，而其参数为step1创建的XxSubcomponent.Builder实例。
@Module(subcomponents = CoffeeReceiverSubcomponent.class) public abstract class CoffeeModule { @Binds @IntoMap @BroadcastReceiverKey(CoffeeReceiver.class) abstract AndroidInjector.Factory bind(CoffeeReceiverSubcomponent.Builder builder); }将创建的Module注入到ApplicationComponent中，即把其添加至ApplicationComponent的modules属性列表
@Component(modules = {AndroidInjectionModule.class, AndroidSupportInjectionModule.class, CoffeeModule.class, ...}) public interface TodoComponent extends AndroidInjector{ @Component.Builder abstract class Builder extends AndroidInjector.Builder { } } 创建Application。在创建时，继承了DaggerApplication，因为dagger把该添加的DispatchingAndroidInjector
添加进去了。但是，并没有实现v4包的HasSupportFragmentInjector，这里需要手动添加进去。 public class TodoApplication extends DaggerApplication implements HasSupportFragmentInjector{ @Inject DispatchingAndroidInjectorfragmentSupportInjector; public void onCreate() { super.onCreate(); } @Override protected AndroidInjector applicationInjector() { return DaggerTodoComponent.builder().create(this); } @Override public AndroidInjector supportFragmentInjector() { return fragmentSupportInjector; } }
值得一提的是，对于Android库的核心类注入要求比较严格，甚至在哪个生命周期内注入都有严格的要求。我们首选的应该是在构造器注入，因为因为javac将确保在设置之前没有引用字段，这样，有助于避免NullPointerExceptions。从而，当需要注入Android库的核心类时，应尽早注入。所以，DaggerActivity在调用super.onCreate()之前,调用AndroidInjection.inject()。而DaggerFragment在调用super.onAttach()之前调用。
对于DaggerFragment而言，可能觉得奇怪，为什么不再super.onCreate()之前调用呢？一是，当Fragment被重新绑定，这样也可以防止不一致；二是，如果已经绑定了Activity的Fragment，又依赖注入了一个Fragment，这时，super.onAttach(fragment)调用AndroidInjection.inject()显得尤为重要了。
更人性化的Dagger2
看了上面的流程，是不是觉得有点模板化了，每创建一个组件，都要重复着这些步骤，有没有优化的可能呢？接下来，我们先看 Dagger2中的一个注解@ContributesAndroidInjector
@Target(METHOD)
public @interface ContributesAndroidInjector {
// 要注入到生成的dagger.Subcomponent中的Module。
Class[] modules() default {};
}
官方文档对它是这么解释的：为其注解的方法生成相应的AndroidInjector。该注射器是 dagger.Subcomponent的实现，而且dagger.Module 的子类。
- 此注释必须应用于返回具体的Android框架类型(例如:FooActivity、BarFragment、MyService等）的dagger.Module中的抽象方法。
- 该方法应该没有参数。
这样，可以将前面的 Dagger的使用流程中的步骤3、4、5省略为：
@Module
public abstract class BookModule {
@ContributesAndroidInjector
abstract BookActivity contributesBookActivity();
}
这样，是不是节省了很多工作，不用再机械式的创建。