dagger2入门指南

dagger2入门指南

参考Dagger2 Wiki，在Gradle中添加以下依赖


dependencies {
provided 'javax.annotation:javax.annotation-api:1.2'
compile 'com.google.dagger:dagger:2.0.2'
apt 'com.google.dagger:dagger-compiler:2.0.2'
}


apt是一个Gradle插件，协助Android Studio 处理Annotation Processors，所以在Gradle中还必须添加以下内容(关于Android-apt更多内容参考)


dependencies {

classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
}


apply plugin: 'com.neenbedankt.android-apt'
开始使用

Dagger2是实现依赖注入的一种手段，关于依赖注入，这里就不多介绍，想了解的可以参考, Dagger2中需要使用注解来完成依赖注入，我们来一个个介绍这些注解

@Inject

我们可以使用@Inject这个注解来标注目标类中所依赖的其他类，也可以用来标注所依赖的其他类的构造函数。举个例子


public class Human{

@Inject
Father father;
}

public class Father{

@Inject

public Father(){ //如果标注有参数的构造方法，在调用构造方法前会去获取参数对应的对象

}
}


当Human需要通过@Inject注入Father这个类的时候，会先调用Father中标注的构造函数，生成相应的对象。这样Human和Father之间就有了一种无形的联系，但是仅仅这样还不够，我们还需要用到Component来使他们连接起来

@Component

@Component的作用就是连接目标类和目标类依赖实例（可以通过上面说的@Inject标注构造函数也可以通过@Module来产生）。那Component是怎么工作的呢？

• 查找目标类中用@Inject标注的属性

• 查找对应属性依赖实例

• 将依赖实例进行赋值

目标类需要初始化自己依赖的其他类还需要调用Component的inject(Object object)方法开始注入

@Singleton @Component(modules = { ApplicationModule.class},dependencies={xxxComponent.class})
public interface ApplicationComponent {
Context getContext();
void inject(MyApplication mApplication);
}


比如在MyApplication中需要注入其他类，则需要在MyApplication中调用ApplicationComponent的inject方法开始注入。

• modules对应的就是提供依赖的Module类，可以有多个
• dependencies表示该Component还依赖其他Component
• @Singleton是一种Scope注解，下面会说到

@Module

介绍@Inject的时候我们说过，可以通过@Inject标注构造函数生成对应的对象，但是如果是第三方类库，我们无法添加@Inject注解的时候该怎么办，这时候就需要用到@Module了。举个列子


@Modulepublic class Module{

//A是第三方类库中的一个类

@Provides
A provideA(){

return A();

}}


• 通过provideA()这个方法我们就可以生成一个A的实例，目标类中可以通过@Inject来注入

• @provides标注的方法直接返回以创建或者新创建的对象，只在Module中使用

• Component会首先从Module中查找需要注入的实例，如果找到了，则停止，如果没有找到则是继续从Inject标注的构造函数查找

@Qualifier

通过上面我们知道，创建类的实例有两种方式，这两个方式有先后之分，但是如果一个类在同一方式下有多个创建类的方法的时候，Component会选取哪个方法来创建这个类的实例呢？举个例子

@Module
public class Module{

@Provides
A provideA(){
return A();
}

@provides
A provideOtherA(){
return A();
}
}


如果我们按照上面这样写，Dagger2在编译的时候就会报错，那么我们改如何解决呢？这时候就需要用到@Qualifier了，我们可以用这个注解给不同的创建实例的方法进行标识并加以区分。

@Module
public class Module{

@Named("firstA")
@Provides
A provideFirstA(){
return A();
}
@Named("secondA")
@provides
A provideSecondA(){
return A();
}
}


@Named是Dagger2对于@Qualifier一个默认实现，我们也可以自定义，比如@ForApplication和@ForAcitivity来标识不同的Context

@Qualifier
@Documented
@Retention(RUNTIME)
public @interface Named {
/** The name. */
String value() default "";
}


这样，通过@Named我们就可以区分不同的实例了

public class Human{
@Inject
@Named("firstA")
A firstA;
@Named("secondA")
@provides
A secondA;
}


@Scope

Scope是一个注解作用域，通过自定义注解限定对象的作用范围。通过这个注解能够解决不同对象生命周期不一致的问题，比如Application,ToastHelper等存在于应用的整个生命周期，Adapter,Presenter等则随着Activity的销毁而销毁。我们可以通过自定义不同的Scope来区分。举个例子

@Scope
@Documented
@Retention(RUNTIME)
public @interface PerApp{}


@PerApp @Component(modules = { ApplicationModule.class})
public interface ApplicationComponent {
Context getContext();
void inject(MyApplication mApplication);
}


@Module
public class ApplicationModule {
private final Context context;
public ApplicationModule(Context context) {
this.cOntext= context;
}
@Provides @PerApp public Context provideApplicationContext() {
return context.getApplicationContext();
}
}


我们在ApplicationModule中定义了创建Context实例的方法，在ApplicationComponent中管理ApplicationModule，因为ApplicationComponent只有在Application中实例化一次，所以Context的生命周期也就和Application一样了，也就是Dagger并不会帮你管理生命周期，只能自己来控制。那么PerApp这个注解有什么用呢？

• 更好的管理Component与Module之间的匹配关系，Dagger2在编译的时候会检查Component管理的Module，若发现Component所标注的自定义Scope注解与Module中不一样，就会报错。
• 提高可读性,通过PerApp就知道是在整个Application有小范围内

注意点：

• 一个Module中只能存在一种Scope
• Scope标注的Component和所依赖的Component的Scope不能一样

创建ApplicationComponent

@PerApp
@Component(modules = { ApplicationModule.class })
public interface ApplicationComponent {
Context getContext();
ToastUtils getToastUtils();
}


ApplicationComponent是一个全局的Component,负责管理整个App的全局类实例，Context getContext();和ToastUtils getToastUtils();是将Context和ToastUtils暴露给子Component。

创建ApplicationModule

@Module
public class ApplicationModule {
private final MyApplication myApplication;
public ApplicationModule(MyApplication myApplication) {
this.myApplication = myApplication;
}
@PerApp @Provides Context provideContext() {
return myApplication.getApplicationContext();
}
@PerApp @Provides ToastUtils provideToastUtils(Context mContext) {
return new ToastUtils(mContext);
}
}


ApplicationModule生成全局Context和ToastUtils实例

在Application中创建ApplicationComponent实例

public class MyApplication extends Application {
private ApplicationComponent mApplicationComponent;
@Override public void onCreate() {
super.onCreate();
mApplicatiOnComponent=
DaggerApplicationComponent.builder().applicationModule(new ApplicationModule(this)).build();
}
public ApplicationComponent getApplicationComponent() {
return mApplicationComponent;
}
}


DaggerApplicationComponent这个是有Dagger2生成的类，因为ApplicationComponent只初始化一次，所以注入的类都是单例的，这就是Dagger2真正创建单例的方法。

划分Component

一个应用应该包含一个全局的Component，负责管理整个全局类的实例，其他Componet建议按照页面来划分。

@PerActivity
@Component(dependencies = ApplicationComponent.class, modules = {
MainModule.class, ActivityModule.class
})
public interface MainComponent {
void inject(MainActivity mActivity);
}


@Module
public class MainModule {
@PerActivity @Provides GetUser getUser() {
return new GetUser();
}
}


@PerActivity
@Component(modules = { ActivityModule.class })
public interface ActivityComponent {
Activity getActivity();
}


@Module
public class ActivityModule {
private final Activity mActivity;
public ActivityModule(Activity mActivity) {
this.mActivity = mActivity;
}
@Provides @PerActivity Activity provideActivity() {
return mActivity;
}
}


上面是Main这个页面的划分

demo