Dagger2入门详解

作者: JFang | 来源:发表于2018-03-20 18:28 被阅读0次

Dagger2入门详解

@(Android)

参考文章

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 注解

两个地方需要加：
1. 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);
}

通过上面例子，我们需要注意：
1. ActivityModule 也需要创建Person时的Context对象，但是本类中却没有 providesContext() 的方法，因为它通过 ActivityComponent依赖于 AppComponent，所以可以通过 AppComponent中的 providesContext() 方法获取到Context对象。
2. 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<Person> lazyPerson;

@Inject
Provider<Person> 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，否则会编译出错。
转至：http://blog.csdn.net/u013647382/article/details/53257141

Dagger2入门详解

Dagger2入门详解

参考文章

环境配置

入门实例

其他注解和情况

单例模式 @Singleton（基于Component）

带有参数的依赖对象

依赖一个组件

自定义标记 @Qualifier 和＠Named

@Named(“…”)

@Qualifier自定义标签

懒加载Lazy和强制重新加载Provider

@Scope 自定义生命周期

总结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Dagger2入门详解

Dagger2入门详解

参考文章

环境配置

入门实例

其他注解和情况

单例模式 @Singleton（基于Component）

带有参数的依赖对象

依赖一个组件

自定义标记 @Qualifier 和 ＠Named

@Named(“…”)

@Qualifier自定义标签

懒加载Lazy和强制重新加载Provider

@Scope 自定义生命周期

总结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

自定义标记 @Qualifier 和＠Named