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

最新推荐文章于 2024-07-16 22:51:23 发布
最新推荐文章于 2024-07-16 22:51:23 发布
阅读量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
关注
学习Dagger2笔记：【4】@Component
Cmd的笔记本
05-17 1260
目标 上一篇说到我们想要dagger自动生成出类似于我们手写的Bridge桥接类，本文就是对实现此功能的@Component做一个简介分析，来看看dagger中怎样使用@Component吧 依赖图 在介绍本篇主角@Component之前，我们先根据已有代码画一个依赖图：（个人认为使用dagger就必须要弄清楚自己的依赖图，无论是画在纸上还是在脑海中，一定要想清楚再编写dagger） 如上图所示...
dagger2之android源码解析（dagger-compiler你在哪）
foshengtang的博客
09-07 853
首先照常理来一份参考地址：Android - Dagger2使用详解，这里说的还行，但是并没有涉及到源码部分，如果没有像我这种纠结症的完全可以参考去使用。dagger这个我用的并不多（咱实话实话了，之前用了下，但是感觉好麻烦，我认为项目中没必要用到它），因为我现在在细品AAC里面的demo，GithubBrowserSample中有使用到，第一为了学习，第二别人家碗里的肉肯定都是香的，所以就有了这么一篇根据demo中案例捋一遍源码。 ...
android 组件化dagger2,从零开始Android组件化改造（五） - Dagger2的使用
weixin_29041195的博客
05-25 319
Dagger2算是本框架中学习成本最高的第三方组件，很多细节也确实很难在本文章中一言尽之，本文只是单纯整理本人在组件化开发中对于Dagger2的理解与使用。Dagger2Dagger2是一个依赖注入框架，什么是依赖注入？简单通俗的说，将类的初始化通过注入的方式去实现从而降低类与类之间的耦合度。常用注释以及含义：注解含义@Inject注入@Binds指定接口的实现@Provides提供实例@Name...
Spring boot之SpringApplicationBuilder，@@Configuration注解，@Component注解
weixin_34185364的博客
04-25 2016
SpringApplicationBuilder： 该方法的作用是可以把项目打包成war包 需要配置启动类，pom.xml文件等，具体见：http://blog.csdn.net/linzhiqiang0316/article/details/52601292 @SpringBootApplication public class FavoritesApplication extend...
这可能是本年度最好用的 Dagger 使用教程 四（使用 @Builder 和 @Factory 创建依赖注入器）
最新发布
李斯维的博客空间
07-16 449
本文接着前面三篇文章讲解 Dagger 中的注入器的两种创建方式 @Factory 和 @Builder，其也对应了工厂模式和建造者模式。
Dagger2新版注解及源码解析
verymrq的博客
08-30 642
一、序 接：Dagger2.1不是Dagger2 demo地址：https://github.com/mrqatom/DaggerInjection 通过学习，我们知道了新版Dagger的用法，可是作为有追求的骚年，不能仅仅成为API的搬运工，必须要了解一下其中具体的用法以及实现方式。首先我们来看看几个注解的具体作用。 二、@Component.Builder 我们在AppCompone...
Android主流三方库源码分析（八、深入理解Dagger2源码）
IT元老的博客
02-28 477
前言 成为一名优秀的Android开发，需要一份完备的知识体系，在这里，让我们一起成长为自己所想的那样~。 上一篇，笔者详细地分析了Android中的依赖注入框架ButterKnife，使用它帮助我们解决了重复编写findViewById和setOnclickListener的繁琐。众所周知，当项目越来越大时，类之间的调用层次会越来越深，并且有些类是Activity/Fragment，有些是单例，...
8.基于Dagger2.38.1的hilt源码-RootProcessor和ComponentTreeDepsProcessor
foshengtang的博客
04-24 1166
RootProcessor处理@HiltAndroidApp、@HiltAndroidTest和@InternalTestRoot三种注解，以及该注解关联的注解。生成一个@ComponentTreeDeps修饰的节点，该节点再由ComponentTreeDepsProcessor类处理。
依赖注入框架Dagger2—2.各注解用法
点滴积累
10-27 847
[@TOC] 0.前言 接上一篇入门文章，这篇主要是各属性实战。 1.Dagger2各属性了解 必要属性 @inject//注入，@Component，@Moudle，@Provider 为什么说这个几个是必要属性，因为只要想用dagger2这几个属性是绕不开的。 高级属性 @Named @Qualifier @Scope @Singleton； 这四个属性实际上可以分文俩组，@Named底层实...
dagger-builder:一个方便的库，增加了在不直接使用生成的代码的情况下执行 dagger 2 注入的方法
06-07
**正文** Dagger 2 是 Google 推出的一款强大的依赖注入框架，用于简化 Android 和 Java 应用程序的组件管理。...如果你的项目中使用了 Dagger 2，那么考虑引入 "dagger-builder" 可能会是一个不错的优化选择。
Dagger 2 完全解析（三）,Component与SubComponent
xiaowu 专栏
06-26 2502
Dagger 2 Component 与 SubComponent Dagger 2 完全解析（一）,基本使用与原理 Dagger 2 完全解析（二）, 进阶使用 Dagger 2 完全解析（三）, Component 与 SubComponent 本系列文章是基于 Google Dagger 2.23.2 版本， Kotlin 1.3.21版本 理解前面两篇文章后，可以使用 Dagge...
android dagger2官网,Android Dagger2 从零单排(四) Dependencies与SubComponent
weixin_42629815的博客
05-28 178
上一篇我们详细介绍了作用域@Scope的使用，本篇我们来研究Dependencies与SubComponent的用法。在前几篇的例子里，@Component都是跟@Module一一对应的提供依赖，如果一个@Component需要用另一个@Component提供依赖，这种情况该如何处理？比如，在Activity注入的依赖，依赖于Applicaton维护的全局单例对象，可能会第一时间想到，先用全局@C...
Dagger2 @Component 和@SubComponent 区别解惑
热门推荐
Lincoln 的专栏
04-18 1万+
前言当前很多blog和技术网站，很多文章都在讲Dagger2 的使用，一般都是在Application中生成一个AppComponent，然后其他的功能模块的Component依赖于AppComponent，但是有些文章中使用的方式是@Component(modules = PreseterModule.class, dependencies = AppComponent.class)，也有使用@S
dagger2使用详解
vhawk的专栏
03-03 4092
依赖注入，完美解决了类间解藕的问题。搞了接近一周的dagger，终于明白点了。将心得记录下来，庆祝一下。 首先引入依赖库， 在app的gradle中添加 apply plugin: 'com.neenbedankt.android-apt'／／不加这个，编译不过去 compile 'com.google.dagger:dagger:2.0.1' apt 'com.googl
Dagger是什么和我们怎么通过使用它获得收获
AexLinda的专栏
03-22 3303
原文：https://github.com/konmik/konmik.github.io/wiki/Snorkeling-with-Dagger-2Dagger是什么Dagger是为对象实例提供选择的Java库。你可以使用注解@Inject来标注你的构造函数，替代在构造函数中传递大量参数，并且所有需要的对象被创建和自动分配。@Inject SharedPreferences pref;这会通过一个
Dagger2 使用详解
u013163564的专栏
07-07 5951
dagger2是解决Android或java中依赖注入的一个类库（DI类库）。
[译] 全新 Android 注入器：Dagger 2（一）
weixin_34054866的博客
12-20 151
原文地址：New Android Injector with Dagger 2—part 1 原文作者：Mert Şimşek 译文出自：掘金翻译计划 本文永久链接：github.com/xitu/gold-m… 译者：MummyDing 校对者：LeviDing 全新 Android 注入器：Dagger 2（一） 全新 Android 注入器：Dagger 2（二） 全新 Andro...
Dagger 2 系列（二） -- 基础篇：@Inject、@Component
Strange_Monkey的博客
05-31 2985
该系列博客的最终目标： 搭建 MVP + Dagger2 框架 该系列博客包含以下几篇内容： Dagger 2 系列（一） – 前奏篇：基本概念介绍 Dagger 2 系列（二） – 基础篇：基本功能的实现 Dagger 2 系列（三） – 基础篇：@Module 和@Provides 在这篇文章中你会看到什么： 1. @Inject 是什么 2. @Component 是...
Kotlin应用Dagger2详解：配置与关键注解全解析
在Kotlin中，这个注解需要与Dagger2框架一起使用才有意义。 2. @Component：这是Dagger2的核心注解，用于定义组件，它包含了应用程序的依赖关系图。 3. @Module：标记一个类为模块，该模块提供了组件所需的服务和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值