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