Dagger 2 : Component.Builder注解有什么用？

最新推荐文章于 2024-08-26 16:55:04 发布
最新推荐文章于 2024-08-26 16:55:04 发布
阅读量2.2k 收藏 6
点赞数
文章标签： 移动开发 json java
原文链接：https://juejin.im/post/5a4cf2b2f265da430d586ace
版权

Dagger 2 : Component.Builder 这篇博客是系列博客Dagger 2 Android : Defeat the Dahaka的其中一部分。如果你想了解更多有关 Dahaka 的内容，可以去查看其它博客，它们教我们如何去打败 Dahaka 以及说明了写这些博客的原因。

这里说明下 Dahaka 是个什么鬼。达哈卡（Dahaka）是游戏《波斯王子：武者之心》中的一个怪物（在这个系列博客里面指的是各个对象之间的依赖关系），同时也是隐藏结局里的最终BOSS。反正两者都很让人头疼。里面还有个重要的道具--时之匕首，其实也有暗指 Dagger 的意思,看来原作者是这游戏的忠实粉，不过她的印式英语真是很难听懂（后面有YouTube的视频）。

我们从一个简单的例子开始。 定义一个 AppComponent 代码如下：

@Singleton
@Component(modules = {AppModule.class})
public interface AppComponent {

  void inject(MainActivity mainActivity);
  SharedPreferences getSharedPrefs();
}
复制代码

AppModule 的代码：

@Module
public class AppModule {

   Application application;

   public AppModule(Application application) {
      this.application = application;
   }

   @Provides
   Application providesApplication() {
      return application;
   }
   @Provides
   @Singleton
   public SharedPreferences providePreferences() {
       return application.getSharedPreferences(DATA_STORE,
                             Context.MODE_PRIVATE);
   }

}
复制代码

可以在我们的App类中的onCreate实例化 Component：

@Override
 public void onCreate() {
     super.onCreate();
     AppComponent appComponent = DaggerAppComponent.builder()
             .appMoudle(new AppMoudle(this))
             .build();
 }
复制代码

下面是 Dagger 自动帮我们生成的 Builder类：

DaggerAppComponent 类

public final class DaggerAppComponent implements AppComponent {

  public static Builder builder() {
    return new Builder();
  }
  ...
  public static final class Builder {
    private AppMoudle appMoudle;

    private Builder() {}

    public AppComponent build() {
      if (appMoudle == null) {
        throw new IllegalStateException(AppMoudle.class.getCanonicalName() + " must be set");
      }
      return new DaggerAppComponent(this);
    }

    public Builder appMoudle(AppMoudle appMoudle) {
      this.appMoudle = Preconditions.checkNotNull(appMoudle);
      return this;
    }
  }
  ...
}
复制代码

其中 Builder 类的 appMoudle 成员变量。它通过appMoudle 方法传递进来的。 在 App 的 OnCreate 方法中：

AppComponent appComponent = DaggerAppComponent.builder()
        .appMoudle(new AppMoudle(this))
        .build();
复制代码

上面的代码都是Daggeer 自动生成的 DaggerAppComponent 类代码，可以在 app/build/generated/source/apt/debug/你的包名/DaggerAppComponent.java 目录下找到

回到本文的重点：@Component.Builder 能干吗？ 它可以让我们自定义上面 Dagger 生成的 Builer 类。 我们先看下 @Component.Builder 的定义。

A builder for a component. Components may have a single nested static abstract class or interface annotated with @Component.Builder. If they do, then the component's generated builder will match the API in the type.--source

让我们在 AppComponent 中使用 @Component.Builder：

@Singleton
@Component(modules = {AppModule.class})
public interface AppComponent {

   void inject(MainActivity mainActivity);
   SharedPreferences getSharedPrefs();
   @Component.Builder
   interface Builder {
        AppComponent build();
        Builder appModule(AppModule appModule);
    }
}
复制代码

通过使用 Component.Builder 来注解接口，Dagger 会自动生成跟上面完全相同的 Builder 类。可以自己去查看生成的 DaggerAppComponent 类。

这样还达不到自定义的目的。如何实现自定义Builder类？ 这时候我们就需要使用到 @BindsInstance 注解了。

什么是 @BindsInstance？ 下面是它的定义:

Marks a method on a component builder or subcomponent builder that allows an instance to be bound to some type within the component.

WHAAT? 这是什么鬼，其实我也不能理解，哈哈。

@BindsInstance methods should be preferred to writing a @Module with constructor arguments and immediately providing those values.--source

这句话大概意思：我们经常通过构造函数来给某些成员变量赋值，在上面的 AppModule 也是通过构造函数来给成员 application 初始化。@BindsInstance 它可以让我们省去写这类构造函数，通过它能够为类的成员变量赋值。

public AppModule(Application application) {
        this.application = application;
}
复制代码

现在我们去掉 AppModule 的构造函数以及 @Provides 注解的 providesApplication 函数：

@Module
 public class AppModule {

     @Provides
     @Singleton
     public SharedPreferences providePreferences(
                                    Application application) {
         return application.getSharedPreferences(
                                    "store", Context.MODE_PRIVATE);
     }
 }
复制代码

这是我们通过 @Component.Builder 自定义的 AppComponent 类：

@Singleton
@Component(modules = {AppModule.class})
public interface AppComponent {
   void inject(MainActivity mainActivity);
   SharedPreferences getSharedPrefs();
   @Component.Builder
   interface Builder {

      AppComponent build();
      @BindsInstance Builder application(Application application);      
  }
}
复制代码

跟前面的代码相比，我们去掉了 Builder appModule(AppModule appModule); 函数，并添加了一行 @BindsInstance Builder application(Application application); 通过它我们就可以为 AppModule 类里面的成员方法提供 application 参数。下面会一步步说明是如何实现的。

首先看下初始化的改变：

初始化 DaggerAppComponent

DaggerAppComponent appComponent = DaggerAppComponent.builder()
           .application(this)
           .build();
复制代码

注意：这里我们少了 appModule(AppModule appModule), 并通过 AppModule 默认构造函数（即无参构造函数）去生成 AppModule 实例（该实例是 Builder 类的成员变量）。

下面是修改后 Dagger 生成 DaggerAppComponent 类的代码：

public final class DaggerAppComponent implements AppComponent {
  ...

  private static final class Builder implements AppComponent.Builder {
    private AppMoudle appMoudle;

    private Application application;

    @Override
    public AppComponent build() {
      if (appMoudle == null) {
        this.appMoudle = new AppMoudle();
      }
      if (application == null) {
        throw new IllegalStateException(Application.class.getCanonicalName() + " must be set");
      }
      return new DaggerAppComponent(this);
    }

    @Override
    public Builder application(Application application) {
      this.application = Preconditions.checkNotNull(application);
      return this;
    }
  }
}
复制代码

这时我们发现Builder 类有两个成员变量了，其中 this.appMoudle = new AppMoudle(); ，所以成员变量 appMoudle 通过默认构造函数生成， 另一个成员变量 application是并通过 @BindsInstance 注解过的方法 public Builder application(Application application) 来初始化的。

注意：前面的Builder类是没有 application 成员变量的，它是 AppMoudle 类的成员变量。

现在 AppMoudle 类没有了 application 成员变量了，那么 AppMoudle 类里面的成员方法 public SharedPreferences providePreferences(Application application) 的 application 参数如何来的？

下面看 Dagger 根据 AppMoudle 自动生成的 *_ProvidePreferencesFactory 类： AppMoudle_ProvidePreferencesFactory 类

public final class AppMoudle_ProvidePreferencesFactory implements Factory<SharedPreferences> {
  private final AppMoudle module;

  private final Provider<Application> applicationProvider;

  public AppMoudle_ProvidePreferencesFactory(
      AppMoudle module, Provider<Application> applicationProvider) {
    assert module != null;
    this.module = module;
    assert applicationProvider != null;
    this.applicationProvider = applicationProvider;
  }

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

  public static Factory<SharedPreferences> create(
      AppMoudle module, Provider<Application> applicationProvider) {
    return new AppMoudle_ProvidePreferencesFactory(module, applicationProvider);
  }
}
复制代码

还有 DaggerAppComponent 类：

private Provider<Application> applicationProvider;

private Provider<SharedPreferences> providePreferencesProvider;

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

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

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

  this.applicationProvider = InstanceFactory.create(builder.application);

  this.providePreferencesProvider =
      DoubleCheck.provider(
          AppMoudle_ProvidePreferencesFactory.create(builder.appMoudle, applicationProvider));
}

@Override
public void inject(MainActivity mainActivity) {
  MembersInjectors.<MainActivity>noOp().injectMembers(mainActivity);
}

@Override
public SharedPreferences getShasredPrefs() {
  return providePreferencesProvider.get();
}
复制代码
  1. 可以发现 application 参数是通过成员 applicationProvider 的 get() 方法拿到的。
  2. applicationProvider 又是通过 create 方法传递进来的。
  3. create 方法是在 DaggerAppComponent 类的 initialize 方法中被调用了。
  4. DaggerAppComponent 类的 applicationProvider 则是通过Builder类的application成员变量生成的（this.applicationProvider = InstanceFactory.create(builder.application);）。
  5. Builder类的application成员变量是通过 @BindsInstance 注解的方法传入的。

然后一切就通了。

总结：
  1. 如果使用 @Component.Builder 和 @BindsInstance 来自定义 Builder 类，那么被@BindsInstance注解方法里面的参数在 Builder 类中都有对应的成员变量。
  2. 可以通过 Builder 类中的成员变量在 Component 中生成对应的 Provider<T> **Provider 成员，通过 **Provider 成员的get()就可以拿到依赖的实例了。
使用场景：
  1. 如果我们的 Moudle 某个被 @Provides 注解的 provide**(xxx obj) 函数使用了某种类型的对象作为参数(比如 application)，而这个参数如果不想通过 Moudle 构造函数传递进来，那么就可以使用 @Component.Builder 来自定义 Builder 类，并通过 @BindsInstance 注解的方法来提供这个参数 obj。
  2. 或者直接给 Component 直接添加一个对象依赖的提供函数。

根据这个总结比如我们添加一个全局的 Gson 对象： 1.AppComponent

void inject(MainActivity mainActivity);

SharedPreferences getShasredPrefs();
Gson getGson();

@Singleton
@Component.Builder
interface Builder{
      AppComponent build();
      @BindsInstance
      Builder application(Application application);
      @BindsInstance
      Builder gson(Gson gson);
复制代码

2.App 类里面：

@Override
  public void onCreate() {
      super.onCreate();
      appComponent = DaggerAppComponent.builder()
              .application(this)
              .gson(new Gson())
              .build();
  }
复制代码

3.然后在我们的MainActivity中:

String json = "{\"name\":\"Pikachu\", \"id\":25}";

@Inject
Gson mgson;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    DaggerLearnApp.getAppComponent().inject(this);
}

@Override
protected void onResume() {
    super.onResume();
    Pokemon pokemon = mgson.fromJson(json, Pokemon.class);
    Log.i(TAG, "pokemon name:" + pokemon.getName());
}
复制代码

通过这种方式可以去掉 @Module 注解 AppMoudle 类里面的 provideGson 方法，同时还去掉了 @Singleton 避免了 Lazy 加载，但是效果却是一样的。

@Module
abstract class ExecutorModule {
@Provides
@Singleton
@Background Executor provideGson() {
    return Executors.newCachedThreadPool(4);
    }
}
复制代码
Subcomponent.Builder

@Subcomponent.Builder 也是类似的，不过它是在 subcomponents 中使用。

视频

weixin_34295316
关注
Dagger2Demo.rar
04-12
Dagger2的核心概念包括模块（Module）、组件（Component）和注解（Annotation）。模块是定义依赖的地方，它通过`@Module`注解标记，其中包含了提供依赖的方法。组件则是依赖关系的接口，通过`@Component`注解定义，...
Dagger2新版注解及源码解析
verymrq的博客
08-30 661
一、序 接：Dagger2.1不是Dagger2 demo地址：https://github.com/mrqatom/DaggerInjection 通过学习，我们知道了新版Dagger的用法，可是作为有追求的骚年，不能仅仅成为API的搬运工，必须要了解一下其中具体的用法以及实现方式。首先我们来看看几个注解的具体作用。 二、@Component.Builder 我们在AppCompone...
【Dagger】Component.Factory与Component.Builder的使用对比
移动端开发干货分享
03-07 1578
Dagger 2.22 起引入了 @Component.Factory 可以取代@Component.Builder的使用，Factory在许多场景的上的使用相对于Builder会更简单。本文用对比的方式介绍@Component.Factory与 @Component.Builder在使用上的区别。 依赖版本 implementation 'com.google.dagger:dagger:...
34 builder与@component区别
最新发布
I_did_it的博客
08-26 304
Component 则⽤于定义完整的⾃定义组件，⽀持状态变量、⽣命周期和插槽功能，提供更丰富的内部功能和使⽤⽅式。4. 调⽤限制：⾃定义构建函数可以在所属组件的build⽅法和其他⾃定义构建函数中调⽤，但不允许在。@Builder 侧重于UI元素的复⽤和抽象，提供轻量级的构建函数，但不⽀持状态变量和⽣命周期。2. 不⽀持状态变量和⽣命周期：⾃定义构建函数不⽀持定义状态变量和⾃定义⽣命周期。1. 轻量级：相⽐于⾃定义组件，⾃定义构建函数更加轻量，实现和调⽤都较为简洁。值参数传递，不⽀持动态改变组件。
学习Dagger2笔记：【4】@Component
Cmd的笔记本
05-17 1289
目标 上一篇说到我们想要dagger自动生成出类似于我们手写的Bridge桥接类，本文就是对实现此功能的@Component做一个简介分析，来看看dagger中怎样使用@Component吧 依赖图 在介绍本篇主角@Component之前，我们先根据已有代码画一个依赖图：（个人认为使用dagger就必须要弄清楚自己的依赖图，无论是画在纸上还是在脑海中，一定要想清楚再编写dagger） 如上图所示...
Android主流三方库源码分析（八、深入理解Dagger2源码）
IT元老的博客
02-28 494
前言 成为一名优秀的Android开发，需要一份完备的知识体系，在这里，让我们一起成长为自己所想的那样~。 上一篇，笔者详细地分析了Android中的依赖注入框架ButterKnife，使用它帮助我们解决了重复编写findViewById和setOnclickListener的繁琐。众所周知，当项目越来越大时，类之间的调用层次会越来越深，并且有些类是Activity/Fragment，有些是单例，...
Dagger 2 完全解析（三）,Component与SubComponent
xiaowu 专栏
06-26 2565
Dagger 2 Component 与 SubComponent Dagger 2 完全解析（一）,基本使用与原理 Dagger 2 完全解析（二）, 进阶使用 Dagger 2 完全解析（三）, Component 与 SubComponent 本系列文章是基于 Google Dagger 2.23.2 版本， Kotlin 1.3.21版本 理解前面两篇文章后，可以使用 Dagge...
详解Kotlin 中使用和配置 Dagger2
08-29
最后，需要新建接口 YouApplicationSub 使用 @Component 注解，继承 AndroidInjector\，内部抽象类使用 @Component.Builder 注解继承 AndroidInjector.Builder\。 ```kotlin @Singleton // 如果有 Module 使用了该...
Dagger2新手入门与使用基础教程
08-27
4. **在View层注入Presenter**：在View类中，同样使用`@Inject`注解创建Presenter的实例，同时需要引入对应的Component，并通过Component的Builder来构建实例。 如果Presenter也需要依赖View，那么可以使用Module：...
DaggerSample:Dagger2的样本
05-14
3. **@Inject** 注解：在类的构造函数、字段或方法上使用此注解，表明这些对象需要由 Dagger2 创建和管理。 4. **@Singleton** 注解：如果一个依赖只需要一个实例在整个应用生命周期内共享，可以使用 `@Singleton` ...
android dagger2官网,Android Dagger2 从零单排(四) Dependencies与SubComponent
weixin_42629815的博客
05-28 197
上一篇我们详细介绍了作用域@Scope的使用，本篇我们来研究Dependencies与SubComponent的用法。在前几篇的例子里，@Component都是跟@Module一一对应的提供依赖，如果一个@Component需要用另一个@Component提供依赖，这种情况该如何处理？比如，在Activity注入的依赖，依赖于Applicaton维护的全局单例对象，可能会第一时间想到，先用全局@C...
Spring boot之SpringApplicationBuilder，@@Configuration注解，@Component注解
weixin_34185364的博客
04-25 2058
SpringApplicationBuilder： 该方法的作用是可以把项目打包成war包 需要配置启动类，pom.xml文件等，具体见：http://blog.csdn.net/linzhiqiang0316/article/details/52601292 @SpringBootApplication public class FavoritesApplication extend...
使用@Builder注解的坑
qq_39277058的博客
06-23 2564
使用@Builder注解的坑
Dagger2 Dependencies与SubComponent 深入
Mr_kings的专栏
08-12 379
依赖引用关系说明 参考链接 位于上层的component是看不到下层的，而下层则可以使用上层的，但不能引用同一层相邻component内的实例。 依赖图例子 @Subcomponent 子组件绑定 绑定子组件中的对象除了可以依赖自身模块中绑定的对象外， 还可以依赖于其父组件或任何祖先组件中绑定的任何对象。 另一方面，绑定在父组件中的对象不能依赖于绑定在子组件中的对象。 绑定在一个子组件中的对象也不能依赖于同级子组件中绑定的对象。 –> 表示依赖 ！–> 表示不依赖 子绑定对象–&gt
Dagger2 @Component 和@SubComponent 区别解惑
Lincoln 的专栏
04-18 1万+
前言当前很多blog和技术网站，很多文章都在讲Dagger2 的使用，一般都是在Application中生成一个AppComponent，然后其他的功能模块的Component依赖于AppComponent，但是有些文章中使用的方式是@Component(modules = PreseterModule.class, dependencies = AppComponent.class)，也有使用@S
Dagger2 彻底了解如何构建依赖关系
热门推荐
wangjianfengnb
07-19 1万+
Dagger2 彻底了解如何构建依赖关系上两篇文章分别介绍了Dagger2的使用方式及其一些细节上的知识补充，如果没有看过的，请传送： Dagger2 这次入门就不用放弃了 Dagger2 使用正确姿势 这两篇文章知识讲解了如何使用Dagger2的方式，知其然不知其所以然，这篇文章就基于上两篇文章的例子来介绍一下Dagger2通过APT生成的代码，深入了解一下。它是如何工作的，如何注入成员变量的。本
“一盘沙拉”带你入门Dagger2（六）之Component依赖
Android_Study_OK的博客
09-05 4795
如果我们有一套做好的煎饼果子（一套齐全的依赖体系，Module、Component），另外一个类需要这套依赖体系的一个对象作为依赖，怎么办，还需要再为这个对象，建立一套新的Module和Component吗 显然是不用的，Component之间是可以依赖的 开始举例子：1. 我们先做一套的依赖体系，这个体系里，依赖的Tomato西红柿Tomato.classpublic class Tomato
Dagger2教程六之Component的组织方法（原）
阿杜的专栏
05-22 7842
为了介绍Dagger2的使用，我们搭建了一个Demo来逐步分析，大家可以在这里下载源码（这个源码与之前的五个小节源码不同）(https://github.com/dushaofeng/DaggerDemo2.git)。         上一节我们介绍了《Dagger2教程五之单例模式》，这一节我们来介绍Component的组织方法。         所谓Component组织方法，也就是我们工
dagger2使用详解
vhawk的专栏
03-03 4105
依赖注入，完美解决了类间解藕的问题。搞了接近一周的dagger，终于明白点了。将心得记录下来，庆祝一下。 首先引入依赖库， 在app的gradle中添加 apply plugin: 'com.neenbedankt.android-apt'／／不加这个，编译不过去 compile 'com.google.dagger:dagger:2.0.1' apt 'com.googl
Kotlin应用Dagger2详解：配置与关键注解全解析
在Kotlin中，这个注解需要与Dagger2框架一起使用才有意义。 2. @Component：这是Dagger2的核心注解，用于定义组件，它包含了应用程序的依赖关系图。 3. @Module：标记一个类为模块，该模块提供了组件所需的服务和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值