Dagger2入门教程

时间  2019-11-09
标签 dagger2 dagger 入门 教程 繁體版
原文   原文链接

一、Android依赖注入简介

1.1 依赖注入（ICO：Inversion of Control）

（1）依赖注入概念
依赖注入未来单说就是非本身主动初始化依赖，而经过外部来传入依赖的方式，咱们就称为依赖注。举例来讲：以下面的代码所示，A是依赖注入的例子，B是非依赖注入的例子。汽车（Car）依赖轮胎（Tyre）的资源。android

  • 若是在Car内部本身去new一个Tyre的资源（如B所示），那么Car就和Tyre产生了前的依赖，既Car->Tyre。若是Tyre的型号发生了改变，那么Car的代码就须要跟随发生改变。
  • 可是若是Car不直接new一个Tyre，而是依赖于外部传入的Tyre，那么Car就解除了Tyre的依赖，无论外部的Tyre怎么改变，Car的代码永远不会发生改变。

【A:依赖注入的例子】git

public class Car {
    ...
    // 轮胎
    Tyre tyre;
    ...
    public Car(Tyre tyre) {
        this.tyre = tyre;
    }
}

【B：非依赖注入的例子】github

public class Car{
    ...
    // 轮胎
    Tyre tyre;
    ...
    public Car(Tyre tyre) {
        this.tyre = new Tyre();
    }
}

（2）Ioc容器：负责依赖注入控制器
如A所示，上文已经说了Car的实现依赖于外界传入的Tyre。那么负责传入这个资源的角色就是Ioc容器。Ioc容器自己也不实际产生资源，它会请求其余的对象来生成资源。由此来看，Car解除了和Tyre的依赖，而和Ioc产生了依赖：Car->Ioc容器。这样的好处是，若是Car依赖于多个对象（方向盘，轮胎，地盘等等），那么Car没必要要和那么多对象产生直接的依赖，而只须要依赖Ico容器便可。无论Car须要什么资源，它只须要找Ico容器要便可。由此能够看出，依赖注入就是要解决对象之间的依赖关系，即由对象->对象的直接依赖，转化到对象->Ico的依赖。app

<img src="https://img-blog.csdn.net/201...; width="60%">框架

（3）依赖注入的好处ide

  • 解耦，解除对象之间的依赖关系。
  • 由于已经解耦，因此方便作单元测试，尤为是 Mock 测试
  • 其余

1.2 Android依赖注入

在Java里面，存在大量的依赖注入的框架，如Spring等等。在Dagger2出来以前，Android也存在一些依赖注入框架如Dagger1。其均是依靠反射来实现依赖注入，所以会带来必定的性能问题，所以这些框架并无在Android中流行起来。函数

Dagger2经过APT技术，经过在编译的时候生成注入的工厂类代码，解决了性能问题，所以Dagger2开始在Android上发扬光大。源码分析

二、dagger2原理

2.1 dagger2原理简析

Dagger2实现原理如C图所示，其主要由三部分组成性能

  • 被注入对象：有属性须要被设置
  • module：对象的生成器
  • component：对象属性的设置器（对应上面的Ioc控制器）

【C：dagger2实现原理】
<img src="https://img-blog.csdn.net/201...; width="60%">单元测试

总结起来就是，当被注入的对象须要Component去给他设置属性的时候，Component就会去找它的Module去生成该对象。若是Module完成不了这件事情，Component就会去找它依赖的Component（Dependency Component）去给他生成该对象。Dependency Component自己也没有生成对象能力，其就依赖它的Module去生成该对象

2.2 dagger2经常使用注解

在了解Dagger2注解以前咱们首先记住2个东西：

  1. Dagger2全部对象匹配都是按照返回类型来匹配，与函数命名无关
  2. Dagger2的Scope的大小都是咱们人为赋予的，Scope的大小不是名字决定的，而是Component之间的依赖关系决定的。

在2.1中所提的三种角色都是经过注解来完成的，dagger2经常使用注解以下：

（1）Component使用的注解

  • @Component

    - 做用对象：Class
- 代表该class是个Component

  • @Scope

    - 做用对象：Class
- 指明Component 范围，其依赖的Model若是用@Scope修饰，必须与Component 的Scope相同

Component示例以下所示：

  • 由于ActivityComponent用@Component修饰了，所以示一个Component，其可用来注入一个对象（给对象属性赋值）
  • 其依包含的Module是ActivityModule.class,而且能够包含Module
  • 其依赖于AppComponent.class,也能够依赖多个Component
@BigScoped
@Component(modules = {ActivityModule.class},dependencies = {AppComponent.class})
public interface ActivityComponent {
    void inject(Dagger2Activity dagger2Activity);
    ActivityScopeObj activityScopeObj();
    ActivityObj activityObj();
}

（2）Module使用的注解

  • @Module

    - 做用对象：Class
- 代表该Class是个对象的生成器

  • @Provider

    - 做用对象：Method
- 代表该方法能对外提供对象：**按照返回的类型匹配**

  • @Scope

    - 做用对象：Method
- 代表该方法在Scope范围内是个单例

Module示例：

  • 其用@Module修饰，代表其示一个Module，属于某一个Component
  • 只有用@Provides修饰的函数才是Module能提供的对象，其按照返回的类型来进行匹配，与函数命名无关
  • @BigScoped：表示一个ActivityComponent的实例只会返回一个ActivityScopeObj的对象。原理可参见：
@Module
public class ActivityModule {

    @Provides
    public ActivityObj provideActivityObj() {
        return new ActivityObj();
    }

    @Provides
    public FragmentNotVisibleObj provideActivityNotVisibleObj() {
        return new FragmentNotVisibleObj();
    }

    @BigScoped
    @Provides
    public ActivityScopeObj provideActivityScopeObj() {
        return new ActivityScopeObj();
    }

}

（3）被注入对象使用的注解

  • @Inject

    - 做用对象：Field
- 代表该属性依赖Component进行注入

代码示例：

public class Dagger2Activity extends AppCompatActivity implements ActivityDataProvider {

    @Inject
    ActivityObj mActivityObj;
    @Inject
    FragmentNotVisibleObj mActivityNotVisibleObj;
    @Inject
    ActivityScopeObj mActivityScopeObj;

    ActivityComponent component = DaggerActivityComponent.builder()
        .activityModule(new ActivityModule())
        .build();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_dagger2_test);
        // 使用component来给Dagger2Activity的属性赋值
        component.inject(this);

再看看ActivityComponent生命的inject方法

  • inject方法示Component留给被注入对象将本身传进来的入口，这个名字可随便命名
  • 其参数必须对应一个具体的对象，不能是基类，也不能是父类
public interface ActivityComponent {
    void inject(Dagger2Activity dagger2Activity);

三、dagger2案例

案例地址：dagger案例源码

3.1 申明Scope

// BigScope
@Documented
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface BigScoped {

}
// SmallScope
@Documented
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface SmallScoped {
}

3.2 Dagger2Activity的注入

（1）Dagger2Activity

  • 其依赖于ActivityComponent来给他注入三个属性mActivityObj，mActivityNotVisibleObj和mActivityScopeObj
  • 其中mActivityScopeObj在Module里面用Scope修饰了，所以一个ActivityComponent的实例只会返回一个mActivityScopeObj对象
public class Dagger2Activity extends AppCompatActivity implements ActivityDataProvider {

    @Inject
    ActivityObj mActivityObj;
    @Inject
    FragmentNotVisibleObj mActivityNotVisibleObj;
    @Inject
    ActivityScopeObj mActivityScopeObj;

    ActivityComponent component = DaggerActivityComponent.builder()
        .activityModule(new ActivityModule())
        .build();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_dagger2_test);
        // 使用component来给Dagger2Activity的属性赋值
        component.inject(this);
        Dagger2Fragment dagger2Fragment = new Dagger2Fragment();
        dagger2Fragment.setDataProvider(this);
        getFragmentManager().beginTransaction()
            .addToBackStack(null)
            .replace(R.id.container, dagger2Fragment)
            .commit();
    }

    @Override
    public ActivityComponent getComponent() {
        return component;
    }

    @Override
    public ActivityScopeObj getActivityScopeObj() {
        return mActivityScopeObj;
    }

}

（2）ActivityComponent

  • 使用ActivityModule来生成对象
  • 同时依赖AppComponent来生成对象
  • 其余参见注释：注释很重要 
@BigScoped
@Component(modules = {ActivityModule.class},dependencies = {AppComponent.class})
public interface ActivityComponent {
    // 暴露接口给Dagger2Activity，让其传入本身，好给Dagger2Activity属性赋值
    void inject(Dagger2Activity dagger2Activity);
    // 暴露给其余Component的接口，只有暴露的接口，其余的Component才能够依赖于它建立对象，按照返回类型匹配，与函数名无关
    ActivityScopeObj activityScopeObj();
    ActivityObj activityObj();
}

（3）ActivityModule

  • ActivityModule能够提供三种对象ActivityObj，FragmentNotVisibleObj，ActivityScopeObj
  • ActivityScopeObj上文已经解释了
  • 因为FragmentNotVisibleObj没有在ActivityComponent中暴露，所以FragmentComponent（参见3.2-2和3.3）不能依赖其提供FragmentNotVisibleObj类型的对象
@Module
public class ActivityModule {

    @Provides
    public ActivityObj provideActivityObj() {
        return new ActivityObj();
    }

    @Provides
    public FragmentNotVisibleObj provideActivityNotVisibleObj() {
        return new FragmentNotVisibleObj();
    }

    @BigScoped
    @Provides
    public ActivityScopeObj provideActivityScopeObj() {
        return new ActivityScopeObj();
    }
}

【Dagger2Activity的总体注入过程以下图】
从图中能够看出dagger2的实现模型和上面介绍的Ioc控制反转模型表现一致
这里写图片描述

3.2 Dagger2Fragment的注入

（1）Dagger2Fragment

  • 须要注入三个对象

    - mActivityObj由ActivityComponent生成
- mActivityScopeObj由ActivityComponent生成
- mFragmentObj有FragmentComponent生成
- 其余参见注释
public class Dagger2Fragment extends android.app.Fragment {


    ActivityDataProvider mProvider;

    @Inject
    ActivityObj mActivityObj;
    @Inject
    ActivityScopeObj mActivityScopeObj;
    @Inject
    FragmentObj mFragmentObj;

    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable final ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.dagger2_fragment, container, false);
        FragmentComponent component = DaggerFragmentComponent.builder()
            .fragmentModule(new FragmentModule())
            // 依赖于ActivityComponent，是由Activity传进来的，所以次数使用的activityComponent和Dagger2Activity使用的Component是同一个对象
            // 所以 mActivityScopeObj和mProvider.getActivityScopeObj()获得的是同一个对象
            .activityComponent(mProvider.getComponent())
            .build();
        component.inject(this);
        // true
        Logger.d("ActivityScope single instance:" + (mActivityScopeObj == mProvider.getActivityScopeObj()));
        // false
        Logger.d("not Scope Object:" + (mActivityObj == mFragmentObj.mActivityObj));
        return view;
    }

    public void setDataProvider(ActivityDataProvider provider) {
        mProvider = provider;
    }
}

（2）FragmentComponent

@Component(modules = {FragmentModule.class},dependencies = {ActivityComponent.class})
@SmallScoped
public interface FragmentComponent {
    void inject(Dagger2Fragment dagger2Fragment);
}

（3）FragmentObj

public class FragmentObj {

    @Inject
    ActivityObj mActivityObj;

    // 用@Inject修饰构造和在Module用@Provide修饰等价
    @Inject
    public FragmentObj() {

    }
}

四、dagger2入门参见疑惑问题

（1）查找对象按照什么匹配？

按照类型匹配

  • 两个函数是彻底等价的
@Module
public class ActivityModule {

    @Provides
    public ActivityObj provideActivityObj() {
        return new ActivityObj();
    }
    @Provides
    public ActivityObj ActivityObj() {
        return new ActivityObj();
    }

（2）Scope之间的依赖关系怎么肯定？

按照其修饰的Component间的依赖关系决定，仍是上面的例子：

@Component(modules = {FragmentModule.class},dependencies = {ActivityComponent.class})
@SmallScoped
public interface FragmentComponent {
    void inject(Dagger2Fragment dagger2Fragment);
}

@BigScoped
@Component(modules = {ActivityModule.class},dependencies = {AppComponent.class})
public interface ActivityComponent {
    void inject(Dagger2Activity dagger2Activity);
    ActivityScopeObj activityScopeObj();
    ActivityObj activityObj();
}

由于FragmentComponent-->ActivityComponent。所以，能够得出ActivityComponent实例生命周期长于FragmentComponent的实例（否则，FragmentComponent要传入AppComponent依赖的时候，没有能够赋的值），所以能够得出SmallScope和BiggerScope之间存在以下关系。
<img src="https://img-blog.csdn.net/201...; width="70%">

（3）其余更多工程上使用的问题能够参见ppt：dagger2源码分析

参考文献

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程