Android开发之Dagger2--其他注解符（五）

前言

在上一篇文章 Android开发之Dagger2--MVP模式中使用（四），在mvp模式里使用了Dagger2，可以看到，Dagger2可以称得上Android开发的神器，虽然实现起来要多出Module和Component两个类，但是能做到很好的解耦。如果使用了Dagger2，以后要是对项目重构，也能省很多事情。
在本篇文章，主要讨论下Dagger2的其他注解符。

@Singleton

这个注解的作用是 提供全局单例注解
在MainModule是我们首先使用不用@Singleton注解的方法，如下：

@Provides
   Student provideStudent(){
       return new Student();
   }

删除app下的build文件后重新编译，找到生成的DaggerMainComponent文件，代码如下：

public final class DaggerMainComponent implements MainComponent {
  private MainModule mainModule;

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

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

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

  @SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {
    this.mainModule = builder.mainModule;
  }

  @Override
  public void inject(Daggertest1Activity daggertest1Activity) {
    injectDaggertest1Activity(daggertest1Activity);
  }

  private Daggertest1Activity injectDaggertest1Activity(Daggertest1Activity instance) {
    Daggertest1Activity_MembersInjector.injectMStudent(
        instance, MainModule_ProvideStudentFactory.proxyProvideStudent(mainModule));
    return instance;
  }

  public static final class Builder {
    private MainModule mainModule;

    private Builder() {}

    public MainComponent build() {
      if (mainModule == null) {
        this.mainModule = new MainModule();
      }
      return new DaggerMainComponent(this);
    }

    public Builder mainModule(MainModule mainModule) {
      this.mainModule = Preconditions.checkNotNull(mainModule);
      return this;
    }
  }
}

然后加上 @Singleton注解，删除app下的build文件，重新编译，找到DaggerMainComponent文件

    @Provides
    @Singleton
    Student provideStudent(){
        return new Student();
    }

public final class DaggerMainComponent implements MainComponent {
  private Provider provideStudentProvider;

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

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

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

  @SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {
    this.provideStudentProvider =
        DoubleCheck.provider(MainModule_ProvideStudentFactory.create(builder.mainModule));
  }

  @Override
  public void inject(Daggertest1Activity daggertest1Activity) {
    injectDaggertest1Activity(daggertest1Activity);
  }

  private Daggertest1Activity injectDaggertest1Activity(Daggertest1Activity instance) {
    Daggertest1Activity_MembersInjector.injectMStudent(instance, provideStudentProvider.get());
    return instance;
  }

  public static final class Builder {
    private MainModule mainModule;

    private Builder() {}

    public MainComponent build() {
      if (mainModule == null) {
        this.mainModule = new MainModule();
      }
      return new DaggerMainComponent(this);
    }

    public Builder mainModule(MainModule mainModule) {
      this.mainModule = Preconditions.checkNotNull(mainModule);
      return this;
    }
  }
}

我们比较两个文件的initialize（）方法。

无@Singleton注解

@SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {
    this.mainModule = builder.mainModule;
  }

有@Singleton注解

@SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {
    this.provideStudentProvider =
        DoubleCheck.provider(MainModule_ProvideStudentFactory.create(builder.mainModule));
  }

前文说过，DoubleCheck是双重锁检查的单例模式。所以@Singleton注解就是提供全局的单例模式。

使用方法

• 1.在需要单例模式的对象提供者方法前加上@Singleton注解
• 2.在该module关联的Component中加上同样的注解，否则编译会报错的。

@Singleton
@Component(modules = MainModule.class)
public interface MainComponent {
    void inject(Daggertest1Activity daggertest1Activity);
}

@Scope

自定义注解限定注解的作用域。
很多文章说成生命周期，也说成局部单例。我觉得局部单例更好理解些。
在实际开发中，我们可能会用到局部单例，现在考虑这样的情况，我们在Activity里注入两个Student对象，并且要保证这两个对象是同一个对象。首先肯定是不能用@Singleton注解的，因为@Singleton是全局单例。
这是我们用自定义的@Scope注解实现局部单例。

在Activity里注入两个Student的对象，并打印了两个地址。

public class DaggerTest2Activity extends AppCompatActivity {

    @Inject
    Student mStudent1;

    @Inject
    Student mStudent2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_dagger_test2);

        DaggerMainComponent.builder()
                .mainModule(new MainModule())
                .build()
                .inject(this);
        Log.d("student--1",mStudent1.toString());
        Log.d("student--2",mStudent2.toString());

    }
}

运行结果如下

很明显，这是两个不同的对对象。

• 首先自定义一个接口，使用@Scope注解，目的是为Activity提供局部单例。

@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface ActivitySingleton {
}

• 在Module上加上@ActivitySingleton注解

 @Provides
    @ActivitySingleton
    Student provideStudent(){
        return new Student();
    }

• 在Component加上@ActivitySingleton注解

@ActivitySingleton
@Component(modules = MainModule.class)
public interface MainComponent {
    void inject(DaggerTest2Activity daggertest2Activity);
}

重新运行代码，结果如下：

可以看到是同一个对象。

@Qualifier

@Qualifier和函数的重载类似。它的作用是告诉依赖的需求方，创建数据的时候使用哪个依赖提供方。
举个栗子，现在我想在Activity里注入Teacher实例，Teacher分男女，所以我们在Teacher类的构造方法中区别。

• Teacher类

public class Teacher {
    String sex;

    public Teacher(String sex) {
        this.sex = sex;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

• 自定义MaleTeacher和FemaleTeacher两个接口，并使用@Qualifier注解。

@Qualifier
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface MaleTeacher {
}

@Qualifier
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface FemaleTeacher {
}

• 修改Module，provide MaleTeacher和FemaleTeacher方法，注意要带参数。

@Provides
    @MaleTeacher
    Teacher provideMaleTeacher(){
        return new Teacher("maleTeacher");
    }

    @Provides
    @FemaleTeacher
    Teacher provideFemaleTeacher(){
        return new Teacher("femaleTeacher");
    }

• 在Activity完成注入。

@Inject
    @MaleTeacher
    Teacher maleTeacher;

    @Inject
    @FemaleTeacher
    Teacher femaleTeacher;

 DaggerMainComponent.builder()
                .mainModule(new MainModule())
                .build()
                .inject(this);

        Log.d("maleTeacher",maleTeacher.getSex());
        Log.d("maleTeacher",femaleTeacher.getSex());

运行结果如下：

可以看到根据传入参数的不同生成了不同的对象。

总结：
其实Google开发者一直在对Dagger2就行优化，以便Dagger2能更好地开发Android，这样Dagger2-Android就应运而生，下一文章就介绍下这个Dagger2-Android。