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

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 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 对象.

参考资料

  • https://google.github.io/dagger/users-guide
  • Dagger 2 Android Tutorial (youtube)
  • The Future of Dependency Injection with Dagger 2 (Jake Wharton 大神亲自介绍) (youtube)
  • MCE^3 - Gregory Kick - Dagger 2 (youtube)

你可能感兴趣的:([Android 学习笔记] Dagger2 依赖注入由浅入深 (3))