Android -- 带你从源码角度领悟Dagger2入门到放弃（二）

1，接着我们上一篇继续介绍，在上一篇我们介绍了简单的@Inject和@Component的结合使用，现在我们继续以老师和学生的例子，我们知道学生上课的时候都会有书籍来辅助听课，先来看看我们之前的Student代码

package com.qianmo.rxjavatext;

import android.util.Log;

import javax.inject.Inject;

/**
 * Created by Administrator on 2017/4/17 0017.
 * E-Mail：[e-mail]
 */

public class Student {
    private int id;
    private String name;
    private Course[] course;

    @Inject
    public Student() {
        System.out.println("Student create!!!");
    }

    public Student(int id, String name, Course[] course) {
        this.id = id;
        this.name = name;
        this.course = course;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Course[] getCourse() {
        return course;
    }

    public void setCourse(Course[] course) {
        this.course = course;
    }

    public void startLessons() {
        System.out.println("开始上课了");
    }
}

　　添加书籍对象，在类中有书籍的姓名属性，还有变黑动作（这里是瞎加上这个动作的），Book的代码如下：

/**
 * Created by Administrator on 2017/4/20 0020.
 * E-Mail：[e-mail]
 */

public class Book {

    private String name;

    public Book(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void changeBlack() {
        System.out.println(name + "我一本新书被翻黑了。。。。");
    }
}

　　然后我们student中的构造函数也要添加了如下代码，且以前的构造函数需要删掉

package com.qianmo.rxjavatext;

import android.util.Log;

import javax.inject.Inject;

/**
 * Created by Administrator on 2017/4/17 0017.
 * E-Mail：[e-mail]
 */

public class Student {
    private int id;
    private String name;
    private Course[] course;
    private Book book;

    @Inject
    public Student(Book book) {
        System.out.println("Student create with book!!!");
    }

    public Student(int id, String name, Course[] course) {
        this.id = id;
        this.name = name;
        this.course = course;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Course[] getCourse() {
        return course;
    }

    public void setCourse(Course[] course) {
        this.course = course;
    }
    public void startLessons() {
        System.out.println("开始上课了");
        book.changeBlack();
    }
}

　　这时候我们会有一个猜想，当我们一个类中存在两个构造函数被标记了@Inject标记呢，那我们来试试代码如下：

　　@Inject
    public Student() {
        System.out.println("Student create!!!");
    }

    @Inject
    public Student(Book book) {
        System.out.println("Student create with book!!!");
    }

　　但是你最后运行的时候会直接报错了，报错信息如下，翻译过来意思就是说Student类中只能包含一个@Inject标记修饰构造函数

Error:(19, 12) 错误: Types may only contain one @Inject constructor.

　　OK，我们肯定现在脑袋了有这种疑问，要是我真的是想使用两个或者多个构造函数呢，别急，后面会和大家在实例中来讲解怎么使用的，好了还是回到我们正题上来，现在我们Student构造函数中出现了一个book对象，我们可能会想，有可能Dagger2会帮我们继续new一个Book对象放入Student构造函数中呐，好，我们抱着它能有这么智能我们来运行一下工程。

　　哦哦，sorry，报错了，我们来看一下报错提示，说不定我们能从报错信息来找到解决方法呐

Error:(12, 9) Gradle: 错误: com.qianmo.rxjavatext.Book cannot be provided without an @Inject constructor or from an @Provides-annotated method.

　　从上面你的信息我们知道它说book对象中没有提供一个标注为@Inject的构造方法，或者@Provides的方法。

　　好的我们就先用第一种方法试试，标记Book构造函数为@Inject，并修改在Student类中的成员变量book也标记成@Inject，运行一下项目，运行结构如下

Student create with book!!!
开始上课了
我一本新书被翻黑了。。。。

　　呃，可以了，没想到就这样可以了，666啊  ，这是我们使用的第一个方法，我们现在根据它之前报错信息的第二个方法来实现提供一个@Provides标记的方法

2，@Module和@Provides的使用

　　　而使用@Provides标记就要使用@Module标签了，先来回顾一下这两个注解标签的定义

@module,标注用于提供需要注入的实例的类，当我们要提供第三方的依赖时，使用Inject注解类的构造函数很明显不现实，这时就可以使用这个注解，在module中提供。
@Provides,使用在用@module标注的类里面，告诉dagger2来这里找依赖。

　　除了构造函数提供依赖，还能用Module提供。所以这里我们要创建一个Module，并创建@Provides注解标签修饰的对应的提供该对象的方法

@Module
public class TeacherModule {

    @Provides
    Book provideBook() {
        return new Book();
    }
}

　　这里需要解释一波了，首先provideBook这个方法名是固定的吗，当然不是固定的，不过我们为了逻辑清晰，一般采用然后修改provide开头，后面再加上类名，切记一定要加上@Provide标签，要让桥接器知道在这里找依赖。

　　然后要修改TeacherComponent中的module引用

package com.qianmo.rxjavatext;

import dagger.Component;

/**
 * Created by Administrator on 2017/4/20 0020.
 * E-Mail：[e-mail]
 */
@Component(modules = TeacherModule.class)
public interface TeacherComponent {
    void injectA(Teacher teacher);
}

　　修改调用方法

DaggerTeacherComponent.builder().teacherModule(new TeacherModule()).build().injectA(this);

　　看一下运行效果

Student create with book!!!
开始上课了
我一本新书被翻黑了。。。。

　　OK，打印结果没问题，这里我们想着既然Module能够提供依赖，那么我们把之前的Student的构造函数依赖添加到这里，代码如下：

package com.qianmo.rxjavatext;

import dagger.Module;
import dagger.Provides;

/**
 * Created by Administrator on 2017/4/20 0020.
 * E-Mail：[e-mail]
 */

@Module
public class TeacherModule {

    @Provides
    Book provideBook() {
        return new Book();
    }

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

　　这时候我们会有一个疑问，我们在Student构造函数加过@Inject注解又在Module中提供了依赖，这两个会不会冲突啊，我们心里面先带着这个疑问，运行一下项目，发现没什么问题运行结果如下：

Student create with book!!!
开始上课了
我一本新书被翻黑了。。。。

　　那么我们现在会有一个疑问了，到底我们是我们通过@Inject注解标记Student构造函数起了作用还是我们的Module中的provideStudent方法起作用了呢？那么是时候看一波我们的源码了，我们这次一共涉及到四个类DaggerTeacherComponent、Teacher_MembersInjector、TeacherModule_ProvideStudentFactory、TeacherModule_ProvideBookFactory，前面两个类和我们之前一篇文章源码分析类似，后面两个类从之前的StudentFactory变成了TeacherModule_ProvideStudentFactory、TeacherModule_ProvideBookFactory这两个类，从字面上我们也可以理解一个是从TeacherModule中获取Student对象的提供工厂，一个是从TeacherModule中获取Book对象的提供工厂。不多说，我们继续先来看看DaggerTeacherComponent类的源码

package com.qianmo.rxjavatext;

import dagger.MembersInjector;
import dagger.internal.Preconditions;
import javax.annotation.Generated;
import javax.inject.Provider;

@Generated(
  value = "dagger.internal.codegen.ComponentProcessor",
  comments = "https://google.github.io/dagger"
)
public final class DaggerTeacherComponent implements TeacherComponent {
  private Provider<Book> provideBookProvider;

  private Provider<Student> provideStudentProvider;

  private MembersInjector<Teacher> teacherMembersInjector;

  private DaggerTeacherComponent(Builder builder) {
    assert builder != null;
    initialize(builder);
  }

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

  public static TeacherComponent create() {
    return builder().build();
  }

  @SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {

    this.provideBookProvider = TeacherModule_ProvideBookFactory.create(builder.teacherModule);

    this.provideStudentProvider =
        TeacherModule_ProvideStudentFactory.create(builder.teacherModule, provideBookProvider);

    this.teacherMembersInjector = Teacher_MembersInjector.create(provideStudentProvider);
  }

  @Override
  public void injectA(Teacher teacher) {
    teacherMembersInjector.injectMembers(teacher);
  }

  public static final class Builder {
    private TeacherModule teacherModule;

    private Builder() {}

    public TeacherComponent build() {
      if (teacherModule == null) {
        this.teacherModule = new TeacherModule();
      }
      return new DaggerTeacherComponent(this);
    }

    public Builder teacherModule(TeacherModule teacherModule) {
      this.teacherModule = Preconditions.checkNotNull(teacherModule);
      return this;
    }
  }
}

　　可以看到和我们之前的DaggerTeacherComponent类源码有所不同，多了teacherModule、provideBookProvider、provideStudentProvider三个成员变量，多了teacherModule()方法。

　　ok，继续按照我们之前的方法分析首先调用DaggerTeacherComponent.builder()创建出一个Builder对象出来，再调用DaggerTeacherComponent.builder().teacherModule(new TeacherModule())，注意了，请看teacherModule()方法里面的源码

public Builder teacherModule(TeacherModule teacherModule) {
      this.teacherModule = Preconditions.checkNotNull(teacherModule);
      return this;
    }

　　这里先检查传递的teacherModule对象是否为空，让不为空的话将将值赋值到成员变量this.teacherModule上。

　　OK，我们继续往下看DaggerTeacherComponent.builder().teacherModule(new TeacherModule()).build()，接下来调用而是build方法，来看看具体的源码

public TeacherComponent build() {
      if (teacherModule == null) {
        this.teacherModule = new TeacherModule();
      }
      return new DaggerTeacherComponent(this);
    }

private DaggerTeacherComponent(Builder builder) {
    assert builder != null;
    initialize(builder);
  }

private void initialize(final Builder builder) {

    this.provideBookProvider = TeacherModule_ProvideBookFactory.create(builder.teacherModule);

    this.provideStudentProvider =
        TeacherModule_ProvideStudentFactory.create(builder.teacherModule, provideBookProvider);

    this.teacherMembersInjector = Teacher_MembersInjector.create(provideStudentProvider);
  }

　　从上面你的源码可以看到，首先我们在build方法判断teacherModule属性是否为空，如果为空则自己new一个TeacherModule对象（那这里是不是表示我们之前的teacherModule(new TeacherModule())方法可以偷懒不用写？  大家可以去试一试，的确可以的，手动微笑....），然后调用DaggerTeacherComponent类中的构造函数，在构造函数中调用initialize（）方法，好了这里是重点了，在这里我们赋值了provideBookProvider、provideStudentProvider两个成员对象，所以我们现在看看TeacherModule_ProvideBookFactory 、TeacherModule_ProvideStudentFactory中的create方法干了什么

package com.qianmo.rxjavatext;

import dagger.internal.Factory;
import dagger.internal.Preconditions;
import javax.annotation.Generated;

@Generated(
  value = "dagger.internal.codegen.ComponentProcessor",
  comments = "https://google.github.io/dagger"
)
public final class TeacherModule_ProvideBookFactory implements Factory<Book> {
  private final TeacherModule module;

  public TeacherModule_ProvideBookFactory(TeacherModule module) {
    assert module != null;
    this.module = module;
  }

  @Override
  public Book get() {
    return Preconditions.checkNotNull(
        module.provideBook(), "Cannot return null from a non-@Nullable @Provides method");
  }

  public static Factory<Book> create(TeacherModule module) {
    return new TeacherModule_ProvideBookFactory(module);
  }
}

　　

package com.qianmo.rxjavatext;

import dagger.internal.Factory;
import dagger.internal.Preconditions;
import javax.annotation.Generated;
import javax.inject.Provider;

@Generated(
  value = "dagger.internal.codegen.ComponentProcessor",
  comments = "https://google.github.io/dagger"
)
public final class TeacherModule_ProvideStudentFactory implements Factory<Student> {
  private final TeacherModule module;

  private final Provider<Book> bookProvider;

  public TeacherModule_ProvideStudentFactory(TeacherModule module, Provider<Book> bookProvider) {
    assert module != null;
    this.module = module;
    assert bookProvider != null;
    this.bookProvider = bookProvider;
  }

  @Override
  public Student get() {
    return Preconditions.checkNotNull(
        module.provideStudent(bookProvider.get()),
        "Cannot return null from a non-@Nullable @Provides method");
  }

  public static Factory<Student> create(TeacherModule module, Provider<Book> bookProvider) {
    return new TeacherModule_ProvideStudentFactory(module, bookProvider);
  }
}

　　大家请看这两个类中的get方法中的参数！！！！  首先TeacherModule_ProvideBookFactory中调用的是module.provideBook()，获取到我们的book创建的对象，在看TeacherModule_ProvideStudentFactory中的get方法首先拿到TeacherModule_ProvideStudentFactory中的book对象，然后在调用 module.provideStudent(bookProvider.get())方法，拿到TeacherModule中创建的Student对象。

　　ok现在基本流程清楚了，最后调用injectA（this）方法在Teacher_MembersInjector类中把当前的Teacher对象中的student属性被赋值到TeacherModule_ProvideStudentFactory.get()上去，这样我们的赋值就完成了。

　　那么这里我们可以有一下结论

我们有两种方式可以提供依赖，一个是注解了@Inject的构造方法，一个是在Module里提供的依赖，那么Dagger2是怎么选择依赖提供的呢，规则是这样的：

步骤1：查找Module中是否存在创建该类的方法。
步骤2：若存在创建类方法，查看该方法是否存在参数
步骤2.1：若存在参数，则按从步骤1开始依次初始化每个参数
步骤2.2：若不存在参数，则直接初始化该类实例，一次依赖注入到此结束
步骤3：若不存在创建类方法，则查找Inject注解的构造函数，看构造函数是否存在参数

步骤3.1：若存在参数，则从步骤1开始依次初始化每个参数

步骤3.2：若不存在参数，则直接初始化该类实例，一次依赖注入到此结束

概括一下就是从注解了@Inject的对象开始，从Module和注解过的构造方法中获得实例，若在获取该实例的过程中需要其他类的实例，则继续获取被需要类的实例对象的依赖，同样是从Module和标注过的构造方法中获取，并不断递归这个过程直到所有被需要的类的实例创建完成，在这个过程中Module的优先级高于@Inject注解过的构造方法。

　　这样我们就懂了为什么同事存在Module和@Inject都不会报错，且它对Module和@Inject提供对象实例的优先级关系了。

3、@Qulifier的使用

　　现在继续扩展业务，由于学校扩招，现在任课老师下面由之前的一个学生变成了两个学生，且新来的那个学生是没有书籍的，那么在我们java代码中怎么表示这种场景呢？

package com.qianmo.rxjavatext;

import javax.inject.Inject;

/**
 * Created by Administrator on 2017/4/20 0020.
 * E-Mail：[e-mail]
 */

public class Teacher {
    //想持有学生对象
    @Inject
    Student student1; //带了书的

    @Inject
    Student student2; //没带了书的

    public Teacher() {
        DaggerTeacherComponent.builder().teacherModule(new TeacherModule()).build().injectA(this);
    }

    public void teacher() {
        student1.startLessons();
        student2.startLessons();
    }

    public static void main(String[] args) {
        new Teacher().teacher();
    }
}

　　自该修改Student中的构造函数，添加不带书的构造方法

    public Student(Book book) {
        System.out.println("Student create with book!!!");
        this.book = book;
    }

    public Student() {
        System.out.println("Student create without book!!!");
        this.book = new Book("对不起我没有书啊");
    }

　　这时候我们想是想student2获取的是Student（）的无参构造的对象，所以我们相当然的在我们的Module中添加对应的提供方法，代码如下：

package com.qianmo.rxjavatext;

import dagger.Module;
import dagger.Provides;

/**
 * Created by Administrator on 2017/4/20 0020.
 * E-Mail：[e-mail]
 */

@Module
public class TeacherModule {

    @Provides
    Book provideBook() {
        return new Book("我是真实的书籍呢...");
    }

    /**
     * 提供有书的学生
     * @param book
     * @return
     */
    @Provides
    Student provideStudentA(Book book) {
        return new Student(book);
    }

    /**
     * 提供没书的学生
     * @return
     */
    @Provides
    Student provideStudentB() {
        return new Student();
    }
}

　　然后你开开心心的运行项目，会发现直接报错了，报错如下：

Error:(10, 9) Gradle: 错误: com.qianmo.rxjavatext.Student is bound multiple times:
@Provides com.qianmo.rxjavatext.Student com.qianmo.rxjavatext.TeacherModule.provideStudentA(com.qianmo.rxjavatext.Book)
@Provides com.qianmo.rxjavatext.Student com.qianmo.rxjavatext.TeacherModule.provideStudentB()

　　明面字义翻译过来就是“绑定的时候迷失了自己在provideStudentA、provideStudentB方法之间”，我们专业术语叫“做依赖迷失”，因为Dagger2是根据返回类型来进行依赖注入的，但是这里我们提供了A、B两个方法返回相同的对象，这时候我们的student1、studnet2不知道他们自己到底是要创建有书的对象呢还是没有书的对象呢。

　　so，为了解决这个问题，我们的Dagger2提供了@Qulifier，可以通过自定义注解，来告诉Dagger2我这次到底是想依赖那个方法，这里不会注解的同学可以去看一下我之前写的这篇文章，那我们就来创建StudentA和StudnetB自定义注解

package com.qianmo.rxjavatext;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

import javax.inject.Qualifier;

/**
 * Created by Administrator on 2017/4/21 0021.
 * E-Mail：[e-mail]
 */
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface StudentA {
}

　　

package com.qianmo.rxjavatext;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

import javax.inject.Qualifier;

/**
 * Created by Administrator on 2017/4/21 0021.
 * E-Mail：[e-mail]
 */
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface StudentB {
}

　　然后在Module中添加这个注解

/**
     * 提供有书的学生
     * @param book
     * @return
     */
    @StudentA
    @Provides
    Student provideStudentA(Book book) {
        return new Student(book);
    }

    /**
     * 提供没书的学生
     * @return
     */
    @StudentB
    @Provides
    Student provideStudentB() {
        return new Student();
    }

　　在需要使用student对象的地方添加

 //想持有学生对象
    @Inject
    @StudentA
    Student student1; //带了书的

    @Inject
    @StudentB
    Student student2; //没带了书的

　　ok，运行一下项目，看一下打印效果

Student create with book!!!
Student create without book!!!
开始上课了
我一本新书被翻黑了。。。。我是真实的书籍呢...
开始上课了
我一本新书被翻黑了。。。。对不起我没有书啊

　　没问题，这里我们Dagger2为了让我们使用方便实际上是提供了一个@Name标签供我们使用的，看一下它里面的内容

@Qualifier
@Documented
@Retention(RUNTIME)
public @interface Named {

    /** The name. */
    String value() default "";
}

　　在底层也是使用了我们@Qualifier标签的，所以如果使用@Name标签来实现我们上面的效果的话是这样的

 /**
     * 提供有书的学生
     * @param book
     * @return
     */
    @Provides
    @Named("StudentA")
    Student provideStudentA(Book book) {
        return new Student(book);
    }

    /**
     * 提供没书的学生
     * @return
     */
    @Provides
    @Named("StudentB")
    Student provideStudentB() {
        return new Student();
    }

　　

 //想持有学生对象
    @Inject
    @Named("StudentA")
    Student student1; //带了书的

    @Inject
    @Named("StudentB")
    Student student2; //没带了书的

　　哈哈哈，看到这儿有没有同学想说我是马后炮的（其实，只能我们自己知道了它是怎么实现的才能更好的使用），说你直接介绍@Name标签不就行了，但是不利于我们之后的深层次的学习。

4，@Scope的使用

　　这个标签不是很好理解，给的解释是该注解能够使同一个Component中的对象保持唯一，即单例（一定要记住是局部单例）。

　　那么我们来写一个栗子试试

　　首先继续自定义注解，并添加

package com.qianmo.rxjavatext;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

import javax.inject.Qualifier;
import javax.inject.Scope;

/**
 * Created by Administrator on 2017/4/21 0021.
 * E-Mail：[e-mail]
 */
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface StudentOnlyOne {
}

　　在B中添加方法标签的引用

 /**
     * 提供没书的学生
     * @return
     */
    @Provides
    @StudentOnlyOne
    @Named("StudentB")
    Student provideStudentB() {
        return new Student();
    }

　　修改Teacher中的两个学生变量的使用，都是用B方法提供Student对象

    @Inject
    @Named("StudentB")
    Student student1; //带了书的

    @Inject
    @Named("StudentB")
    Student student2; //没带了书的

　　最后，很重要！！！在你的component中添加上面标注！！！！，不然你就等着bug满天飞吧（在这儿趟坑了很久）

package com.qianmo.rxjavatext;

import dagger.Component;

/**
 * Created by Administrator on 2017/4/20 0020.
 * E-Mail：[e-mail]
 */
@StudentOnlyOne
@Component(modules = TeacherModule.class)
public interface TeacherComponent {
    void injectA(Teacher teacher);
}

　　ok，运行一下，看一下打印效果，

Student create without book!!!
开始上课了
我一本新书被翻黑了。。。。对不起我没有书啊
开始上课了
我一本新书被翻黑了。。。。对不起我没有书啊

　　书的确只被创建了一次，ok，其实我们Dagger2中也提供了封装好了的@Scope，就是我们的@Singleton，看一下它的源码

@Scope
@Documented
@Retention(RUNTIME)
public @interface Singleton {}

　　也是应用了@Scope标签，对不起，又马后炮了一次（哈哈哈........）

　　到这里我们的Dagger2的标签基本上就全部学习完了，后面一篇我将和大家一起看看，在Android中的Activity ，Dagger2能帮我们做些什么

　　最后！！！还有一个很关键事：最近打算辞职回北京，有没有大神同学推荐工作，带带啊啊啊啊啊

　　下一篇：Android -- 带你从源码角度领悟Dagger2入门到放弃（三）