上一章，@Provides 注解实现第三方库的依赖注入，但每次获取都是新的实例。有时候创建实例本身将消耗大量的系统资源，这会导致性能问题，影响用户体验，为此，我们需要使用单例模式。
查看 @Singleton 注解的源码：
/**
* Identifies a type that the injector only instantiates once. Not inherited.
*
* @see javax.inject.Scope @Scope
*/
@Scope
@Documented
@Retention(RUNTIME)
public @interface Singleton {}
@Singleton 注解由 @Scope 注解标记，它们都是 JSR330 的注解，用来确定实例的重用范围。
4.1 @Singleton
标记在 @Component 注解的类上：
@Singleton
@Component(modules = AccountModule.class)
public interface ActivityComponent {
// ...
}
标记在 @Provides 注解的方法上：
@Module
final class AccountModule {
// ...
@Singleton
@Provides
PasswordEncoder providePasswordEncoder() {
return PasswordEncoderFactories.createDelegatingPasswordEncoder();
}
}
编译生成：
public final class DaggerActivityComponent implements ActivityComponent {
private final AccountModule accountModule;
private Provider passwordEncoderProvider;
private DaggerActivityComponent(AccountModule accountModuleParam) {
this.accountModule = accountModuleParam;
initialize(accountModuleParam);
}
// ...
@SuppressWarnings("unchecked")
private void initialize(final AccountModule accountModuleParam) {
this.passwordEncoderProvider = DoubleCheck.provider(AccountModule_PasswordEncoderFactory.create(accountModuleParam));
}
// ...
}
其他内容都一样，多出来一个初始化方法，使用 DoubleCheck.provider() 方法包装依赖。
4.1.1 双重检查模式
查看 DoubleCheck 类的源码：
public final class DoubleCheck implements Provider, Lazy {
private static final Object UNINITIALIZED = new Object();
private volatile Provider provider;
private volatile Object instance = UNINITIALIZED;
private DoubleCheck(Provider provider) {
assert provider != null;
this.provider = provider;
}
@SuppressWarnings("unchecked") // cast only happens when result comes from the provider
@Override
public T get() {
Object result = instance;
if (result == UNINITIALIZED) {
synchronized (this) {
result = instance;
if (result == UNINITIALIZED) {
result = provider.get();
instance = reentrantCheck(instance, result);
/* Null out the reference to the provider. We are never going to need it again, so we
* can make it eligible for GC. */
provider = null;
}
}
}
return (T) result;
}
// ...
}
核心就在 get() 方法中，利用双重检查模式和 volatile 关键字，在多线程环境下，可以保证线程安全。
4.1.2 标记账号类
注释 Account 类提供方法上的 @Provides 注解：
@Module
final class AccountModule {
// @Provides
Account provideAccount() {
return new Account();
}
// ...
}
恢复 Account 类构造函数上的 @Inject 注解，并在类上标记 @Singleton 注解：
@Singleton
public class Account {
// ...
@Inject
public Account() {
this.username = "fssd";
this.password = "123456";
}
@NonNull
@Override
public String toString() {
return "Account{" +
"username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
}
查看编译生成的组件类：
public final class DaggerActivityComponent implements ActivityComponent {
// ...
private DaggerActivityComponent(AccountModule accountModuleParam) {
initialize(accountModuleParam);
}
// ...
@SuppressWarnings("unchecked")
private void initialize(final AccountModule accountModuleParam) {
this.accountProvider = DoubleCheck.provider(Account_Factory.create());
this.passwordEncoderProvider = DoubleCheck.provider(AccountModule_PasswordEncoderFactory.create(accountModuleParam));
}
// ...
}
看到 DoubleCheck.provider 方法就知道 Account 类也实现了单例，神奇的是，Account_Factory 类居然被调用了。
@Singleton 注解标记在提供方法或依赖类上，都可以让组件生成单例实现。
现在删除 Account 类中的 @Singleton 注解和 @Inject 注解，恢复模块内容：
@Module
final class AccountModule {
@Singleton
@Provides
Account provideAccount() {
return new Account();
}
@Singleton
@Provides
PasswordEncoder passwordEncoder() {
return PasswordEncoderFactories.createDelegatingPasswordEncoder();
}
}
4.2 验证单例
光看生成的源代码还不够，我们必须动手验证一下。
为此，我们实现一个简单的 记住账号 功能，需要使用 Gson 库来序列化 Account 类为 json 字符串，再保存到 SharedPreferences 共享首选项。
4.2.1 声明依赖
老规矩，上 Maven 搜一下 Gson，拿到在 Gradle 中声明依赖的方式。
添加到 app 模块的 build.gradle 文件：
dependencies {
// other dependencies
implementation 'com.google.code.gson:gson:2.8.7'
}
4.2.2 提供依赖
用 @Provides 注解标记提供方法：
@Module
final class AccountModule {
// ...
@Singleton
@Provides
Gson gson() {
return new Gson();
}
}
4.2.3 使用依赖
在 MainActivity 类中使用 Gson 实例：
public class MainActivity extends AppCompatActivity {
@Inject
Account account;
@Inject
PasswordEncoder passwordEncoder;
@Inject
Gson gson;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ActivityComponent component = DaggerActivityComponent.create();
component.inject(this);
TextView contentText = findViewById(R.id.content_text);
String content = String.format("username: %s, password: %s, encodePassword: %s",
account.username,
account.password,
passwordEncoder.encode(account.password));
contentText.setText(content);
// 1. 序列化
String json = gson.toJson(component.account());
SharedPreferences preferences = getSharedPreferences("account", Context.MODE_PRIVATE);
// 2. 持久化
preferences.edit().putString("current", json).apply();
// 3. 获取字符串
String current = preferences.getString("current", null);
if (current != null) {
// 4. 反序列化
Account currentAccount = gson.fromJson(current, Account.class);
Log.i("account", "account is equals: " + this.account.equals(currentAccount));
}
}
}
这里只是演示代码，实际开发中不会这样做。
现在需要验证一下，从组件中拿到的 Account 实例与通过注入字段的 Account 实例是否相等？
4.2.4 改造账号类
验证之前，我们做一点点额外的工作：
public class Account {
private static final String NUMBER = "1234567890";
public String username;
public String password;
public Account() {
this.username = randomNumber(4);
this.password = randomNumber(6);
}
private String randomNumber(int length) {
StringBuilder builder = new StringBuilder();
for (int i = 0; i < length; i++) {
builder.append(NUMBER.charAt((int) (Math.random() * NUMBER.length())));
}
return builder.toString();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Account account = (Account) o;
return Objects.equals(username, account.username) &&
Objects.equals(password, account.password);
}
@Override
public int hashCode() {
return Objects.hash(username, password);
}
@NonNull
@Override
public String toString() {
return "Account{" +
"username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
}
提示：利用 IDEA 的 Alt + Insert 快捷键，自动生成 equals() 和 hashCode() 方法。
两个对象的比较，必须重写 equals() 方法。
4.3 运行
运行结果：
对象比较日志
可以看到，用不同方式获取的两个 Account 实例完全相等。
4.4 总结
@Singleton 是用 @Scope 标记的注解，实现为线程安全的延迟初始化。
回顾前面的知识点，我们知道：
- 默认情况下，使用
@Inject注解标记构造函数，可以向 Dagger2 添加依赖类型 - 必须在
@Component注解标记的接口中，添加注入方法和目标类参数，才能完成依赖注入 - 第三方库，通过
@Provides注解标记的方法提供依赖实例 - 要实现依赖的单例模式，需要用
@Singleton注解标记在类或提供方法上
学会这四个注解，Dagger2 的精髓就已经掌握，可以在实际开发中大展身手。