Dagger2:上手就爱不释手

概览:

  • 什么是Dagger2?
    既然有Dagger2那么必然有Dagger1的存在,Dagger1是大名鼎鼎的Square公司受到Guice启发而开发的依赖注入框架,而Dagger2是Dagger1的分支,由谷歌公司接手开发。

  • 为什么使用Dagger2?
    1.有利于模块间的解耦,组件依赖的注入独立于业务模块之外
    2.能够清晰地管理实例的有效范围
    3.因为对象的实例化独立于业务,所以当对象的实例化方法改变时,不需要大量地修改业务代码
    4.在编译期即完成依赖的注入,完全静态(说白了就是抛弃了反射)

深入研究

前言讲了那么多,接下来着重从原理和代码方面进行分析

引入Dagger2

Dagger2的引入也非常方便,首先在项目的gradle中配置:

 dependencies { 
         classpath 'com.neenbedankt.gradle.plugins:android-apt:1.4' 
}```   
然后在app的gradle中配置:

apply plugin: 'com.neenbedankt.android-apt'
...
dependencies {
apt 'com.google.dagger:dagger-compiler:2.0'
compile 'com.google.dagger:dagger:2.0'
}

可以看到gradle中出现了apt相关的配置,可以猜到Dagger2的生成与apt技术相关,即通过定义编译期的注解,再通过继承Proccesor生成代码逻辑,有兴趣的同学可以深入学习一番

###  使用详解

引入了Dagger2之后,首先解释一下Dagger2中的四种常用用法
- _ @Inject_  
主要有两种用法:一是标注相关的构造方法,那么Dagger2在使用时会找到标注有@Inject的构造方法来实例化;第二种是标注在相关的变量,告知Dagger2为其提供依赖

- _@Component_ 
@Component用于标注接口,是依赖需求方和依赖提供方之间的桥梁。被Component标注的接口在编译时会生成该接口的实现类(如果@Component标注的接口为ApplicationComponent,则编译期生成的实现类为DaggerApplicationComponent),我们通过调用这个实现类的方法完成依赖注入;
- _@Module_ 
@Module用于标注提供依赖的类,但涉及到一些第三方包中的构造方法,或者有参数的构造方法时,我们无法使用@Inject,转而使用@Module进行标注

- _@Provide_
@Provide
用于标注@Module中的方法,提供实例化的操作,并在需要时将依赖注入标注了@Inject的变量

随后这几种注解结合上述基本用法,有意想不到的妙用
- _@Qulifier_ 
@Qulifier 为了区分不同使用不同类型生成的实例,比如@ForActivity 或@ForApplication

- _@Scope_ 
可限定变量的生效范围,形成局部单例

- _@Singleton_ 
这个就比较好理解了,Application级别的单例

只是介绍了基本用法,可能理解起来还是一头雾水,我们接下来结合代码进行进一步阐述

1.仅使用@Inject
首先定义实体类Coke,并用@Inject标注构造方法

public class Coke {
@Inject
public Coke() {
Log.d("process", "a cup of coke was made");
}
}


第二步创建Component,命名为CokeComponent。inject方法即代表依赖注入至MainActivity

@Component
public interface CokeComponent
{
void inject(MainActivity activity);
}


在MainActivity中定义变量,并用@Inject标注
```java
public class MainActivity extends AppCompatActivity 
{   
//定义变量并标注
@Inject  Coke coke;    
@Override    
protected void onCreate(Bundle savedInstanceState) 
{
  super.onCreate(savedInstanceState);        
  setContentView(R.layout.activity_main); 
//DaggerCokeComponent由CokeComponent生成,调用下面的方法实现依赖注入
  DaggerCokeComponent.builder().build().inject(this);    
}
}

运行程序,则log中打印出:

D/process: a cup of coke was made

然而事实上,我们更多遇到是构造函数含参或者无法直接打上@Inject标记的情况,那么此时就要使用@Module进行依赖注入

2.结合@Module使用

假设我们现在制造一瓶可乐的构造方法为:public Coke(String ingredient),然后创建一个Module,并命名为CokeModule。用@Provide标注提供实例的方法,并在方法体内加入实例化相关的代码

@Module  
public class CokeModule
{    
public CokeModule() {} 
   
@Provides    
Coke provideCoke()  {        
    return new Coke("with suger");    
  }  
}

并对Component进行一点修改,告知Dagger2使用CokeModule提供依赖

@Component (modules = {CokeModule.class})
public interface CokeComponent {    
void inject(MainActivity activity);
}

运行程序,结果为:

D/process: a cup of coke was made with suger

3.结合@Qulifier使用

首先用@Qulifier定义两个注解

@Qualifier
@Retention (RetentionPolicy.RUNTIME)
public @interface QulifierNonSuger {}
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface QulifierSuger {}

其次对CokeModule进行一点改造,支持两种实例化方式

@Module
public class CokeModule {   
  public CokeModule() {}    
@QulifierSuger    
@Provides   
Coke provideCokeWithSuger() {        
return new Coke("with suger");   
 }    
@QulifierNonSuger    
@Provides    
Coke provideCokeWithoutSuger() {        
    return new Coke("without suger");    
 }
}

在MainActivity创建两个Coke变量,并分别用两种Qulifier注解

@QulifierSuger 
@Inject
Coke cokeA;

@QulifierNonSuger
@Inject
Coke cokeB;

运行程序,两杯不同的可乐就制造出来啦

D/process: a cup of coke was made with suger
D/process: a cup of coke was made without suger

Dagger2:上手就爱不释手_第1张图片
@Qulifier.png

通过上图,我们可以清晰地看出,Module中通过两种Qulifier注解表示了两种实例化对象的方法,Component通过Module中提供的方法将依赖注入标注了不同Qulifier的两个变量

4.结合@Scope使用

好吧,我们继续进行改造~
第一步,定义注解ActivityScope

@Scope
@Retention (RetentionPolicy.RUNTIME)
public @interface ActivityScope {}

然后用该Scope标注Component和Module

@Module
public class CokeModule {        
public CokeModule() {}    
@ActivityScope    
@Provides    
Coke provideCokeWithSuger() {        
return new Coke("with suger");    
  }
}
@ActivityScope
@Component(modules = {CokeModule.class})
public interface CokeComponent {   
 void inject(MainActivity activity);
}

我们在MainActivity中定义了两个Coke变量,但可以看到Log只打印了一次,即代表Coke变量在MainActivity范围内是局部单例的

5.扩展应用

Dagger2:上手就爱不释手_第2张图片
Dependent Components.png

如图,Component之间也可以有依赖关系,Dagger2的实际运用中,我们常定义一个应用级别单例的ApplicationComponent来保持对Application的依赖,根据不同粒度(Activity级别或者页面级别)创建依赖于ApplicationComponent的其余Component进行整个应用的依赖注入控制

至此,一个简单的依赖注入使用案例已经结束,但大多数的同学应该还意犹未尽吧,因此我们接下来从Dagger2自动生成的代码层面深入了解Dagger2是如何工作的。

原理探究

这里我们以例子中的情况2作样本,Dagger2生成的代码可以在Build->generated->source->apt中找到

  • CokeModule_ProvideCokeWithSugerFactory

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

代码比较简单,构造方法中传入了CokeModule,get()中通过我们在Module创建的provideCokeWithSugaer()拿到Coke的实例,而create方法我们稍后进行解释

  • MainActivity_MembersInjector
@Generated("dagger.internal.codegen.ComponentProcessor")
public final class MainActivity_MembersInjector implements MembersInjector {  
private final MembersInjector supertypeInjector;  
private final Provider cokeAndCokeAProvider;  
public MainActivity_MembersInjector(MembersInjector supertypeInjector, Provider cokeAndCokeAProvider) {     
assert supertypeInjector != null;    
this.supertypeInjector = supertypeInjector;    
assert cokeAndCokeAProvider != null;   
this.cokeAndCokeAProvider = cokeAndCokeAProvider;  
  }  
@Override  public void injectMembers(MainActivity instance) {     
 if (instance == null) {      
throw new NullPointerException("Cannot inject members into a null reference");    }    
//依赖注入
supertypeInjector.injectMembers(instance);     
instance.coke = cokeAndCokeAProvider.get();  
  }  
public static MembersInjector create(MembersInjector supertypeInjector, Provider cokeAndCokeAProvider) {       
 return new MainActivity_MembersInjector(supertypeInjector, cokeAndCokeAProvider);  
  }
}

构造方法中传入了Injector和Provider,injectMembers()中将instance(MainActivity)通过回调传给Injector,并从Provider中取出Coke的实例赋值给instance。代码最后又出现了create,我们可以肯定有一个桥梁将两者串联在一起,那就是——请继续往下看

  • DaggerCokeComponent
@Generated("dagger.internal.codegen.ComponentProcessor")
public final class DaggerCokeComponent implements CokeComponent {  
private Provider provideCokeWithSugerProvider;  
private MembersInjector mainActivityMembersInjector;  
private DaggerCokeComponent(Builder builder) {      
assert builder != null;    
initialize(builder);  
}  
public static Builder builder() {      
return new Builder();  
}  
public static CokeComponent create() {      
return builder().build();  
}  
private void initialize(final Builder builder) {      
this.provideCokeWithSugerProvider = ScopedProvider.create(CokeModule_ProvideCokeWithSugerFactory.create(builder.cokeModule));    
this.mainActivityMembersInjector = MainActivity_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), provideCokeWithSugerProvider);  }  
@Override  public void inject(MainActivity activity) {   
  mainActivityMembersInjector.injectMembers(activity);  
}  
public static final class Builder {    
private CokeModule cokeModule;      
private Builder() {      }     
public CokeComponent build() {       
 if (cokeModule == null) {        
this.cokeModule = new CokeModule();      
}      
return new DaggerCokeComponent(this);    
}      
public Builder cokeModule(CokeModule cokeModule) {        
if (cokeModule == null) {        
throw new NullPointerException("cokeModule");      
}      
this.cokeModule = cokeModule;      
return this;    
    }  
  }
}

谜底揭开了,结合我们在MainActivity中注入依赖的方法:
DaggerCokeComponent.builder().cokeModule(new CokeModule()).build().inject(this)
在Builder中,传入创建的CokeModule,可以看到Dagger2贴心地帮我们做了缺省设置,直接调用build()也可以生成CokeModule。然后调用DaggerCokeComponent的构造方法,在initialize中我们终于看到了刚才的两个create方法,也就是通过这座桥梁完成了实例的提供和注入。

后记

1.文中的图摘自CodePath Android Cliffnotes,原文为:Dependency Injection with Dagger 2
2.注意事项:当更新Dagger2的版本时,需重新clean项目,否则会出现actual and former argument lists different in length

你可能感兴趣的:(Dagger2:上手就爱不释手)