Android Dagger2 Module&Component源码分析（二）

一、前言：

上一篇：Android Dagger2基础使用（一）https://www.jianshu.com/p/78de2d573533
通过Dagger2依赖注入的两种方式获取User对象,并简单了解了各个组件的作用和互相的联系:

@Inject ： 注入，被注解的构造方法会自动编译生成一个Factory工厂类提供该类对象。
@Component: 注入器，类似快递员，作用是将产生的对象注入到需要对象的容器中，供容器使用。
@Module: 模块，类似快递箱子，在Component接口中通过@Component(modules =
xxxx.class),将容器需要的商品封装起来，统一交给快递员（Component），让快递员统一送到目标容器中。

gitHub 地址：https://github.com/lyyRunning/DaggerDemo

二、带Inject源码解析：

我们打开app目录下的build文件夹，以笔者为例，目录结构为：

/Users/luo/develop/my/DaggerDemo/app/build/generated/source/apt/debug....../A01SimpleActivity_MembersInjector.java

如下图：


image.png

我们不难发现，编译器已经帮我们生成了这样几个文件：

DaggerA01SimpleComponent
User_Factory
A01SimpleActivity_MembersInjector

1. User_Factory.java

上一篇文章我们已经进行了分析，很简单，当我们@Inject注解一个类的构造方法时，编译器会自动帮我们生成一个工厂类，负责生产该类的对象，类似于商品的厂家

public enum User_Factory implements Factory<User> {
  INSTANCE;

  @Override
  public User get() {
    return new User();
  }

  public static Factory<User> create() {
    return INSTANCE;
  }
}

2. DaggerA01SimpleComponent类

public final class DaggerA01SimpleComponent implements A01SimpleComponent {
  private MembersInjector<A01SimpleActivity> a01SimpleActivityMembersInjector;

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

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

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

  @SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {
    //初始化A01SimpleActivity_MembersInjector
    this.a01SimpleActivityMembersInjector =
        A01SimpleActivity_MembersInjector.create(User_Factory.create());
  }

  @Override
  public void inject(A01SimpleActivity activity) {
    a01SimpleActivityMembersInjector.injectMembers(activity);
  }

  public static final class Builder {
    private Builder() {}

    public A01SimpleComponent build() {
      return new DaggerA01SimpleComponent(this);
    }

    /**
     * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://google.github.io/dagger/unused-modules.
     */
    @Deprecated
    public Builder a01SimpleModule(A01SimpleModule a01SimpleModule) {
      Preconditions.checkNotNull(a01SimpleModule);
      return this;
    }
  }
}

很熟悉，我们在Activity中就用到了这个生成的类，编译器起名方式也很简洁：Dagger+你的Component接口名

在我们的Activity中我们是这样使用：

 //添加新代码
        DaggerA01SimpleComponent.builder()
            //  .a01SimpleModule(new A01SimpleModule(this))
                .build()
                .inject(this);

我们根据这个步骤查看源码，发现

DaggerA01SimpleComponent.builder().build()

实际上是通过建造者模式创建了一个新的DaggerA01SimpleComponent对象，在这个对象的构造方法中，执行了initialize()方法，初始化了一个A01SimpleActivity_MembersInjector对象。

请注意，在初始化A01SimpleActivity_MembersInjector时我们看到这行代码：

 this.a01SimpleActivityMembersInjector =
 A01SimpleActivity_MembersInjector.create(User_Factory.create());

可以看到，Student工厂类作为参数传入了Injector中。

然后通过调用

DaggerA01SimpleComponent.builder().build().inject(this);

中，实际上是将Activity作为参数传入了A01SimpleActivity_MembersInjector对象的InjectMembers()方法里面，仅此而已。

很好，我们看起来已经明白了Component的作用：编译器通过@Component注解，生成了DaggerA01SimpleComponent类，然后将activity传入初始化了的A01SimpleActivity_MembersInjector对象中。

这时我们有了一点头绪，因为我们发现，Student工厂类，已经和Activity同时都放入了这个神秘的A01SimpleActivity_MembersInjector类中了。

3. A01SimpleActivity_MembersInjector类,将User和Activity进行连接

public final class A01SimpleActivity_MembersInjector implements MembersInjector<A01SimpleActivity> {
  private final Provider<User> userProvider;

  public A01SimpleActivity_MembersInjector(Provider<User> userProvider) {
    assert userProvider != null;
    this.userProvider = userProvider;
  }

  public static MembersInjector<A01SimpleActivity> create(Provider<User> userProvider) {
    return new A01SimpleActivity_MembersInjector(userProvider);
  }

  @Override
  public void injectMembers(A01SimpleActivity instance) {
    if (instance == null) {
      throw new NullPointerException("Cannot inject members into a null reference");
    }
    instance.user = userProvider.get();
  }

  public static void injectUser(A01SimpleActivity instance, Provider<User> userProvider) {
    instance.user = userProvider.get();
  }
}

其实已经很简单了，在该Injector的injectMembers()方法中，已经将User对象通过User_Factory的get()方法获得，然后直接赋值给Activity的user对象了！

就是这行代码：

instance.user = userProvider.get();

private final Provider userProvider ->就是在create（）方法中传入的User_Factory工厂类，不信？点击Factory类：

public interface Factory<T> extends Provider<T> {
}

很明显了，User_Factory父类是 Factory,Factory父类是Provider，向上转型嘛。

三、带Module的源码解析：

1. User 类 （取消Inject注解）：

public class User {
    public User() {
    }
}

2. Module类（增加一个Provide注解方法）：

@Module
public class A01SimpleModule {
    private A01SimpleActivity activity;

    public A01SimpleModule(A01SimpleActivity activity) {
        this.activity = activity;
    }

    //下面为新增代码：
    @Provides
    User provideUser(){
        return new User();
    }
}

3. Component(不变) ：

@Component(modules = A01SimpleModule.class)
public interface A01SimpleComponent {

    void inject(A01SimpleActivity activity);
}

4. Activity（新增一行代码）：

public class A01SimpleActivity extends Activity {

    @BindView(R.id.btn1)
    Button btn1;

    @Inject
    User user;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_a01_simple);
        ButterKnife.bind(this);

        //添加新代码.a01SimpleModule(new A01SimpleModule(this))
        DaggerA01SimpleComponent.builder()
                .a01SimpleModule(new A01SimpleModule(this))
                .build()
                .inject(this);

    }

    @OnClick(R.id.btn1)
    public void onViewClicked() {

        Toast.makeText(this,user.toString(),Toast.LENGTH_LONG).show();
    }

}

我们先把app/build文件夹删除，删除自动生成的代码后，然后ctrl+F9重新编译,编译成功运行，依然可以获得User对象。

这时我们打开build目录，层层剥开后，发现这样三个类：

DaggerA01SimpleComponent
A01SimpleModule_ProvideUserFactory
A01SimpleActivity_MembersInjector

5. A01SimpleModule_ProvideUserFactory类

public final class A01SimpleModule_ProvideUserFactory implements Factory<User> {
  private final A01SimpleModule module;

  public A01SimpleModule_ProvideUserFactory(A01SimpleModule module) {
    assert module != null;
    this.module = module;
  }

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

  public static Factory<User> create(A01SimpleModule module) {
    return new A01SimpleModule_ProvideUserFactory(module);
  }
}

我们知道，我们在Module中创建了一个provideUser()方法，方法中创建并返回了一个User对象，其实很相似，Module的@Provides注解就是帮助我们生成了一个User_Factory的工厂，只不过这个工厂很特别，只有钥匙才能进(必须传入A01SimpleModule对象才能实例化)：

//没有传入A01SimpleModule对象，无法实例化该工厂对象
 public static Factory<User> create(A01SimpleModule module) {
    return new A01SimpleModule_ProvideUserFactory(module);
  }

我们查看A01SimpleModule会发现，想实例化A01SimpleModule，必须传入一个A01SimpleActivity对象，这说明了，A01SimpleModule就像是一个专属的快递箱子，只有本人（A01SimpleActivity）才能签收私人快递，然后打开自己的盒子（A01SimpleModule->创建A01SimpleModule_ProvideUserFactory）获得这个User对象！

简单来说，通过@Providers注解后，产生的对象就经过Module包装，通过Component快递员送到需要的容器Activity中。

相比@Inject简单粗暴的注解生成的“万能工厂”User_Factory类，似乎这个更“安全”一些~

6. DaggerA01SimpleComponent类

public final class DaggerA01SimpleComponent implements A01SimpleComponent {
  private Provider<User> provideUserProvider;

  private MembersInjector<A01SimpleActivity> a01SimpleActivityMembersInjector;

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

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

  @SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {
    //创建A01SimpleModule专属工厂
    this.provideUserProvider = A01SimpleModule_ProvideUserFactory.create(builder.a01SimpleModule);
    //将专属工厂放入 Injector 中
    this.a01SimpleActivityMembersInjector =
        A01SimpleActivity_MembersInjector.create(provideUserProvider);
  }

  @Override
  public void inject(A01SimpleActivity activity) {
   //将 Activity 容器传入 Injector 中
    a01SimpleActivityMembersInjector.injectMembers(activity);
  }

  public static final class Builder {
    private A01SimpleModule a01SimpleModule;

    private Builder() {}

    public A01SimpleComponent build() {
      if (a01SimpleModule == null) {
        throw new IllegalStateException(A01SimpleModule.class.getCanonicalName() + " must be set");
      }
      return new DaggerA01SimpleComponent(this);
    }
    //传入需要的 Mouble
    public Builder a01SimpleModule(A01SimpleModule a01SimpleModule) {
      this.a01SimpleModule = Preconditions.checkNotNull(a01SimpleModule);
      return this;
    }
  }
}

变化很少，相比较@Inject注解的方式，@Inject注解生成的工厂类就好像将商品赤裸着交给Component,@module注解生成的工厂类就好像给商品加了一层防护纸箱，感觉更贴心了呢~

7. A01SimpleActivity_MembersInjector类

public final class A01SimpleActivity_MembersInjector implements MembersInjector<A01SimpleActivity> {
  private final Provider<User> userProvider;

  public A01SimpleActivity_MembersInjector(Provider<User> userProvider) {
    assert userProvider != null;
    this.userProvider = userProvider;
  }

  public static MembersInjector<A01SimpleActivity> create(Provider<User> userProvider) {
    return new A01SimpleActivity_MembersInjector(userProvider);
  }

  @Override
  public void injectMembers(A01SimpleActivity instance) {
    if (instance == null) {
      throw new NullPointerException("Cannot inject members into a null reference");
    }
    instance.user = userProvider.get();
  }

  public static void injectUser(A01SimpleActivity instance, Provider<User> userProvider) {
    instance.user = userProvider.get();
  }
}

可以发现，基本并没有什么变化。

四、总结：

经过两次分析 我们基本理解了Dagger2的使用方式，原理基本如下：

  1. @Inject 注解构造 生成“大众”工厂类
    或者
    @Module +@Providers 提供注入“私有”工厂类

  2. 通过Component 创建获得Activity,获得工厂类Provider，统一交给Injector

  3. Injector将Provider的get()方法提供的对象，注入到Activity容器对应的成员变量中，我们就可以直接使用Activity容器中对应的成员变量了！

了解了原理，接下来怎么使用就随意了~在接下来的文章中，我会结合MVP的架构对Dagger2进行更深入的使用。

原文链接：https://blog.csdn.net/mq2553299/article/details/73136396

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 216,544评论 6赞 501
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,430评论 3赞 392
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 162,764评论 0赞 353
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,193评论 1赞 292
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,216评论 6赞 388
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,182评论 1赞 299
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,063评论 3赞 418
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,917评论 0赞 274
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,329评论 1赞 310
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,543评论 2赞 332
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,722评论 1赞 348
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,425评论 5赞 343
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,019评论 3赞 326
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,671评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,825评论 1赞 269
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,729评论 2赞 368
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,614评论 2赞 353