Dagger2源码剖析

最新推荐文章于 2021-12-22 10:18:14 发布
置顶 最新推荐文章于 2021-12-22 10:18:14 发布
阅读量2.5k 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 流行框架 Android开发流行框架 文章标签： 源码 dagger android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u012926924/article/details/52056180
本文深入剖析Dagger2的源码，讲解其注解使用，如@Inject, @Module, @Component等，并探讨处理注解的类如何在编译期生成代码，实现依赖注入。通过调用API的方式，理解Dagger2如何构建依赖图并注入对象。" 107587454,9762682,iview组件使用技巧与常见问题解析,"['Vue', 'JavaScript', '前端框架', 'iview', '组件库']

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Dagger2源码剖析

Dagger是一个非常优秀的IOC框架，使用Dagger能够极大减少代码耦合，介绍Dagger如何使用的文章网上有很多，在这里给大家推荐3篇，作者讲得非常白话，大家应该可以理解：

在使用过Dagger之后，大家不免会对其实现原理产生疑问，本文就对Dagger的源码进行剖析。(由于dagger代码并未开源，一些细节方面的东西可能讲不到)

首先Dagger是基于APT开发的，所以请大家先看下我之前写的一篇文章

编译期注解浅析

好的，终于完成了系列的准备工作，

接下来咱们还是沿着我上篇文章中提到的编译期注解的三要素，一一剖析Dagger框架

注解

dagger里面常用的注解
无非就是

  • @Inject
  • @Moudel
  • @Component
  • @Qualifier
  • @Scope
@Target({ METHOD, CONSTRUCTOR, FIELD })
@Retention(RUNTIME)
@Documented
public @interface Inject {}
@Target(ANNOTATION_TYPE)
@Retention(RUNTIME)
@Documented
public @interface Qualifier {}
@Target(ANNOTATION_TYPE)
@Retention(RUNTIME)
@Documented
public @interface Scope {}

这3个注解不来自dagger，而来自java本身！，通过这些注解的源码我们关键要捕获一个信息，这些注解在哪里使用，可以看到Inject可以在方法，构造方法，属性上面使用，而Qualifier和Scope则只能在注解上面使用（意味着我们不能直接使用他们，所以就有了@Name @Singleton这些注解）

再看看dagger自己写的注解

@Retention(RUNTIME) 
@Target(TYPE)
@Documented
public @interface Component {
  Class<?>[] modules() default {};

  Class<?>[] dependencies() default {};
}

Component注解在类上，可以包含多个Modules,也可以依赖多个Component.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Module {
  Class<?>[] includes() default {};
}

Module也是注解在类上

@Documented 
@Target(METHOD) 
@Retention(RUNTIME)
public @interface Provides {
  enum Type {
    UNIQUE,
    SET,
    SET_VALUES;
  }

  Type type() default Type.UNIQUE;
}

在@Provides这个里面需要注意的是”SET”的这个设置，这个是什么意思呢？如果你选择了”UNIQUE”(其实就是不选)。那么别人一需要这个对象就会来你这里找(必须是唯一的，除了Inject(因为他们优先级不同))，但使用了SET后，你其实就是把生产出来的对象扔到一个对象池里，需要的时候从池里面拿。(这个是个人理解，如果有误，这块请大家私信我，我也好好学习学习)。

处理注解的类

 apt 'com.google.dagger:dagger-compiler:{version}'

这也是我们为什么需要在Build.gradle里面加上这句话的原因，因为我们需要他们在编译期生成代码

整个Dagger的流程其实就是一个画图的过程，将能够提供对象的类于需要对象的类画在一张图上，这样就实现了所谓依赖注入

接下来我们看一下处理注解的类:

首先，我们必须找到注解的入口


@AutoService(Processor.class)
public final class ComponentProcessor
extends BasicAnnotationProcessor {}

没错，只是这个类(当然里面有很多方法)，包括上面的注解分析，还有这里处理注解的类，如果你找的和我不一样，那说明你是在看dagger1，github上只有1

这个类会生成怎么样的代码呢？

 @Generated("dagger.internal.codegen.ComponentProcessor")
public final class DaggerAppComponent implements AppComponent {
  private Provider<HRApp> provideApplicationProvider;

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

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

  private void initialize(final Builder builder) {  
    this.provideApplicationProvider = ScopedProvider.create(AppModule_ProvideApplicationFactory.create(builder.appModule));
  }

  @Override
  public HRApp getApplication() {  
    return provideApplicationProvider.get();
  }

  public static final class Builder {
    private AppModule appModule;

    private Builder() {  
    }

    public AppComponent build() {  
      if (appModule == null) {
        throw new IllegalStateException("appModule must be set");
      }
      return new DaggerAppComponent(this);
    }

    public Builder appModule(AppModule appModule) {  
      if (appModule == null) {
        throw new NullPointerException("appModule");
      }
      this.appModule = appModule;
      return this;
    }
  }
}

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class AppModule_ProvideApplicationFactory implements Factory<HRApp> {
  private final AppModule module;

  public AppModule_ProvideApplicationFactory(AppModule module) {  
    assert module != null;
    this.module = module;
  }

  @Override
  public HRApp get() {  
    HRApp provided = module.provideApplication();
    if (provided == null) {
      throw new NullPointerException("Cannot return null from a non-@Nullable @Provides method");
    }
    return provided;
  }

  public static Factory<HRApp> create(AppModule module) {  
    return new AppModule_ProvideApplicationFactory(module);
  }
}

这个是component和module生成的代码，module其实就是生成一个产生对象的工厂。每次需要对象的时候，现在看到了吧，为什么我们的component要用接口，因为dagger要实现它。现在情况是module生成的类提供对象，component拿到这个对象然后注入到需要它的对象中，然而怎么知道谁需要呢？

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class BaseActivity_MembersInjector implements MembersInjector<BaseActivity> {
  private final MembersInjector<AppCompatActivity> supertypeInjector;
  private final Provider<HRApp> applicationProvider;

  public BaseActivity_MembersInjector(MembersInjector<AppCompatActivity> supertypeInjector, Provider<HRApp> applicationProvider) {  
    assert supertypeInjector != null;
    this.supertypeInjector = supertypeInjector;
    assert applicationProvider != null;
    this.applicationProvider = applicationProvider;
  }

  @Override
  public void injectMembers(BaseActivity instance) {  
    if (instance == null) {
      throw new NullPointerException("Cannot inject members into a null reference");
    }
    supertypeInjector.injectMembers(instance);
    instance.application = applicationProvider.get();
  }

  public static MembersInjector<BaseActivity> create(MembersInjector<AppCompatActivity> supertypeInjector, Provider<HRApp> applicationProvider) {  
      return new BaseActivity_MembersInjector(supertypeInjector, applicationProvider);
  }
}

一个类有@inject注解的时候就会生成这样的一个类，这类就是这个类所以需要注入的汇总。

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class DaggerActivityComponent implements ActivityComponent {
  private Provider<HRApp> getApplicationProvider;
  private MembersInjector<BaseActivity> baseActivityMembersInjector;

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

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

  private void initialize(final Builder builder) {  
    this.getApplicationProvider = new Factory<HRApp>() {
      private final AppComponent appComponent = builder.appComponent;
      @Override public HRApp get() {
        HRApp provided = appComponent.getApplication();
        if (provided == null) {
          throw new NullPointerException("Cannot return null from a non-@Nullable component method");
        }
        return provided;
      }
    };
    this.baseActivityMembersInjector = BaseActivity_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), getApplicationProvider);
  }

  @Override
  public void inject(BaseActivity baseActivity) {  
    baseActivityMembersInjector.injectMembers(baseActivity);
  }

  public static final class Builder {
    private ActivityModule activityModule;
    private AppComponent appComponent;

    private Builder() {  
    }

    public ActivityComponent build() {  
      if (activityModule == null) {
        this.activityModule = new ActivityModule();
      }
      if (appComponent == null) {
        throw new IllegalStateException("appComponent must be set");
      }
      return new DaggerActivityComponent(this);
    }

    public Builder activityModule(ActivityModule activityModule) {  
      if (activityModule == null) {
        throw new NullPointerException("activityModule");
      }
      this.activityModule = activityModule;
      return this;
    }

    public Builder appComponent(AppComponent appComponent) {  
      if (appComponent == null) {
        throw new NullPointerException("appComponent");
      }
      this.appComponent = appComponent;
      return this;
    }
  }
}

看到了吧！我们经常写的void inject(xxx)，这时候就会在对应的component里面生成对应的注入对象，这样component就知道谁需要注入了。

形象的说，含有注解的类生成的类相对于一次汇总将本类所有需求汇总汇报给component生成的类，然后comonent知道需要后就找生产对应对象的工厂要东西了。

调用api

dagger的调用api就是component生成的那个类，一般是先build出，然后调个inject(xxx)，如果上面认真看代码的话，就可以看到这个方法将会调那个含注解类生成的类的方法，这个方法就真正实现了注入，而那个对象的提供者，是在component构建含注解类生成的类的时候传入的。

好了，dagger流程基本就是这样，有个关键点没讲，那就是那个源码中是如何生成代码，没办法google没有开源dagger2的源码，我只能找到其中core部分的，其中编译部分找不到，有知道的人欢迎联系我。

后记

个人认为dagger的出现非常大解决了android耦合问题，和mvp配合简直耦合直降，代码结构瞬间清晰。希望大家以后多多使用mvp+dagger的组合写出优秀的代码

Dagger2源码分析一
irXiang的专栏
06-21 262
写一个最基本的注入过程，分别有ClassA,ModuleA,ComponentA三个类public class ClassA {}@Modulepublic class ModuleA {    @Provides    public ClassA provideA(){        return new ClassA();    }}@Component(modules = ModuleA.c...
详细的Dagger2+MVP融合，一行一行分析，一点一点进步
02-25
详细的Dagger2+MVP融合，一行一行分析，一点一点进步源码
dagger2Test源代码
03-10
本人博客《Dagger2在Android studio中的配置与简单使用》对应的源码
Dagger2源码解析
JackWangDev的博客
02-20 341
Android 神兵利器Dagger2使用详解（一）基础使用 https://blog.youkuaiyun.com/mq2553299/article/details/73065745 Android 神兵利器Dagger2使用详解（二）Module&amp;Component源码分析 https://blog.youkuaiyun.com/mq2553299/article/details/73136396 ...
Dagger2源码分析
寻找极限的猫
07-29 938
前言 上文dagger2入门教程以一个实例介绍了dagger2的相关组件，概念是使用的方法。本文继续以上文的例子为基础，对其进行源码分析。 1. dagger2生成的代码 如下图说示，右边是我们申明的Component和Module，左边是dagger2生成的对应代码。从图中可以看出，我们申明了ActivityComponent，dagger2就会给我们生成一个对应的Dagger2Act...
你所看到较轻松的Dagger2(源码分析)
boboyuwu的博客
08-07 663
上篇我们介绍完了Dagger2的详细使用方式,这篇我们分析一下Dagger2为什么这么神奇,它是怎么进行依赖注入的.我们一起解开它神秘的面纱. 当我们在宿主中调用依赖注入后build一下我们发现生成了一些class 我们先从头开始分析也就是宿主跟依赖之间的桥梁Component// // Source code recreated from a .class file by IntelliJ
dagger2的生成源码简单分析
闪电人
11-27 590
dagger2官方GitHub: 点击打开链接 直接上图,自己对dagger2构架的见解: 这里使用的是官方的实例分析的.  并稍微修改了CoffeeApp @Singleton @Component(modules = {DripCoffeeModule.class}) public interface CoffeeApp { void inject(App co
Dagger2的使用以及源码分析
ls4568206的博客
04-13 1617
一，简介 Dagger2是Dagger1的分支，由谷歌公司接手开发的，Dagger2中没有再使用反射机制，而是使用派遣方法，自动生成如同自己手写的代码，好处是：第一，谷歌声称提高了13%的效率；第二，代码的调试变得更简单，缺点是缺乏灵活性。 二，接入 在app的gradle文件中添加插件 apply plugin: 'com.neenbedankt.android-apt'
Dagger2源码分析（三）从源码角度分析注解在Dagger2中的使用
m0_64383449的博客
12-22 138
public interface CarComponent { void inject(Car car); } 完成这些之后我们需要Build下项目，让Dagger2帮我们生成相关的Java类。接着我们就可以在Car的构造函数中调用Dagger2生成的DaggerCarComponent来实现注入（这其实在前面Car类的代码中已经有了体现） public class Car { /** @Inject：@Inject有两个作用，一是用来标记需要依赖的变量，以此告诉Dagger2为它提供依赖 */ @Inj
Dagger2 简单源码理解
yyo201的博客
08-01 376
1.其他不说只看代码流程 @ActivityScoped @Component(modules = HomePageModule.class, dependencies = ApplicationComponent.class) public interface HomePageComponent { void inject(MainActivity mainActivity); }...
dagger2依赖分析的代码
06-03
dagger2依赖分析的代码
Dagger2源码
喂_balabala
10-15 462
dagger2的GitHub地址 优秀的小白入门博客 大神的dagger2详解博客 只有Inject的模式 activity（Inject成员变量，告诉dagger拿到对象之后赋值给它） @Inject lateinit var person: Person override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(...
【Spring源码解析】-- Java注解知识回顾（一）
小虎的博客
09-05 251
前言 在学习spring注解驱动开发之前，我们先来回顾一下Java的注解相关的知识。 一、注解的定义 直接看代码： /*自定义注解@Book*/ @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE}) @Documented public @interface Book { String name() default...
Android 神兵利器Dagger2使用详解（四）Scope注解的使用及源码分析
却把清梅嗅的博客
06-18 5036
前言在我的上一篇文章Android 神兵利器Dagger2使用详解（三）进阶篇，不可自拔爱上Dagger2 中，我们以简单的案例对Dagger2依赖注入库在实际开发中的使用方法进行了学习。本文内容： 1.@Singleton 全局单例 注解的使用 2.自定义@Scope 局部单例 注解的使用 3.通过 源码分析 @Singleton和@Scope注解是 如何实现单例 的。 一
Dagger2使用方法及源码解析（一）
小王的学习blog
12-11 339
Dagger2使用方法及源码解析 1.Dagger2简介 2.Dagger2项目依赖 3.Dagger2基础使用方法 4.Dagger2基础源码分析 . . . 1.Dagger2简介 ： Dagger是一种对Java和Android的静态的，编译时依赖注入(Dependency Injection)框架。它主要用来解决很多由于大量使用反射reflection而带来的开发和性能问题。总而言之，Da...
Dagger2详解-从代码分析其原理
始于迷茫终于更高水平的迷茫
11-29 1062
Dagger2基本概念请移步官方文档,或者我的翻译。架构方面请关注GitHub（MVP+Retrofit+Dagger2+Okhttp）及我的文章Android UI框架快速搭建实践Dagger2是Dagger1的分支，由谷歌公司接手开发，目前的版本是2.0。Dagger2解决问题的基本思想是：利用生成和写的代码混合达到看似所有的产生和提供依赖的代码都是手写的样子。如果我们将Dagger2和1比较，
Dagger2进阶-编译生成源码解读
木木baby的博客
04-06 751
前言 Dagger2的介绍和配置 Dagger2基础的使用 Dagger2进阶-编译生成源码解读 Dagger2进阶-范围的控制（Scope和Singleton） Dagger2进阶-Scope的源码探究 项目源码传送门​​​​​​​ 根据前面两...
Dagger2解析（实例+源码）
weixin_34205076的博客
08-21 224
Dagger is a fully static, compile-time dependency injection framework for both Java and Android. It is an adaptation of an earlier versioncreated by Square and now maintained by Google. Dagger aims to...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值