美文网首页Android开发Android开发经验谈Android-Rxjava&retrofit&dagger
[Android 学习笔记] Dagger2 依赖注入由浅入深

[Android 学习笔记] Dagger2 依赖注入由浅入深

作者: afluy | 来源:发表于2018-06-12 23:01 被阅读47次

Scope 是 Dagger2 库中比较难理解一个概念, 它可以翻译为"作用域", 进一步解释就是"创建出的对象的生命周期".
Dagger2 中 Module 只负责创建所需的对象, Module 中创建的对象由 Component 负责缓存和复用, 至于这个对象是每次调用都要新创建, 还是全局都复用同一个对象, 这些是在自动生成的实现了 Component 接口的代码中.

没有使用 Scope 注解的场景

定义的 SimpleActivityComponent 接口:

@Component(modules = { UserServerModule.class })
public interface SimpleActivityComponent {
    UserServer getUserServer();
}

自动生成的 DaggerSimpleActivityComponent 类:

public final class DaggerSimpleActivityComponent implements SimpleActivityComponent {
  private DaggerSimpleActivityComponent(Builder builder) {}

  public static Builder builder() {
    return new Builder();
  }

  public static SimpleActivityComponent create() {
    return new Builder().build();
  }

  @Override
  public UserServer getUserServer() {
    return UserServerModule_ProvideUserServerFactory.proxyProvideUserServer();
// 该方法每次都会去  UserServerModule.provideUserServer() 方法, 所以每次都会去调用 new UserServer("kimi"), 这样每次调用 getUserServer() 方法都是去新创建一个 UserServer 对象
  }

  public static final class Builder {
    private Builder() {}

    public SimpleActivityComponent build() {
      return new DaggerSimpleActivityComponent(this);
    }

    /**
     * @deprecated This module is declared, but an instance is not used in the component. This
     *     method is a no-op. For more, see https://google.github.io/dagger/unused-modules.
     */
    @Deprecated
    public Builder userServerModule(UserServerModule userServerModule) {
      Preconditions.checkNotNull(userServerModule);
      return this;
    }
  }
}

上面的代码中可以看出, 每次调用 getUserServer() 方法都是去新创建一个 UserServer 对象.

引入 Scope 注解解决对象的复用问题

javax.inject 库中自带一个 Singleton 注解, 它的类定义上添加了 @Scope 注解.

package javax.inject;

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Identifies a type that the injector only instantiates once. Not inherited.
 *
 * @see javax.inject.Scope @Scope
 */
@Scope
@Documented
@Retention(RUNTIME)
public @interface Singleton {}

在自定义 Module 的 provide 方法上添加 @Singleton 注解

import dagger.Module;
import dagger.Provides;
import javax.inject.Singleton;

@Module
public class UserServerModule {

    @Singleton  // 添加 Singleton 注解
    @Provides
    static UserServer provideUserServer() {
        return new UserServer("kimi");
    }
}

然后再定义的 SimpleActivityComponent 接口类定义上添加 @Singleton 注解:

import dagger.Component;
import javax.inject.Singleton;

@Singleton  // 添加 Singleton 注解
@Component(modules = { UserServerModule.class })
public interface SimpleActivityComponent {
    UserServer getUserServer();
}

编译后再看自动生成的 DaggerSimpleActivityComponent 类:

import dagger.internal.DoubleCheck;
import dagger.internal.Preconditions;
import javax.inject.Provider;

public final class DaggerSimpleActivityComponent implements SimpleActivityComponent {

  // 添加了一个 provideUserServerProvider 变量
  private Provider<UserServer> provideUserServerProvider;

  private DaggerSimpleActivityComponent(Builder builder) {
    initialize(builder);
  }

  public static Builder builder() {
    return new Builder();
  }

  public static SimpleActivityComponent create() {
    return new Builder().build();
  }

// 多了一个 initialize 方法用于给变量 provideUserServerProvider 赋值
// 这里介绍一下 DoubleCheck 类, 它会缓存传值, 所以每次调用它的 get() 方法时, 返回的都是同一个对象 
  @SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {
    this.provideUserServerProvider =
    DoubleCheck.provider(UserServerModule_ProvideUserServerFactory.create());
  }

  @Override
  public UserServer getUserServer() {
    return provideUserServerProvider.get();  // 所以每次再调用  get() 方法都是返回同一个对象, 不是每次再创建新对象
  }

  public static final class Builder {
    private Builder() {}

    public SimpleActivityComponent build() {
      return new DaggerSimpleActivityComponent(this);
    }

    /**
     * @deprecated This module is declared, but an instance is not used in the component. This
     *     method is a no-op. For more, see https://google.github.io/dagger/unused-modules.
     */
    @Deprecated
    public Builder userServerModule(UserServerModule userServerModule) {
      Preconditions.checkNotNull(userServerModule);
      return this;
    }
  }
}

从上面的代码和添加的注释可以看出:
添加 Scope 注解使 Component 对象强引用了 Module 中提供的对象, 当 Component 对象存在时, Module 提供的对象也是存在的, 不会被回收, 所以它们两个是同样的生命周期.
不用 Scope 注解时, Component 对象每次都会创建新的 Module 提供的对象, Component 和 Module 提供的对象就不是同一个生命周期.

@Singleton

Singleton 给我们的第一印象是它注解生成的对象应该是全局唯一的, 单例的, 但是通过 demo 中可以看出 @Singleton 注解的对象也是和 Component 相同生命周期的, 如果 Component 被回收了那么 @Singleton 注解的对象也会被回收, 所以它不是全局唯一, 如果 Component 被创建了多次, 那么内存中也会出现多个 @Singleton 注解的对象, 不能被它的命名迷惑了.

自定义 Scope 注解

javax.inject 包中只提供了一个 Scope 注解, 也就是 @Singleton, 但是开发者也可以自定义 Scope 注解.

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import javax.inject.Scope;

@Scope // 注意
@Retention(RetentionPolicy.CLASS)
public @interface CustomScope {
}

自定义 Scope 注解很简单, 但是需要用 @Scope 来注解自定义的注解类, 这样做的目的是方便 AnnotationProcessor 在编译时能找到哪些是自定义的 Scope 注解.

自定义注解用于区分各个 Module 的生命周期, 就拿日常 Android 开发来说, 有的对象在整个 APP 生命周期内都被引用, 所以只有完全退出 APP 后, 这个对象才会被回收, 而有的对象只有在某个 Activity 生命周期内被引用了, 当退出这个 Activity 时, 这个对象也会被回收.
所以我们可以定义两个 Scope 注解:

@Scope
@Retention(RetentionPolicy.CLASS)
public @interface ApplicationScope {
}


@Scope
@Retention(RetentionPolicy.CLASS)
public @interface LoginActivityScope {
}

ApplicationScope 注解用于注解那些与 APP 整个生命周期绑定的对象, LoginActivityScope 注解可以用于注解只在 LoginActivity 的生命周期内被引用的对象, 比如 LoginServer 对象.

参考资料

相关文章

  • [Android 学习笔记] Dagger2 依赖注入由浅入深

    Scope 是 Dagger2 库中比较难理解一个概念, 它可以翻译为"作用域", 进一步解释就是"创建出的对象的...

  • 更清晰的Dagger2 + MVP 架构

    Dagger2 与 MVP Dagger2是Google提供的依赖注入框架,依赖注入为Android中组件之间的解...

  • [转]Dagger2 入门,以初学者角度

    原文地址Dagger2 入门,以初学者角度 依赖注入 Dagger2是Android中比较热门的依赖注入框架,什么...

  • 依赖注入之Dagger2初探

    Dagger2 Dagger2是Google提供的依赖注入框架,依赖注入为Android中组件之间的解耦提供了很好...

  • 三篇关于dagger2非常好的文章

    dagger2是解决Android或java中依赖注入的一个类库(DI类库) dagger2:基础依赖注入框架篇 ...

  • Dagger2学习笔记(一)

    系列文章:Dagger2学习笔记(一)Dagger2学习笔记(二) 依赖注入是一种十分好的技巧,它能解偶高层次模块...

  • Using Dagger2 in Android

    Dagger2是一个Java和Android的依赖注入框架.本文介绍Android中dagger2的基本使用.其中...

  • Dagger2最简单入门

    什么是Dagger2 Dagger2是Android上的一个依赖注入框架,那么什么是依赖注入,通俗一点来说就是我们...

  • Dagger2的理解和使用

    Android:dagger2让你爱不释手-基础依赖注入框架篇Android:dagger2让你爱不释手-重点概念...

  • Dagger2 介绍

    依赖注入 为了理解dagger2在android中的应用,我们需要先理解为什么需要依赖注入。 为什么我们需要依赖注...

网友评论

    本文标题:[Android 学习笔记] Dagger2 依赖注入由浅入深

    本文链接:https://www.haomeiwen.com/subject/loyteftx.html