Dagger 2 在 Android 上的使用（三）

本文介绍了Dagger 2 中@Qualifier和@Named注解以及Lazy和Provider的使用。

《卜算子·咏梅》
风雨送春归，飞雪迎春到。已是悬崖百丈冰，犹有花枝俏。
俏也不争春，只把春来报。待到山花烂漫时，她在丛中笑。
-近代，毛泽东

Dagger 2 在 Android 上的使用（一）
Dagger 2 在 Android 上的使用（二）
Dagger 2 在 Android 上的使用（三）
Dagger 2 在 Android 上的使用（四）
Dagger 2 在 Android 上的使用（五）

注解@Qualifier和注解@Named

书接上文，在上文中我们使用注解@Binds完成了对People抽象类的其中一个子类的绑定，如果我们想同时注入两个子类该怎样处理？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public abstract class People {
    abstract String doWhat();
}

public class Student extends People {
    @Inject
    public Student() {
    }

    @Override
    String doWhat() {
        return "study";
    }
}


public class Worker extends People {

    @Inject
    public Worker() {
    }

    @Override
    String doWhat() {
        return "work";
    }
}

在Module类中添加对另一个子类Worker的绑定方法，这里我们用到了限定符注解@Named，由于我们提供了多个依赖导致Dagger2无法识别要注入哪一个依赖，使用限定符注解@Named很好地解决了这种问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Module
public abstract class PeopleModule {

    @Binds
    @Named("study")
    abstract People bindStudent(Student student);

    @Binds
    @Named("work")
    abstract People bindWorker(Worker worker);

}


@Component(modules = PeopleModule.class)
public interface PeopleComponent {

    void inject(PeopleActivity activity);
}

在提供的实例添加注解@Named，在使用依赖注入的地方添加同样的注解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class PeopleActivity extends Activity {

    @Inject
    @Named("study")
    People student;

    @Inject
    @Named("work")
    People worker;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        DaggerPeopleComponent.create().inject(this);
        Log.d("debug", student.doWhat());
        Log.d("debug", worker.doWhat());
    }
}

同样我们也可以使用限定符注解@Qualifier通过自定义注解完成相同的功能。

使用注解@Qualifier自定义注解：

1
2
3
4
5
6
7
8
9
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface Study {
}

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

然后将自定义的注解替换上面注解@Named：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
@Module
public abstract class PeopleModule {

    @Binds
    @Study
    abstract People bindStudent(Student student);

    @Binds
    @Work
    abstract People bindWorker(Worker worker);

}

public class PeopleActivity extends Activity {

    @Inject
    @Study
    People student;

    @Inject
    @Work
    People worker;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        DaggerPeopleComponent.create().inject(this);
        setContentView(R.layout.activity_main);
        Log.d("debug", student.doWhat());
        Log.d("debug", worker.doWhat());
    }
}

由于使用注解@Named需要指定字符串，可能会由于人为疏忽造成错误，所以这里推荐使用限定符注解@Qualifier自定义注解的方法。

Lazy和Provider

我们可以使用Lazy在注入时不进行初始化，在调用get方法时再初始化实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class PeopleActivity extends Activity {

    @Inject
    @Work
    Lazy<People> worker;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        DaggerPeopleComponent.create().inject(this);
        setContentView(R.layout.activity_main);
        Log.d("debug", worker.get().doWhat());
    }
}

然后来看一下生成的代码：

1
2
3
4
5
6
7
8
9
public final class DaggerPeopleComponent implements PeopleComponent {
  ...
  private PeopleActivity injectPeopleActivity(PeopleActivity instance) {
    PeopleActivity_MembersInjector.injectWorker(
        instance, DoubleCheck.lazy((Provider) Worker_Factory.create()));
    return instance;
  }
  ...
}

这里终于用到了生成的工厂类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public final class Worker_Factory implements Factory<Worker> {
  private static final Worker_Factory INSTANCE = new Worker_Factory();

  @Override
  public Worker get() {
    return provideInstance();
  }

  public static Worker provideInstance() {
    return new Worker();
  }

  public static Worker_Factory create() {
    return INSTANCE;
  }

  public static Worker newWorker() {
    return new Worker();
  }
}

这里使用双重检查锁定为我们提供了唯一的实例，分析具体可参见：Java实现单例模式的正确姿势

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
/**
 * A {@link Lazy} and {@link Provider} implementation that memoizes the value returned from a
 * delegate using the double-check idiom described in Item 71 of <i>Effective Java 2</i>.
 */
public final class DoubleCheck<T> implements Provider<T>, Lazy<T> {
  private static final Object UNINITIALIZED = new Object();

  private volatile Provider<T> provider;
  private volatile Object instance = UNINITIALIZED;

  private DoubleCheck(Provider<T> 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;
  }

  /**
   * Checks to see if creating the new instance has resulted in a recursive call. If it has, and the
   * new instance is the same as the current instance, return the instance. However, if the new
   * instance differs from the current instance, an {@link IllegalStateException} is thrown.
   */
  public static Object reentrantCheck(Object currentInstance, Object newInstance) {
    boolean isReentrant = !(currentInstance == UNINITIALIZED
        // This check is needed for fastInit's implementation, which uses MemoizedSentinel types.
        || currentInstance instanceof MemoizedSentinel);

    if (isReentrant && currentInstance != newInstance) {
      throw new IllegalStateException("Scoped provider was invoked recursively returning "
          + "different results: " + currentInstance + " & " + newInstance + ". This is likely "
          + "due to a circular dependency.");
    }
    return newInstance;
  }

  ...

  /** Returns a {@link Lazy} that caches the value from the given provider. */
  // This method is declared this way instead of "<T> Lazy<T> lazy(Provider<T> delegate)"
  // to work around an Eclipse type inference bug: https://github.com/google/dagger/issues/949.
  public static <P extends Provider<T>, T> Lazy<T> lazy(P provider) {
    if (provider instanceof Lazy) {
      @SuppressWarnings("unchecked")
      final Lazy<T> lazy = (Lazy<T>) provider;
      // Avoids memoizing a value that is already memoized.
      // NOTE: There is a pathological case where Provider<P> may implement Lazy<L>, but P and L
      // are different types using covariant return on get(). Right now this is used with
      // DoubleCheck<T> exclusively, which is implemented such that P and L are always
      // the same, so it will be fine for that case.
      return lazy;
    }
    return new DoubleCheck<T>(checkNotNull(provider));
  }
}

相对于Lazy注入，Provider注入每次调用get时都会提供一个新的实例，Provider是由Java提供的接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class PeopleActivity extends Activity {

    @Inject
    @Study
    Provider<People> student;

    @Inject
    @Work
    Lazy<People> worker;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        DaggerPeopleComponent.create().inject(this);
        setContentView(R.layout.activity_main);
        Log.d("debug", "1"+student.get().toString());
        Log.d("debug", "2"+student.get().toString());
        Log.d("debug", "3"+worker.get().toString());
        Log.d("debug", "4"+worker.get().toString());
    }
}

打印输出如下：

1
2
3
4
2018-11-12 21:26:26.365 30805-30805/? D/debug: 1io.github.yuweiguocn.test.Student@205713d
2018-11-12 21:26:26.365 30805-30805/? D/debug: 2io.github.yuweiguocn.test.Student@6fffd32
2018-11-12 21:26:26.365 30805-30805/? D/debug: 3io.github.yuweiguocn.test.Worker@d03a83
2018-11-12 21:26:26.365 30805-30805/? D/debug: 4io.github.yuweiguocn.test.Worker@d03a83

对比下生成的代码，唯一的区别就是Lazy使用DoubleCheck保证了实例的唯一性：

1
2
3
4
5
6
7
8
9
10
11
public final class DaggerPeopleComponent implements PeopleComponent {
  ...

  private PeopleActivity injectPeopleActivity(PeopleActivity instance) {
    PeopleActivity_MembersInjector.injectStudent(instance, (Provider) Student_Factory.create());
    PeopleActivity_MembersInjector.injectWorker(
        instance, DoubleCheck.lazy((Provider) Worker_Factory.create()));
    return instance;
  }
  ...
}

总结

  • 当提供多个相同类型的注入依赖时，可以使用限定符注解@Qualifier和注解@Named，为了避免人为疏忽导致错误，推荐使用注解@Qualifier自定义注解完成相应功能
  • 使用Lazy可以在调用get方法时再初始化，其中使用了双重检查锁定保证了实例的唯一性
  • 使用Provider在调用get方法时会提供新的实例

参考

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

Android开发工程师