详细Dagger2入门

最新推荐文章于 2024-03-12 09:46:33 发布

A@风

最新推荐文章于 2024-03-12 09:46:33 发布

阅读量187

点赞数

CC 4.0 BY-SA版权

分类专栏： dagger 文章标签： Dagger2 注入解耦和

原文链接：https://blog.youkuaiyun.com/lv_fq/article/details/78777731

dagger 专栏收录该内容

1 篇文章

订阅专栏

本文是作者在学习Dagger2入门的一篇很好的文章，特此在此转载，非原创
Dagger官网
Dagger Document API
从零开始的Android新项目4
http://www.bozhiyue.com/anroid/boke/2016/0719/273761.html

环境配置
这里以Gradle配置为例子，实用得是AndroidStudio：

打开project 的 build.gradle ，添加

dependencies {
classpath ‘com.android.tools.build:gradle:2.2.2’

    // NOTE: Do not place your application dependencies here; they belong
    // in the individual module build.gradle files

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

打开 app module 的 build.gradle，添加

apply plugin: ‘com.android.application’
//dagger2
apply plugin: ‘com.neenbedankt.android-apt’

//…

dependencies {
//…

//dagger2
compile 'com.google.dagger:dagger:2.4'
apt 'com.google.dagger:dagger-compiler:2.4'
compile 'org.glassfish:javax.annotation:10.0-b28'

}

然后sync gradle一下，环境就配置好了，在实用dagger2的时候，会自动生成一些类，所以最好记一下 build project的快捷键 ctrl+F9，写好dagger代码，然后build一下，就会自动生成 DaggerXXX 开头的一些类。

入门实例
好了，下面我们来看一个入门实例，实用Dagger2到底是怎么依赖注入的。
现在又一个Person类（这里为了简单起见），然后MainActivity中又一个成员变量person。
Person.java
public class Person {

public Person() {
    System.out.println("a person created");
}

}

MainActivity.java
public class MainActivity extends AppCompatActivity {

Person person;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    person = new Person();
}

}

如果不适用依赖注入，那么我们只能在MainActivity中自己new一个Person对象，然后使用。
使用依赖注入：
public class MainActivity extends AppCompatActivity {

@Inject
Person person;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

}
}

在Person对象上添加一个 @Inject注解，即可自动注入对象。
那么问题来了，就一个@Inject 注解，系统就会自动给我创建一个对象? 当然不是，这个时候我们需要一个Person类的提供者。估计叫它: MainModule
MainModule.java
@Module
public class MainModule {

@Provides
Person providesPerson() {
    System.out.println("a person created from MainModule");
    return new Person();
}

}

里面两个注解，@Module 和 @Provides，Module标注的对象，你可以把它想象成一个工厂，可以向外提供一些类的对象。那么到底提供什么对象呢？
@Provides标注的方法就是提供对象的，这种方法一般会返回一个对象实例，例如上面返回一个 Person对象
那么好了，现在Perso类的提供者也有了，我们是不是可以运行起来了。ctrol+F9 build一下项目，然后运行。发现没有任何输出（如果创建Person对象，会打印消息）。为什么了？
这个时候需要引入第3个东东，component容器。可以把它想成一个容器， module中产出的东西都放在里面，然后将component与我要注入的MainActivity做关联，MainActivity中需要的person就可以冲 component中去去取出来。
MainComponent.java
@Component(modules = {MainModule.class})
public interface MainComponent {

void inject(MainActivity mainActivity);

}

看到一个新注入 @Component 表示这个接口是一个容器，并且与 MainModule.class 关联，它生产的东西都在这里。
void inject(MainActivity mainActivity); 表示我怎么和要注入的类关联。这个比较抽象！这个时候我们可以 build 一下项目。
然后在MainActivity中将component 关联进去：
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

    MainComponent component = DaggerMainComponent.builder()
            .mainModule(new MainModule()).build();
    component.inject(this);
}

下面就是将 MainActivity和Module通过Component关联起来的代码，那么这个时候系统看到有一个 @Inject修饰的Person，就知道在这个 MainComponent中去找，并且是有 MainModule 的 Provides修饰的方法提供的。
MainComponent component = DaggerMainComponent.builder()
.mainModule(new MainModule()).build();
component.inject(this);

然后 build 项目，运行项目，发现打印：
person from module
a person created

说明确实系统创建了对象，并且注入到MainActivity中。
细心的同学会发现，MainComponent, MainModule, MainActivity 都是我们自己创建的，上面还有一个 DaggerMainComponent 是上面鬼？这就是你 build project 的时候，dagger自己为你生成的具体的component类（我们自己定义的是MainComponent接口）。感兴趣的可以直接跟到代码里面去看看。
好了，上面我们把 DI (Dependency Inject) 最基本的流程走了一遍，用到了几个注解：

@Inject
@Module
@Component
@Provides

下面来介绍另外几个常用的注解。
其他注解和情况
如果只有最简单的情况，那么上面的几个注解已经够了，但是其实还有很多情形，我们稍微展示几个
单例模式 @Singleton（基于Component）
基于Component的单例模式，怎么理解呢？也是是在这个Component 对象中，一个对象是单例对象。如果又新创建了一个Component，那么两个Component中的当你对象是不一样的。具体的看后面介绍。
上面的MainActivity代码不变，我们再在MainActivity中添加一个 @Inejct Person person2，并打印两个 person对象，结果如下：
person from module
a person created
person from module
a person created
org.yxm.daggerlearn2.data.Person@64cf4a2
org.yxm.daggerlearn2.data.Person@899b533

发现person会被创建两次，并且两个person对象也不同，如果我们希望只有一个 person 和 person2 都指向同一个Person对象了？使用 @Singleton 注解
两个地方需要加：

MainModule.java 的 provides方法上需要添加 @Singleton 注解
@Module
public class MainModule {

private static final String TAG = “MainModule”;

@Singleton
@Provides
public Person providesPerson() {
Log.d(TAG, “person from module”);
return new Person();
}
}

MainComponent.java 类上添加

@Singleton
@Component(modules = {MainModule.class})
public interface MainComponent {

void inject(MainActivity mainActivity);

}

再运行，发现只创建了一次，并且两个person指向同一个对象。
person from module
a person created
org.yxm.daggerlearn2.data.Person@64cf4a2
org.yxm.daggerlearn2.data.Person@64cf4a2

需要非常注意的是：单例是基于Component的，所以不仅 Provides 的地方要加 @Singleton，Component上也需要加。并且如果有另外一个OtherActivity，并且创建了一个MainComponent，也注入Person，这个时候 MainActivity和OtherActivity中的Person是不构成单例的，因为它们的Component是不同的。
带有参数的依赖对象
如果构造Person类，需要一个参数Context，我们怎么注入呢？要知道注入的时候我们只有一个 @Inject 注解，并不能带参数。所以我们需要再 MainModule 中提供context，并且由 providesXXX 函数自己去构造。如：
Person.java
public class Person {

private Context context;

public Person(Context context) {
    Log.d(TAG, "a person created with context:"+context);
}

}

修改MainModule.java
@Module
public class MainModule {

private static final String TAG = "MainModule";

private Context context;

public MainModule(Context context) {
    this.context = context;
}

@Provides
public Context providesContext() {
    return this.context;
}

@Singleton
@Provides
public Person providesPerson(Context context) {
    Log.d(TAG, "person from module");
    return new Person(context);
}

}

这里需要强调的是， providesPerson(Context context)中的 context，不能直接使用成员变量 this.context，而是要在本类中提供一个 Context providesContext() 的 @Provides 方法，这样在发现需要 context 的时候会调用 provideContext 来获取，这也是为了解耦。
依赖一个组件
如果组件之间有依赖，比如 Activity 依赖 Application一样，Application中的东西，Activity要直接可以注入，怎么实现呢？
例如，现在由 AppModule 提供Context对象， ActivityModule 自己无需提供Context对象，而只需要依赖于 AppModule，然后获取Context 对象即可。
AppModule.java
@Module
public class AppModule {

private Context context;

public AppModule(Context context) {
    this.context = context;
}

@Provides
public Context providesContext() {
    return context;
}

}

AppComponent.java
@Component(modules = {AppModule.class})
public interface AppComponent {
// 向下层提供Context
Context getContext();
}

ActivityModule.java
@Module
public class ActivityModule {

@Provides
Person providePerson(Context context) {
    return new Person(context);
}

}

ActivityComponent.java
@Component(dependencies = {AppComponent.class}, modules = {ActivityModule.class})
public interface ActivityComponent {

void inject(MainActivity mainActivity);

}

通过上面例子，我们需要注意：

ActivityModule 也需要创建Person时的Context对象，但是本类中却没有 providesContext() 的方法，因为它通过 ActivityComponent依赖于 AppComponent，所以可以通过 AppComponent中的 providesContext() 方法获取到Context对象。
AppComponent中必须提供 Context getContext(); 这样返回值是 Context 对象的方法接口，否则ActivityModule中无法获取。
使用方法：一定要在 activityComponent中注入 appComponent 这个它依赖的组件。我们可以看到，由于AppComponent没有直接和 MainActivity发生关系，所以它没有 void inject(…);这样的接口
AppComponent appComponent = DaggerAppComponent.builder()
.appModule(new AppModule(this))
.build();
ActivityComponent activityComponent = DaggerActivityComponent.builder()
.appComponent(appComponent)
.activityModule(new ActivityModule())
.build();
activityComponent.inject(this);

自定义标记 @Qualifier 和＠Named
如果Person中有两个构造方法，那么在依赖注入的时候，它怎么知道我该调用哪个构造方法呢？
修改Person类，两个不同的构造方法
Person.java
public class Person {

private static final String TAG = "Person";

private Context context;
private String name;

public Person(Context context) {
    Log.d(TAG, "a person created with context:" + context);
}

public Person(String name) {
    this.name = name;
    Log.d(TAG, "a person created with name:" + name);
}

}

有两种方法可以解决这个问题：
@Named(“…”)
@Module
public class MainModule {

private static final String TAG = "MainModule";

private Context context;

public MainModule(Context context) {
    this.context = context;
}

@Provides
public Context providesContext() {
    return this.context;
}

@Named("context")
@Provides
public Person providesPersonWithContext(Context context) {
    return new Person(context);
}

@Named("string")
@Provides
public Person providesPersonWithName() {
    return new Person("yxm");
}

}

分别在两个提供Person的provides方法上添加 @Named标签，并指定。
然后在要依赖注入的地方，同样添加 @Name 标注表示要注入时使用哪一种
@Named(“string”)
@Inject
Person p1;

@Named("context")
@Inject
Person p2;

@Qualifier自定义标签
使用@Named 会使用到字符串，如果两边都必须写对才能成功，并且字符串总是不那么优雅的，容易出错，所以我们可以自定义标签来解决上面的问题。
PersonWithContext.java
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface PersonWithContext {
}

PersonWithName.java
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface PersonWithName {
}

这样就自定义了两个标签，然后在刚刚所有使用到 @Named 的地方替换成我们自定义的标签即可：
MainModule.java
// …
@PersonWithContext
@Provides
public Person providesPersonWithContext(Context context) {
return new Person(context);
}

@PersonWithName
@Provides
public Person providesPersonWithName() {
    return new Person("yxm");
}

依赖注入的地方：
@PersonWithContext
@Inject
Person p1;

@PersonWithContext
@Inject
Person p2;

输入：调用了两种构造方法
a person created with context:org.yxm.daggerlearn2.MainActivity@8018a6e
a person created with name:yxm

懒加载Lazy和强制重新加载Provider
在注入时分别使用 Lazy 和 Provider 修饰要注入的对象：
@Inject
Lazy lazyPerson;

@Inject
Provider providerPerson;

在使用的地方，用 .get()方法获取：
Person p1 = lazyPerson.get();
Person p2 = lazyPerson.get();
Person p3 = providerPerson.get();
Person p4 = providerPerson.get();

打印结果：
a person created with context:org.yxm.daggerlearn2.MainActivity@8018a6e
a person created with name:yxm
a person created with name:yxm

说明 lazyPerson 多次get 的是同一个对象，providerPerson多次get，每次get都会尝试创建新的对象。
@Scope 自定义生命周期
通过前面的例子，我们遇到了 @Singleton 这个标签，它可以保证在同一个Component中，一个对象是单例对象。其实可以跟进去看代码：
Singleton.java
@Scope
@Documented
@Retention(RUNTIME)
public @interface Singleton {}

就这么多东西。利用单例和组件间依赖的关系，是不是我们也可以定义生命周期来满足我们的需求呢？比如 Application，Activity 这样的生命周期。下面我们来创建这两个生命周期：
Application生命周期
ApplicationScope.java
@Scope
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface ApplicationScope {
}

Activity生命周期
ActivityScope.java
@Scope
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface ActivityScope {
}

除了名字，其他都和 @Singleton 是一样的。
然后用 ApplicationScope 来修饰 AppModule和AppComponent，ActivityScope 修饰 ActivityModule和ActivityComponent
AppModule.java
@Module
public class AppModule {

private Context context;

public AppModule(Context context) {
    this.context = context;
}

@ApplicationScope
@Provides
public Context providesContext() {
    return context;
}

}

AppComponent.java
@ApplicationScope
@Component(modules = {AppModule.class})
public interface AppComponent {

// 向下层提供Context
Context getContext();

}

ActivityModule.java
@Module
public class ActivityModule {

@ActivityScope
@PersonWithContext
@Provides
Person providesPersonWithContext(Context context) {
    return new Person(context);
}

@ActivityScope
@PersonWithName
@Provides
Person providesPersonWithString() {
    return new Person("yxm");
}

}

ActivityComponent.java
@ActivityScope
@Component(dependencies = {AppComponent.class}, modules = {ActivityModule.class})
public interface ActivityComponent {

void inject(MainActivity mainActivity);

}

然后创建自定义Application：
App.java
public class App extends Application {

public static AppComponent appComponent;

@Override
public void onCreate() {
    super.onCreate();

    appComponent = DaggerAppComponent.builder()
            .appModule(new AppModule(this))
            .build();
}

}

在MainActivity中注入：
public class MainActivity extends AppCompatActivity {

private static final String TAG = "MainActivity";

@PersonWithContext
@Inject
Person p1;

@PersonWithContext
@Inject
Person p2;

@PersonWithName
@Inject
Person p3;

@PersonWithName
@Inject
Person p4;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    ActivityComponent activityComponent = DaggerActivityComponent.builder()
            .appComponent(App.appComponent)
            .activityModule(new ActivityModule())
            .build();
    activityComponent.inject(this);

    Log.d(TAG, "" + p1);
    Log.d(TAG, "" + p2);
    Log.d(TAG, "" + p3);
    Log.d(TAG, "" + p4);

}

}

可以看到我们注入了4个Person对象，打印结果：
a person created with context:org.yxm.daggerlearn2.App@103efff
a person created with name:yxm
org.yxm.daggerlearn2.data.Person@711cc
org.yxm.daggerlearn2.data.Person@711cc
org.yxm.daggerlearn2.data.Person@a36ec15
org.yxm.daggerlearn2.data.Person@a36ec15

只创建了两次，说明在ActivityScope生命周期中，创建了两种 Person，并且它们保持各自的单例。
其实看到这里，再说单例我都觉得不是很准确了，它其实就是说的在这个Component中可以又几个这样的对象。如果是普通的就可能有很多个，如果是Scope修饰的，就只有一个。
总结
哎哟我去，还是写了很长，这篇还是主要展示了Dagger2中最基本的环境配置，和常用的标签以及特性,列举一下：

@Inject
@Module
@Component
@Singleton
@Scope
@Named, @Qualifier
Lazy, Provider
modules, dependencys

然后也踩了一些坑，很无知的错误：

在Component中我们会使用：void inject(实体类)，表示这个Component 可以与实体类关联，然后为它注入。注意这里的实体类必须是直接关联的那个类，如果你填它的父类，按照多态你也可以在 compoment.inject(…)的时候成功，但是却无法注入。纠结了好一会儿。
一旦使用 compoment.inject(…) 使某个实体类和Component发生了关系，那么对应Component的 Module 中必须提供 @Inject修饰的所有对象的 providesXXX 方法，而且如果有两种构造方法，必须提供两种 providesXXX 方法哦！又被坑了好一会儿。
如果被依赖的 Component 使用了Scope，那么依赖他的 Component 也必须使用Scope才能使用。典型例子就是：AppComponent使用了 Scope，那么ActivityComponent也必须使用Scope，否则会编译出错。