一、序
接:Dagger2.1不是Dagger2
demo地址:https://github.com/mrqatom/DaggerInjection
通过学习,我们知道了新版Dagger的用法,可是作为有追求的骚年,不能仅仅成为API的搬运工,必须要了解一下其中具体的用法以及实现方式。首先我们来看看几个注解的具体作用。
二、@Component.Builder
我们在AppComponent里有如下代码
@Component.Builder
interface Builder {
@BindsInstance
Builder application(Application application);
AppComponent build();
}
![](http://img.e-com-net.com/image/info10/b92fff8b7e35496c9c66ec0010bf8228.gif)
我们大概也猜出他的作用,就是自定义构造component
以前我们的用法像这样:
@Module
public class AppModule {
Application application;
public AppModule(Application application) {
this.application = application;
}
@Provides
Application providesApplication() {
return application;
}
@Provides
public SharedPreferences providePreferences() {
return application.getSharedPreferences(DATA_STORE,
Context.MODE_PRIVATE);
}
}
//使用时
DaggerAppComponent appComponent = DaggerAppComponent.builder()
.appModule(new AppModule(this)) //this : application
.build();
![](http://img.e-com-net.com/image/info10/742541445b67432a9d82c8757fd89cad.gif)
现在Dagger允许我们自定义Builder:
@Component(modules = {AppModule.class})
public interface AppComponent {
void inject(MainActivity mainActivity);
@Component.Builder
interface Builder {
AppComponent build();
Builder appModule(AppModule appModule);
}
}
![](http://img.e-com-net.com/image/info10/3b1833b97206409e8f0e20cb4828654f.gif)
就像我们以前的用法一样。这看起来多此一举,不过,配合@BindsInstance就会发生不一样的化学反应,下面我们来看看:
@Module
public class AppModule {
@Provides
@Singleton
public SharedPreferences providePreferences(
Application application) {
return application.getSharedPreferences(
"store", Context.MODE_PRIVATE);
}
}
@Component(modules = {AppModule.class})
public interface AppComponent {
void inject(MainActivity mainActivity);
SharedPreferences getSharedPrefs();
@Component.Builder
interface Builder {
AppComponent build();
@BindsInstance Builder application(Application application);
}
//使用时
DaggerAppComponent appComponent = DaggerAppComponent.builder()
.application(this)
.build();
![](http://img.e-com-net.com/image/info10/bbec5227ca604d28a0b0be3568a613a3.gif)
我们的代码发生了如下改变:
1、AppModule不再需要Application为参数的构造函数,可以直接使用Application
2、component里加入application并加上了@BindsInstance注解,而且无需传入Module
3、使用时无需传入Module而仅仅需要application即可
这个注解有效的简化了Module的初始化并减少了与module的耦合,所以再回头看看demo里的AppComponent是不是更清晰了些呢?
三、@IntoMap
这个注解看名字就可以猜测,用来把什么东西加入map里。
是的,就是把依赖加入map里,先来看看官方简单的例子:
@Module
class MyModule {
@Provides @IntoMap
@StringKey("foo")
static Long provideFooValue() {
return 100L;
}
@Provides @IntoMap
@ClassKey(Thing.class)
static String provideThingValue() {
return "value for Thing";
}
}
@Component(modules = MyModule.class)
interface MyComponent {
Map longsByString();
Map, String> stringsByClass();
}
@Test void testMyComponent() {
MyComponent myComponent = DaggerMyComponent.create();
assertThat(myComponent.longsByString().get("foo")).isEqualTo(100L);
assertThat(myComponent.stringsByClass().get(Thing.class))
.isEqualTo("value for Thing");
}
![](http://img.e-com-net.com/image/info10/13e4a78f177e4cbe8b38bd24241554a2.gif)
我们来梳理一下重点:
1、@intoMap需要和@provides及@binds之类的注解配合使用,这很好理解,就是把依赖in to map而已
2、需要和@mapKey配合使用,即map的key,比如StringKey、ClassKey、ActivityKey...balabala...
3、使用时就和普通map一样
四、@Binds
@Binds和@provides一样,都是提供依赖的作用,也可以说是优化版,我们先来看看@provides的用法:
@Provides
public LoginContract.Presenter
provideLoginPresenter(LoginPresenter loginPresenter) {
return loginPresenter;
}
![](http://img.e-com-net.com/image/info10/23846e23da324c0781c97c854e4f1d9b.gif)
这应该是Dagger使用者比较常见的格式了,相比之下@Binds方式就显得更简洁了:
@Binds
public abstract LoginContract.Presenter
provideLoginPresenter(LoginPresenter loginPresenter);
![](http://img.e-com-net.com/image/info10/12db3494d8ba486d8739b7c227c41a22.gif)
以下是重点:
1、binds方式是抽象方法,无需方法体
2、只能有一个参数且return类型与其相同
3、使用@Binds后该module变为抽象(废话
4、@binds与@provides不得在同一个Module中使用,必须分开写在两个Module里,可以使用include使其关联就像这样
@Module(includes = Declarations.class)
public class MainActivityModule {
@Provides
MainPresenter provideMainPresenter(MainView mainView, ApiService apiService) {
return new MainPresenter(mainView, apiService);
}
}
@Module
public abstract class Declarations {
@Binds
abstract MainView provideMainView(MainActivity mainActivity);
}
![](http://img.e-com-net.com/image/info10/8318457e62a34c78b70b11a4d043959f.gif)
5、如果你一定要将他们写在一个module里,也有方案,把@provides方法变为static即可:
@Module
public abstract class MainActivityModule {
@Binds
abstract MainView provideMainView(MainActivity mainActivity);
@Provides
static MainPresenter provideMainPresenter(MainView mainView, ApiService apiService) {
return new MainPresenter(mainView, apiService);
}
}
![](http://img.e-com-net.com/image/info10/3d44fff3819c4517b194296f93f905c5.gif)
五、源码解析
Dagger2是利用APT自动化形成,这里我就不详述了不然一篇文章根本不够,大家可以自行谷歌关键字:‘APT’、‘编译期注解’
我不会一段一段代码的贴,而是讲述大概流程以及一些思想,避免“休闲式学习”,所以大家需要自己打开源码浏览,如果仅看文章大概率会懵逼:),先来看一段Dagger的初始代码
public class MyApplication extends Application implements HasActivityInjector {
@Inject
DispatchingAndroidInjector dispatchingAndroidInjector;
@Override
public void onCreate() {
super.onCreate();
DaggerAppComponent.builder().application(this).build().inject(this);
}
@Override
public AndroidInjector activityInjector() {
return dispatchingAndroidInjector;
}
}
![](http://img.e-com-net.com/image/info10/5dccf2e926884beaa9e0791e82033952.gif)
继承HasActivityInjector重写activityInjector,定义DispatchingAndroidInjector加上@Inject这里先提一下,后面有用。
主要是 DaggerAppComponent.builder().application(this).build().inject(this) 这句代码,这是一句很明显的建造者模式的代码,是由我们自定义的@Component.Builder形成的,当我们调用.build时会对DaggerAppComponent进行初始化即调用initialize方法,代码如下:
private void initialize(final Builder builder) {
this.mainActivityComponentBuilderProvider =
new Provider() {
@Override
public MainActivityComponent.Builder get() {
return new MainActivityComponentBuilder();
}
};
}
![](http://img.e-com-net.com/image/info10/daad19a140de40818b3c8c3c40053254.gif)
初始化时创建了ActivityBuilder中由@Binds注解的方法return的类,并用Provider封装了一层,其实也就是我们的@Subcomponent.Builder修饰的类而已,这里我们仅有一个MainActivity
这个类实际上只是一个创建者,调用build方法创建真正的实现类:MainActivityComponentImpl,在这个类里会提供我们Module里用provides注解的依赖,我们对比一下:
//Module中
@Provides
MainView provideMainView(MainActivity mainActivity){
return mainActivity;
}
@Provides
MainPresenter provideMainPresenter(MainView mainView, ApiService apiService) {
return new MainPresenter(mainView, apiService);
}
//源码中
private MainView getMainView() {
return MainActivityModule_ProvideMainViewFactory.proxyProvideMainView(
mainActivityModule, seedInstance);
}
private MainPresenter getMainPresenter() {
return MainActivityModule_ProvideMainPresenterFactory.proxyProvideMainPresenter(
mainActivityModule, getMainView(), new ApiService());
}
![](http://img.e-com-net.com/image/info10/039d7415365c4f17addc7e3b7ca72d4f.gif)
proxyProvideMainPresenter其实就是调用module的provideMainPresenter来生成一个Mainpresenter
当MainActivityComponentImpl的inject方法被调用时,以上方法也同时被调用,像这样:
@Override
public void inject(MainActivity arg0) {
injectMainActivity(arg0);
}
private MainActivity injectMainActivity(MainActivity instance) {
//....省略
MainActivity_MembersInjector.injectPresenter(instance, getMainPresenter());
return instance;
}
![](http://img.e-com-net.com/image/info10/bfd332df74ba4aeb8de3699eef866f55.gif)
MainActivity_MembersInjector.injectPresenter会将生成的Mainpresenter注入到MainActivity里,也就完成了依赖注入。
至于inject方法什么时候被调用,以及MainActivity如何传入的留待后文分析,我们先回到初始化的地方。
DaggerAppComponent构建完成之后,又调用了他的Inject方法,这个方法了只做了一件事,就是初始化MyApplication中的
DispatchingAndroidInjector,而他里面就保存了我们上面提到的MainActivityComponentBuilder,如果有多个Activity的话,就会把他们保存到一个map中,key为activity名字,这就是@IntoMap的作用了。
所以DispatchingAndroidInjector其实提供了一个仓库的作用,仓库里保存了我们在ActivityBuilder里@binds修饰的类,其实也就是我们所有的Activity
还记得我们在MyApplication中重写的方法吗?
@Override
public AndroidInjector activityInjector() {
return dispatchingAndroidInjector;
}
![](http://img.e-com-net.com/image/info10/6a99437abd4c4865a3c187c54b0e78b7.gif)
通过这个方法就可以获取到该“仓库”,然后一步步获取到真正的实现类完成依赖注入,具体我们继续看。
那我们Activity如何获取到该’仓库‘呢?在每一个Activity中都需要调用一句代码:
AndroidInjection.inject(this);
//实现
public static void inject(Activity activity) {
checkNotNull(activity, "activity");
//拿到application
Application application = activity.getApplication();
//判断application是否继承了HasActivityInjector
if (!(application instanceof HasActivityInjector)) {
throw new RuntimeException(
String.format(
"%s does not implement %s",
application.getClass().getCanonicalName(),
HasActivityInjector.class.getCanonicalName()));
}
//通过刚刚讲到的方法拿到“仓库”
AndroidInjector activityInjector =
((HasActivityInjector) application).activityInjector();
checkNotNull(activityInjector, "%s.activityInjector() returned null", application.getClass());
//调用“仓库”的inject方法,并传入了相应的Activity
activityInjector.inject(activity);
}
![](http://img.e-com-net.com/image/info10/f8ed4da44d854cd0b5bcc3bdefdc24b6.gif)
“仓库”的inject方法会在map里找到我们之前所说的真正实现类完成所有依赖注入工作。
因为“仓库”保存了我们所有Activity,所以只要在Activity里调用上述代码就能完成该Activity的依赖注入。
至于Fragment的注入是如何实现由读者自行阅读,就是在Activity依赖注入实现类里又创建了一个Fragment的ComponentBuilder而已,类似于递归的思想。
至于@ContributesAndroidInjector的实现方式就是和基本版相同,只是自动生成了component而已,帮我们简化了操作。
总结
看完大家可能觉得Dagger源码解析部分很少,事实上Dagger的源码确实不算难,适合刚刚学习看源码的童鞋,克服源码的恐惧就是现在了。至于编译期注解方面的知识,建议大家去看Arouter源码上手。
Dagger的思想是非常优秀的,加上现在更新的越来越简洁,非常推荐大家尝试使用。
课外拓展:研究@Singleton以及@scope的源码实现