一.Dagger2注入原理

Dagger2以自动生成代码的形式,帮助我们构建依赖图,在使用依赖的时候方便清晰,这里说明一点,在我们使用Dagger2的时候,绝大多数错误都是编译器就会暴漏出来,这也就决定了这套框架的稳定性会更高。

关于生成的源码,我们一起看一下。我们就以之前提到的例子来看:

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class DaggerApplicationComponent implements ApplicationComponent {
private Provider<Application> applicationProvider;
private Provider<Context> contextProvider; private DaggerApplicationComponent(Builder builder) {
assert builder != null;
initialize(builder);
} public static Builder builder() {
return new Builder();
} private void initialize(final Builder builder) {
this.applicationProvider = ApplicationModule_ApplicationFactory.create(builder.applicationModule);
this.contextProvider = ApplicationModule_ContextFactory.create(builder.applicationModule);
} @Override
public Application application() {
return applicationProvider.get();
} @Override
public Context context() {
return contextProvider.get();
} public static final class Builder {
private ApplicationModule applicationModule;
private GsonModule gsonModule; private Builder() {
} public ApplicationComponent build() {
if (applicationModule == null) {
throw new IllegalStateException("applicationModule must be set");
}
if (gsonModule == null) {
this.gsonModule = new GsonModule();
}
return new DaggerApplicationComponent(this);
} public Builder applicationModule(ApplicationModule applicationModule) {
if (applicationModule == null) {
throw new NullPointerException("applicationModule");
}
this.applicationModule = applicationModule;
return this;
} public Builder gsonModule(GsonModule gsonModule) {
if (gsonModule == null) {
throw new NullPointerException("gsonModule");
}
this.gsonModule = gsonModule;
return this;
}
}
}

可以看到DaggerApplicationComponent中,有一个建造者模式来构建一个ApplicationComponent对象,这也帮我们初始化了两个Module中的依赖,但是注意,这里并没有直接初始化所有模块内的依赖,而只是初始化了组件对象而已。

可以看到initialize方法中有两个工厂方法。

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class ApplicationModule_ContextFactory implements Factory<Context> {
private final ApplicationModule module; public ApplicationModule_ContextFactory(ApplicationModule module) {
assert module != null;
this.module = module;
} @Override
public Context get() {
Context provided = module.context();
if (provided == null) {
throw new NullPointerException("Cannot return null from a non-@Nullable @Provides method");
}
return provided;
} public static Factory<Context> create(ApplicationModule module) {
return new ApplicationModule_ContextFactory(module);
}
}

可以看出这个工厂中一直保留着ApplicationModule,当我们每次获取依赖,则会重新调用Module的context()方法,即如果里面是new的形式提供依赖 ,则会重新创建对象。

而反观我们用PerActivity标注的ToasterProvider:

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class DaggerActivityComponent implements ActivityComponent {
private Provider<Context> contextProvider;
private MembersInjector<BaseActivity> baseActivityMembersInjector;
private Provider<Toaster> provideToasterProvider;
private Provider<Toaster> provideTheToasterProvider; private DaggerActivityComponent(Builder builder) {
assert builder != null;
initialize(builder);
} public static Builder builder() {
return new Builder();
} private void initialize(final Builder builder) {
this.contextProvider = new Factory<Context>() {
private final ApplicationComponent applicationComponent = builder.applicationComponent;
@Override public Context get() {
Context provided = applicationComponent.context();
if (provided == null) {
throw new NullPointerException("Cannot return null from a non-@Nullable component method");
}
return provided;
}
};
this.baseActivityMembersInjector = BaseActivity_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), contextProvider);
this.provideToasterProvider = ScopedProvider.create(ActivityUtilModule_ProvideToasterFactory.create(builder.activityUtilModule));
this.provideTheToasterProvider = ActivityUtilModule_ProvideTheToasterFactory.create(builder.activityUtilModule);
} @Override
public void inject(BaseActivity activity) {
baseActivityMembersInjector.injectMembers(activity);
} @Override
public Toaster theToaster() {
return provideToasterProvider.get();
} @Override
public Toaster toaster() {
return provideTheToasterProvider.get();
} public static final class Builder {
private ActivityUtilModule activityUtilModule;
private ApplicationComponent applicationComponent; private Builder() {
} public ActivityComponent build() {
if (activityUtilModule == null) {
throw new IllegalStateException("activityUtilModule must be set");
}
if (applicationComponent == null) {
throw new IllegalStateException("applicationComponent must be set");
}
return new DaggerActivityComponent(this);
} public Builder activityUtilModule(ActivityUtilModule activityUtilModule) {
if (activityUtilModule == null) {
throw new NullPointerException("activityUtilModule");
}
this.activityUtilModule = activityUtilModule;
return this;
} public Builder applicationComponent(ApplicationComponent applicationComponent) {
if (applicationComponent == null) {
throw new NullPointerException("applicationComponent");
}
this.applicationComponent = applicationComponent;
return this;
}
}
}

provideToasterProvider则和其他初始化方式不同,可以看到后面ProviderToaster的工厂很普通:

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class ActivityUtilModule_ProvideToasterFactory implements Factory<Toaster> {
private final ActivityUtilModule module; public ActivityUtilModule_ProvideToasterFactory(ActivityUtilModule module) {
assert module != null;
this.module = module;
} @Override
public Toaster get() {
Toaster provided = module.provideToaster();
if (provided == null) {
throw new NullPointerException("Cannot return null from a non-@Nullable @Provides method");
}
return provided;
} public static Factory<Toaster> create(ActivityUtilModule module) {
return new ActivityUtilModule_ProvideToasterFactory(module);
}
}

那么ScopedProvider.create包住的工厂有什么特别的呢?

public final class ScopedProvider<T> implements Provider<T> {
private static final Object UNINITIALIZED = new Object(); private final Factory<T> factory;
private volatile Object instance = UNINITIALIZED; private ScopedProvider(Factory<T> factory) {
assert factory != null;
this.factory = factory;
} @SuppressWarnings("unchecked") // cast only happens when result comes from the factory
@Override
public T get() {
// double-check idiom from EJ2: Item 71
Object result = instance;
if (result == UNINITIALIZED) {
synchronized (this) {
result = instance;
if (result == UNINITIALIZED) {
instance = result = factory.get();
}
}
}
return (T) result;
} /** Returns a new scoped provider for the given factory. */
public static <T> Provider<T> create(Factory<T> factory) {
if (factory == null) {
throw new NullPointerException();
}
return new ScopedProvider<T>(factory);
}
}

我们看下源码,这里的create是创建了一个ScopeProvider的对象,并将工厂传入,当这个ScopeProvider去get的时候,内部有个单例来维持这个对象,这就是为什么我们自定义注解是个单例的秘密。

接下来看看神器的注解是怎么起作用的。

public final class BaseActivity_MembersInjector implements MembersInjector<BaseActivity> {
private final MembersInjector<FragmentActivity> supertypeInjector;
private final Provider<Context> contextProvider; public BaseActivity_MembersInjector(MembersInjector<FragmentActivity> supertypeInjector, Provider<Context> contextProvider) {
assert supertypeInjector != null; this.supertypeInjector = supertypeInjector; assert contextProvider != null; this.contextProvider = contextProvider;
} public void injectMembers(BaseActivity instance) {
if(instance == null) {
throw new NullPointerException("Cannot inject members into a null reference");
} else {
this.supertypeInjector.injectMembers(instance);
instance.context = (Context)this.contextProvider.get();
}
} public static MembersInjector<BaseActivity> create(MembersInjector<FragmentActivity> supertypeInjector, Provider<Context> contextProvider) {
return new BaseActivity_MembersInjector(supertypeInjector, contextProvider);
}
}

在我们注入这个对象后,injectMembers方法中,写明了BaseActivity中的context对象是从ContextProvider的get方法中得到,根据代码也可以看到,这部分依赖是从ApplicationComponent中的provideContext方法取得。

再看看Lazy Load:

public final class DoubleCheckLazy<T> implements Lazy<T> {
private static final Object UNINITIALIZED = new Object(); private final Provider<T> provider;
private volatile Object instance = UNINITIALIZED; private DoubleCheckLazy(Provider<T> provider) {
assert provider != null;
this.provider = provider;
} @SuppressWarnings("unchecked") // cast only happens when result comes from the factory
@Override
public T get() {
// to suppress it.
Object result = instance;
if (result == UNINITIALIZED) {
synchronized (this) {
result = instance;
if (result == UNINITIALIZED) {
instance = result = provider.get();
}
}
}
return (T) result;
} public static <T> Lazy<T> create(Provider<T> provider) {
if (provider == null) {
throw new NullPointerException();
}
return new DoubleCheckLazy<T>(provider);
}
}

toasterLazy加载的时候是使用DoubleCheckLazy.create(this.toasterLazyProvider)来进行初始化。而内部是个单例,只有在get时才会初始化。

至此,Dagger2的主要源码就差不多理解了。

二.使用分析

Dagger2很优雅,优雅到你可以特别轻松的调试它,以为他和你手写的代码几乎一模一样,又优雅到几乎所有的错误都从编译器暴露出。

与RoboGuice的反射不同,生成代码必然会导致方法数的增加。但是,我们可以看到生成的代码数量并不多,而且在实际应用过程中也可以看出,确实影响不大,这个可以大家在以后的使用中慢慢体会。

性能上Dagger2会优于RoboGuice,尤其是天生支持懒加载,但是在易用性上,RoboGuice更容易上手和理解,并且针对Android做了很多通用依赖,为项目开发提高便利。

综上,如果是一个小而美的应用,使用RoboGuice可以快速帮你完成开发工作,而Dagger2在长期来看,性能和效率更佳。

至此,Dagger2入坑系列结束。

Dagger2 (三) 总结篇的更多相关文章

  1. Delphi 泛型(三十篇)

    Delphi 泛型(三十篇)http://www.cnblogs.com/jxgxy/category/216671.html

  2. Dagger2 (二) 进阶篇

    一.作用域Scope 之前了解RoboGuice的时候,我们知道它默认给我们提供了几个注解,ContextSingleton和Singleton,但是Dagger2更为灵活,只有javax包中提供的S ...

  3. JavaScript 面向对象(三) —— 高级篇

    JavaScript 面向对象(一) —— 基础篇 JavaScript 面向对象(二) —— 案例篇 一.json方式的面向对象 首先要知道,js中出现的东西都能够放到json中.关于json数据格 ...

  4. 读懂IL代码就这么简单(三)完结篇

    一 前言 写了两篇关于IL指令相关的文章,分别把值类型与引用类型在 堆与栈上的操作区别详细的写了一遍 这第三篇也是最后一篇,之所以到第三篇就结束了,是因为以我现在的层次,能理解到的都写完了,而且个人认 ...

  5. ios -- 教你如何轻松学习Swift语法(三) 完结篇

    前言:swift语法基础篇(二)来了,想学习swift的朋友可以拿去参考哦,有兴趣可以相互探讨,共同学习哦.      一.自动引用计数   1.自动引用计数工作机制      1.1 swift和o ...

  6. Android UI开发第三十三篇——Navigation Drawer For Android API 7

    Creating a Navigation Drawer中使用的Navigation Drawer的android:minSdkVersion="14",现在Android API ...

  7. Android UI开发第三十一篇——Android的Holo Theme

    好长时间没写Android UI方面的文章了,今天就闲扯一下Android的Holo主题.一直做android开发的可能都知道,Android 系统的UI有过两次大的变化,一次是android 3.0 ...

  8. JDK源码学习--String篇(三) 存储篇

    在进一步解读String类时,先了解下内存分配和数据存储的. 数据存储 1.寄存器:最快的存储区,位于处理器的内部.由于寄存器的数量有限,所以寄存器是按需分配. 2.堆栈:位于RAM中,但是通过堆栈指 ...

  9. Java 面试知识点解析(三)——JVM篇

    前言: 在遨游了一番 Java Web 的世界之后,发现了自己的一些缺失,所以就着一篇深度好文:知名互联网公司校招 Java 开发岗面试知识点解析 ,来好好的对 Java 知识点进行复习和学习一番,大 ...

随机推荐

  1. ReactNative&weex&DeviceOne对比

    React Native出来有一段时间了,国内的weex和deviceone是近期发布的,我可以说从2011年就开始关注快速开发的跨平台平台技术了,接触过phoneGap.数字天堂.appcan等早期 ...

  2. 再见Windows C++

    我3年多以前写过一个小工具,是用来检测Windows操作系统的版本及其所安装的.NET Framework版本的,我用它来排查由于缺乏运行环境支持所导致的程序无法运行的问题.这个工具是用Visual ...

  3. IKAnalyzer

    我们的项目中中文切词使用的是mmseg,有一个不满意的地方是jar包中的默认词典一定会被加载进去,当我对有些term有意见时,无法删除. mmseg中Dictionary.java里一段代码保证了/d ...

  4. Convert.ToInt32()、int.Parse()和(int)三者的区别

    Convert.ToInt32将object类类型转换成int类型,如Convert.ToInt32(session["shuzi"]); (int)适合简单数据类型之间的转换: ...

  5. 解析大型.NET ERP系统 多国语言实现

    实现多国语言有许多种实现方案,无外乎是一种字符串替换技术,将界面控件的文本标签替换成相应语言的文字..NET Windows Forms实现多国语言的方法有以下几种: 1 .NET的方案,使用资源文件 ...

  6. T-SQL检查停止的复制作业代理,并启动

        有时候搭建的复制在作业比较多的时候,会因为某些情况导致代理停止或出错,如果分发代理时间停止稍微过长可能导致复制延期,从而需要从新初始化复制,带来问题.因此我写了一个脚本定期检查处于停止状态的分 ...

  7. 基本数据结构(1)——算法导论(11)

    1. 引言     从这篇博客开始,来介绍一些基本的数据结构知识.本篇及下一篇会介绍几种基本的数据结构:栈.队列.链表和有根树.此外还会介绍由数组构造对象和指针的方法.     这一篇主要介绍栈和队列 ...

  8. “前.NET Core时代”如何实现跨平台代码重用 ——程序集重用

    除了在源代码层面实现共享("前.NET Core时代"如何实现跨平台代码重用 --源文件重用)之外,我们还可以跨平台共享同一个程序集,这种独立于具体平台的"中性" ...

  9. C#:浅析结构与类的区别

    一.      结构:值类型,存储在堆栈中,位于计算机的内存逻辑区域中      类   :引用类型,存储在堆中,位于计算机内存的不同逻辑位置   二.      较小的数据使用结构:      将一 ...

  10. SharePoint 2103 Check user permission on list

    一.需求: check user 对SharePoint list 的permission 代码如下: private static string GetListPermission(SPList l ...