devbox
小惠珠哦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

神兵利器Dragger2学习篇

作者：小惠珠哦 | 2024-07-15 18:12:33

赞

踩

dragger2

Dagger ，早有耳闻，但一直没有与他正真的认识过。Dagger 英文翻译为“匕首”，这可能就是把它称作神兵利器的原因。当我看一些开源项目在使用dagger2 时，我停止了前进的步伐，查阅了网上一些层差不齐的资料后，感觉还是懵逼状态，正当我感受到了从入门到放弃的状态时，看到了一篇相对好理解一写的博文，我又开始踏上了从放弃到入门之路。

背景（日常念经，了解一下）

Dagger ，鼎鼎大名的Square公司 开发的，光听Square，就知道肯定不简单(okhttp，Picasso，leakcanary，等等等等）起初Square公司受到Guice的启发而开发了Dagger，但是Dagger这种半静态半运行时的框架还是有些性能问题（虽说依赖注入是完全静态的，但是其有向无环图(Directed Acyclic Graph)还是基于反射来生成的，这无论在大型的服务端应用还是在Android应用上都不是最优方案）。因此Google工程师Fork了Dagger项目，对它进行了改造。于是变演变出了今天我们要讨论的Dagger2，所以说Dagger2其实就是高配版的Dagger。

Dagger2 基于Java注解来实现的完全在编译阶段完成依赖注入的开源库，主要用于模块间解耦、提高代码的健壮性和可维护性。Dagger2在编译阶段通过apt利用Java注解自动生成Java代码，然后结合手写的代码来自动帮我们完成依赖注入的工作。

依赖注入

上文中提到了Dagger2 是解决Android或java中依赖注入的一个类库（Dependency Injection类库） ，通过注解在编译期生成代码的方式实现注入。那为什么要用依赖注入呢？首先看个例子

上面两张图很形象的说明了使用依赖的差别，只不过用的是构造函数传参给成员变量赋值，实现注入（后面简称构造注入）。前者在编码中肯定不提倡，因为Major和 Student耦合性太高。当然，除了构造函数注入还有接口注入：实现接口方法，同样以传参的方式实现注入。

  1. public interface Injection<T>{
  2.     void inject(T t);
  3. }
  4. public class Student implements Injection<Engine>{
  5.     private Major major;
  6.     public Student(){}
  7.     public void inject(Major major){
  8.         this.major = major;
  9.     }
  10. }

重点来了当然，前两者注入方式需要编写大量代码，Dagger2是通过Java注解在编译期来实现依赖注入的

  1. /**
  2.  * 创建时间：2018/8/23
  3.  * 编写人：kanghb
  4.  * 功能描述：学生
  5.  */
  6. public class Student {
  7.  
  8.     @Inject
  9.     Major major;
  10.  
  11.     public Student() {
  12.     }
  13.  
  14.     @Override
  15.     public String toString() {
  16.         return "Student{" +
  17.                 "major=" + major +
  18.                 '}';
  19.     }
  20. }

Dagger2注解

Dagger2是基于Java注解来实现依赖注入的，那么在正式使用之前我们需要先了解下Dagger2中的注解。Dagger2使用过程中我们通常接触到的注解主要包括：@Inject, @Module, @Provides, @Component, @Qulifier, @Scope, @Singleten。

  • @Inject：@Inject有两个作用，一是用来标记需要依赖的变量，以此告诉Dagger2为它提供依赖；二是用来标记构造函数，Dagger2通过@Inject注解可以在需要这个类实例的时候来找到这个构造函数并把相关实例构造出来，以此来为被@Inject标记了的变量提供依赖；

  • @Module：@Module用于标注提供依赖的类。你可能会有点困惑，上面不是提到用@Inject标记构造函数就可以提供依赖了么，为什么还需要@Module？很多时候我们需要提供依赖的构造函数是第三方库的，我们没法给它加上@Inject注解，又比如说提供以来的构造函数是带参数的，如果我们之所简单的使用@Inject标记它，那么他的参数又怎么来呢？@Module正是帮我们解决这些问题的。

  • @Provides：@Provides用于标注Module所标注的类中的方法，该方法在需要提供依赖时被调用，从而把预先提供好的对象当做依赖给标注了@Inject的变量赋值；

  • @Component：@Component用于标注接口，是依赖需求方和依赖提供方之间的桥梁。被Component标注的接口在编译时会生成该接口的实现类（如果@Component标注的接口为StudentComponent，则编译期生成的实现类为DaggerStudentComponent）,我们通过调用这个实现类的方法完成注入；

  • @Qulifier：@Qulifier用于自定义注解，也就是说@Qulifier就如同Java提供的几种基本元注解一样用来标记注解类。我们在使用@Module来标注提供依赖的方法时，方法名我们是可以随便定义的（虽然我们定义方法名一般以provide开头，但这并不是强制的，只是为了增加可读性而已）。那么Dagger2怎么知道这个方法是为谁提供依赖呢？答案就是返回值的类型，Dagger2根据返回值的类型来决定为哪个被@Inject标记了的变量赋值。但是问题来了，一旦有多个一样的返回类型Dagger2就懵逼了。@Qulifier的存在正式为了解决这个问题，我们使用@Qulifier来定义自己的注解，然后通过自定义的注解去标注提供依赖的方法和依赖需求方（也就是被@Inject标注的变量），这样Dagger2就知道为谁提供依赖了。—-一个更为精简的定义：当类型不足以鉴别一个依赖的时候，我们就可以使用这个注解标示；

  • @Scope：@Scope同样用于自定义注解，我能可以通过@Scope自定义的注解来限定注解作用域，实现局部的单例；

  • @Singleton：@Singleton其实就是一个通过@Scope定义的注解，我们一般通过它来实现全局单例。但实际上它并不能体现全局单例，是否能提供全局单例还要取决于对应的Component是否为一个全局对象。

Dagger2使用

一、@inject标注构造方法提供依赖

1.添加依赖

  1. // Add Dagger dependencies
  2. dependencies {
  3.   compile 'com.google.dagger:dagger:2.x'
  4.   annotationProcessor 'com.google.dagger:dagger-compiler:2.x'
  5. }

关于Dagger2的依赖配置就不在这里占用篇幅去描述了，大家可以到它的github主页下去查看官方教程https://github.com/google/dagger。接下来我们拿Car和Engine来举例。

2.Student类是依赖需求方，依赖了Major类；因此我们需要在类变量Major上添加@Inject来告诉Dagger2来为自己提供依赖。

  1. /**
  2.  * 创建时间：2018/8/23
  3.  * 编写人：kanghb
  4.  * 功能描述：学生（依赖需求方）
  5.  */
  6. public class Student {
  7.  
  8.     @Inject
  9.     Major major;
  10.  
  11.     public Student() {
  12.  
  13.     }
  14.  
  15.     @Override
  16.     public String toString() {
  17.         return "Student{" +
  18.                 "major=" + major +
  19.                 '}';
  20.     }
  21. }

3.Major类是依赖提供方，因此我们需要在它的构造函数上添加@Inject

  1. /**
  2.  * 创建时间：2018/8/23
  3.  * 编写人：kanghb
  4.  * 功能描述：专业（依赖提供方）
  5.  */
  6. public class Major {
  7.     @Inject
  8.     public Major() {
  9.     }
  10.     public void test(){
  11.         System.out.println("我是Major的方法");
  12.     }
  13. }

4.创建一个用@Component标注的接口StudentComponent，这个StudentComponent其实就是一个注入器，这里用来将Major注入到Student中。

  1. /**
  2.  * 创建时间：2018/8/24
  3.  * 编写人：kanghb
  4.  * 功能描述：
  5.  */
  6. @Component
  7. public interface StudentComponent {
  8.     void bind(Student student);
  9. }

注意：看一些文档里这里bind方法命名都是用inject的，我不知道是不是强制必须inject，所以写了bind看看测试一下，稍后揭晓结果。

5.上述操作完成后Build下项目，让Dagger2帮我们生成相关的Java类。

 

6.Student的构造函数中调用Dagger2生成的DaggerStudentComponent来实现注入。

Student类完整代码如下

  1. /**
  2.  * 创建时间：2018/8/23
  3.  * 编写人：kanghb
  4.  * 功能描述：学生（需求依赖方）
  5.  */
  6. public class Student {
  7.  
  8.     @Inject
  9.     Major major;
  10.  
  11.     public Student() {
  12.         DaggerStudentComponent.builder().build().bind(this);
  13.     }
  14.  
  15.     @Override
  16.     public String toString() {
  17.         return "Student{" +
  18.                 "major=" + major +
  19.                 '}';
  20.     }
  21.  
  22.     public Major getMajor() {
  23.         return major;
  24.     }
  25.  
  26. }

7.查看运行结果如下，证明我们前面说的inject方法不是强制的但有益于提升代码的可读性）

  1.  Student student = new Student();
  2.  student.getMajor().test();
08-24 01:57:58.035 2459-2459/kanghb.com.dagger2demo I/System.out: 我是Major的方法

二、@Module +@Provide标注构造方法提供依赖

如果创建Major的构造函数是带参数的呢？比如说制造一各专业是需要教师(teacher)的。或者Major类是我们无法修改的呢(依赖第三方，无法修改构造函数)？这时候就需要@Module和@Provide上场了。

1.在Student类的成员变量Major上加上@Inject表示自己需要Dagger2为自己提供依赖；Major类的构造函数上的@Inject也需要去掉，因为现在不需要通过构造函数上的@Inject来提供依赖了。

  1. public class Student {
  2.  
  3.     @Inject
  4.     Major major;
  5.  
  6.     public Student() {
  7.         DaggerStudentComponent.builder().makeMajorModule(new                                 MakeMajorModule()).build().inject(this);
  8.     }
  9.  
  10.     @Override
  11.     public String toString() {
  12.         return "Student{" +
  13.                 "major=" + major +
  14.                 '}';
  15.     }
  16.  
  17.     public Major getMajor() {
  18.         return major;
  19.     }
  20.  
  21. }

2.新建个Module类来生成依赖对象。前面介绍的@Module就是用来标准这个类的，而@Provide则是用来标注具体提供依赖对象的方法（这里有个不成文的规定，被@Provide标注的方法命名我们一般以provide开头，这并不是强制的但有益于提升代码的可读性）

  1. @Module
  2. public class MakeMajorModule {
  3.     public MakeMajorModule() {
  4.     }
  5.  
  6.     @Provides
  7.     public Major provideMajor(){
  8.         return new Major("kanghanbin");
  9.     }
  10. }

3.对StudentComponent进行一点点修改，之前的@Component注解是不带参数的，现在我们需要加上modules = {MakeMajorModule.class}，用来告诉Dagger2提供依赖的是MakeMajorModule这个类。

  1. @Component(modules = {MakeMajorModule.class})
  2. public interface StudentComponent {
  3.     void inject(Student student);
  4. }

4.Student类的构造函数我们也需要修改，相比之前多了个markCarModule(new MarkCarModule())方法，这就相当于告诉了注入器DaggerStudentComponent把MakeMajorModule提供的依赖注入到了Student类中

  1.  
  2.  
  3. public Student() {
  4.     DaggerStudentComponent.builder().makeMajorModule(new MakeMajorModule()).build().inject(this);
  5. }

注意：其实这里加不加 makeMajorModule(new MakeMajorModule())方法，都能顺利执行，为什么呢，打开DaggerStudentComponent一探究竟，发现就算不使用 makeMajorModule(new MakeMajorModule())方法，在调用build方法时，也直接 new MakeMajorModule（）。

  1. public static final class Builder {
  2.   private MakeMajorModule makeMajorModule;
  3.  
  4.   private Builder() {}
  5.  
  6.   public StudentComponent build() {
  7.     if (makeMajorModule == null) {
  8.       this.makeMajorModule = new MakeMajorModule();
  9.     }
  10.     return new DaggerStudentComponent(this);
  11.   }
  12.  
  13.   public Builder makeMajorModule(MakeMajorModule makeMajorModule) {
  14.     this.makeMajorModule = Preconditions.checkNotNull(makeMajorModule);
  15.     return this;
  16.   }
  17. }

5.执行结果同样是

08-24 01:57:58.035 2459-2459/kanghb.com.dagger2demo I/System.out: 我是Major的方法

三、@Qualifier实现一个类中有两个相同类型不同对象

Dagger2根据返回值的类型来决定为哪个被@Inject标记了的变量赋值。但是问题来了，一旦有多个一样的返回类型Dagger2就懵逼了。@Qulifier的存在正式为了解决这个问题，我们使用@Qulifier来定义自己的注解，然后通过自定义的注解去标注提供依赖的方法和依赖需求方。

1.使用Qulifier定义两个注解：

  1. @Qualifier
  2. @Retention(RetentionPolicy.RUNTIME)
  3. public @interface QualifierA {
  4.  
  5. }
  1. @Qualifier
  2. @Retention(RetentionPolicy.RUNTIME)
  3. public @interface QualifierB {
  4.  
  5. }

2.对依赖提供方做出修改

  1. @Module
  2. public class MakeMajorModule {
  3.     public MakeMajorModule() {
  4.     }
  5.     @QualifierA
  6.     @Provides
  7.     public Major provideMajorA(){
  8.         return new Major("kanghanbin");
  9.     }
  10.     @QualifierB
  11.     @Provides
  12.     public Major provideMajorB(){
  13.         return new Major("fenglin");
  14.     }
  15. }

3.对依赖需求方做出修改

  1. public class Student {
  2.  
  3.     @QualifierA
  4.     @Inject
  5.     Major major;
  6.     @QualifierB
  7.     @Inject
  8.     Major major2;
  9.  
  10.     public Student() {
  11.         DaggerStudentComponent.builder().makeMajorModule(new MakeMajorModule()).build().inject(this);
  12.     }
  13.  
  14.     @Override
  15.     public String toString() {
  16.         return "Student{" +
  17.                 "major=" + major +
  18.                 '}';
  19.     }
  20.  
  21.     public Major getMajorA() {
  22.         return major;
  23.     }
  24.     public Major getMajorB() {
  25.         return major2;
  26.     }

4.添加测试代码查看运行结果

  1.   Student student = new Student();
  2.   student.getMajorA().test();
  3.   student.getMajorB().test();
  1. 08-24 03:32:20.678 7632-7632/kanghb.com.dagger2demo I/System.out: 我是teacher为kanghanbinMajor的方法
  2. 08-24 03:32:20.679 7632-7632/kanghb.com.dagger2demo I/System.out: 我是teacher为fenglinMajor的方法

四、@Scope限定作用域

1.首先我们需要通过@Scope定义一个StudentScope注解：

  1. @Scope
  2. @Retention(RetentionPolicy.RUNTIME)
  3. public @interface StudentScope {
  4. }
  5.

2.接着我们需要用这个@StudentScope去标记依赖提供方MakeMajorModule。

  1. @StudentScope
  2. @Provides
  3. public Major provideMajorA(){
  4.     return new Major("kanghanbin");
  5. }

3.用@StudentScope去标注注入器 StudentComponent

  1. @StudentScope
  2. @Component(modules = {MakeMajorModule.class})
  3. public interface StudentComponent {
  4.     void inject(Student student);
  5. }

4.Student类改为

  1. @Inject
  2. Major major;
  3. @Inject
  4. Major major2;

5.Major类改为

  1. public Major(String teacher) {
  2.     this.teacher = teacher;
  3.     System.out.println("Create a Major");
  4. }
  5.  
  6. public void test(){
  7.     System.out.println("我是teacher为"+ teacher + "Major的方法");
  8. }

输出结果：

Create a Major

但是如果我么不加@StudentScope，就打印出两次

  1. Create a Major
  2. Create a Major

所以，通过@Scope实现了局部的单例。

dagger2原理分析

1.MakeMajorModule和MakeMajorModule_ProvideMajorAFactory

  1.  
  2. 自己写的类
  3. @Module
  4. public class MakeMajorModule {
  5.     public MakeMajorModule() {
  6.     }
  7. //    @QualifierA
  8.     @StudentScope
  9.     @Provides
  10.     public Major provideMajorA(){
  11.         return new Major("kanghanbin");
  12.     }  
  13. }
  14.  
  15.  
  16.  Dagger2生成的工厂类
  17. public final class MakeMajorModule_ProvideMajorAFactory implements Factory<Major> {
  18.   private final MakeMajorModule module;
  19.  
  20.   public MakeMajorModule_ProvideMajorAFactory(MakeMajorModule module) {
  21.     assert module != null;
  22.     this.module = module;
  23.   }
  24.  
  25.   @Override
  26.   public Major get() {
  27.     return Preconditions.checkNotNull(
  28.         module.provideMajorA(), "Cannot return null from a non-@Nullable @Provides method");
  29.   }
  30.  
  31.   public static Factory<Major> create(MakeMajorModule module) {
  32.     return new MakeMajorModule_ProvideMajorAFactory(module);
  33.   }

可以看到dagger2依据我们写的类给我们提供了一个工厂类，get（）方法调用了MakeMajorModule的provideMajorA()拿到了Major，create(MakeMajorModule module)通过传进来的MakeMajorModule 创建工厂类实例。

2.StudentComponent 和DaggerStudentComponent

  1.  
  2. 自己写的类
  3. @StudentScope
  4. @Component(modules = {MakeMajorModule.class})
  5. public interface StudentComponent {
  6.     void inject(Student student);
  7. }
  8.  
  9.  
  10.  Dagger2生成的StudentComponent的实现类
  11.  public final class DaggerStudentComponent implements StudentComponent {
  12.   private Provider<Major> provideMajorAProvider;
  13.  
  14.   private MembersInjector<Student> studentMembersInjector;
  15.  
  16.   private DaggerStudentComponent(Builder builder) {
  17.     assert builder != null;
  18.     initialize(builder);
  19.   }
  20.  
  21.   public static Builder builder() {
  22.     return new Builder();
  23.   }
  24.  
  25.   public static StudentComponent create() {
  26.     return builder().build();
  27.   }
  28.  
  29.   @SuppressWarnings("unchecked")
  30.   private void initialize(final Builder builder) {
  31.  
  32.     this.provideMajorAProvider =
  33.         DoubleCheck.provider(MakeMajorModule_ProvideMajorAFactory.create(builder.makeMajorModule));
  34.  
  35.     this.studentMembersInjector = Student_MembersInjector.create(provideMajorAProvider);
  36.   }
  37.  
  38.   @Override
  39.   public void inject(Student student) {
  40.     studentMembersInjector.injectMembers(student);
  41.   }
  42.  
  43.   public static final class Builder {
  44.     private MakeMajorModule makeMajorModule;
  45.  
  46.     private Builder() {}
  47.  
  48.     public StudentComponent build() {
  49.       if (makeMajorModule == null) {
  50.         this.makeMajorModule = new MakeMajorModule();
  51.       }
  52.       return new DaggerStudentComponent(this);
  53.     }
  54.  
  55.     public Builder makeMajorModule(MakeMajorModule makeMajorModule) {
  56.       this.makeMajorModule = Preconditions.checkNotNull(makeMajorModule);
  57.       return this;
  58.     }
  59.   }
  60. }

DaggerStudentComponent就是StudentComponent 的实现类，通过builder()方法返回了Builder对象，然后build创建了一个DaggerStudentComponent对象。在构造函数中初始化了provideMajorAProvider 和 studentMembersInjector。当调用inject时候，执行 studentMembersInjector.injectMembers(student)。

  1. 分析上一步提到的Student_MembersInjector

  1. public final class Student_MembersInjector implements MembersInjector<Student> {
  2.   private final Provider<Major> majorAndMajor2Provider;
  3.  
  4.   public Student_MembersInjector(Provider<Major> majorAndMajor2Provider) {
  5.     assert majorAndMajor2Provider != null;
  6.     this.majorAndMajor2Provider = majorAndMajor2Provider;
  7.   }
  8.  
  9.   public static MembersInjector<Student> create(Provider<Major> majorAndMajor2Provider) {
  10.     return new Student_MembersInjector(majorAndMajor2Provider);
  11.   }
  12.  
  13.   @Override
  14.   public void injectMembers(Student instance) {
  15.     if (instance == null) {
  16.       throw new NullPointerException("Cannot inject members into a null reference");
  17.     }
  18.     instance.major = majorAndMajor2Provider.get();
  19.     instance.major2 = majorAndMajor2Provider.get();
  20.   }
  21.  
  22.   public static void injectMajor(Student instance, Provider<Major> majorProvider) {
  23.     instance.major = majorProvider.get();
  24.   }
  25.  
  26.   public static void injectMajor2(Student instance, Provider<Major> major2Provider) {
  27.     instance.major2 = major2Provider.get();
  28.   }
  29. }

create方法在DaggerStudentComponent中被调用用来创建一个Student_MembersInjector对象，injectMembers（）方法也是在DaggerStudentComponent的inject中被调用初始化，用majorAndMajor2Provider.get()来初始化Student中的两个Major对象，从而Student依赖需求方就得到了major和major2的实例。而这里的majorAndMajor2Provider.get()就是MakeMajorModule_ProvideMajorAFactory里面的get方法。

换一种角度去思考（结合方法调用顺序再来一波分析）

首先Major构造方法是在provideMajor被调用的，然后看看是谁调用了provideMajor这个方法，发现是被MakeMajorModule_ProvideMajorFactory类里的get方法调用，再看看是谁调用了get方法，看到了是由Student_MembersInjector的injectMembers方法调用，而injectMembers正是在DaggerStudentComponent的inject方法中执行的，瞬间恍然大悟，从后往前看更容易理解

  1. @Provides
  2. public Major provideMajor(){
  3.     return new Major("kanghanbin");
  4. }
  1.   @Override
  2.   public Major get() {
  3.     return Preconditions.checkNotNull(
  4.         module.provideMajor(), "Cannot return null from a non-@Nullable @Provides method");
  5.   }
  1.   @Override
  2.   public void injectMembers(Student instance) {
  3.     if (instance == null) {
  4.       throw new NullPointerException("Cannot inject members into a null reference");
  5.     }
  6.       //都调用的是
  7.     instance.major = majorAndMajor2Provider.get();
  8.     instance.major2 = majorAndMajor2Provider.get();
  9.   }
  1.   @Override
  2.   public void inject(Student student) {
  3.     studentMembersInjector.injectMembers(student);
  4.   }

总结

本文只是简单的对dagger2分析了一下，没有真正在安卓项目中去运用，在开发安卓App过程中会遇到的比这更复杂，但是相信掌握了本篇所讲内容，再去结合实际开发去用它就没有那么难了。

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小惠珠哦/article/detail/830539
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号