Dagger & Konlin

dagger 部分,参考

https://google.github.io/dagger/users-guide.html


总结下


声明依赖

方法一 在构造函数上加上 @Inject

class Thermosiphon implements Pump {
  private final Heater heater;

  @Inject
  Thermosiphon(Heater heater) {
    this.heater = heater;
  }

  ...
}

方法二 使用@Module 和 @Provide

@Module
class DripCoffeeModule {
  @Provides static Pump providePump(Thermosiphon pump) {
    return pump;
  }
}


两者的异同

1. 被标注的类作为依赖放入 object graph

2. @Inject 是全局依赖

    @Provider 依赖仅属于该 module

3. 接口没有构造函数,无法添加 @Inject

    第三方类无法修改,无法添加 @Inject

4. 所需参数会去 component 的 object graph 中寻找


Component

@Component(modules = DripCoffeeModule.class)
interface CoffeeShop {
  CoffeeMaker maker();
}
CoffeeShop coffeeShop = DaggerCoffeeShop.create();
coffeeShop.maker().brew();

component 负责注入依赖。

CoffeeShop 的 object graph 由两部分组成:全局依赖(@Inject)和 DripCoffeeModule 提供的依赖。


注入依赖的方式

1. @Inject @Provider 标注的参数会被自动注入

2. Provision-methods

像 CoffeeMaker maker() 这样,无参函数。

会去根据返回类型,去 object graph 中寻找并实例化,这是手动注入。(很少用)

3. Members-injection methods

有参函数,会为该参数的注入依赖。

这也是最常用的方法,方法名无所谓。

https://google.github.io/dagger/api/latest/dagger/Component.html#provision-methods


SubComponent

可以尝试整个应用只用一个注入器,但更好的实践是越小越好。

分散注入器职能的方式有两种: Component dependencies 和 SubComponent。

前者需要在 component 中写 provision methods 来暴露作为组件依赖的类(类似手动注入,很少用)


声明 SubComponent

声明的方式有两种,选择简单的那种(以下kotlin代码)

@Module
class MovieModule{
    @Provides
    fun movieApi(retrofit: Retrofit): MovieApi = retrofit.create(MovieApi::class.java)

    @Provides
    fun movieRepository(movieApi: MovieApi): MovieRepository = MovieRepositoryImpl(movieApi)
}
@Subcomponent(modules = arrayOf(MovieModule::class))
interface MovieComponent {
}

@Component(modules = arrayOf(AppModule::class))
interface AppComponent {
    fun getMovieComponent(): MovieComponent
}
只需要两步

1. 用 @SubComponent 替代 @Component。

2. 在 parent component 中声明  provision methods 暴露  sub component

如果 sub component 依赖的 module 不需要外部参数, module 参数都可以省略(会自动生成)。

object ComponentsHolder {

    private val appComponent: AppComponent by lazy { DaggerAppComponent.create() }

    val movieComponent: MovieComponent by lazy { appComponent.getMovieComponent() }

}
贴下生成的代码

    public AppComponent build() {
      if (appModule == null) {
        this.appModule = new AppModule();
      }
      return new DaggerAppComponent(this);
    }
    private MovieComponentImpl() {
      this.movieModule = new MovieModule();
      initialize();
    }


scope

scope 的作用之一是实现单列,会改变生成代码

    @Singleton
    @Provides
    fun okHttpClient(): OkHttpClient = OkHttpClient.Builder()
            .connectTimeout(60, TimeUnit.SECONDS)
            .readTimeout(60, TimeUnit.SECONDS)
            .build()

    this.okHttpClientProvider =
        DoubleCheck.provider(AppModule_OkHttpClientFactory.create(builder.appModule));

public final class AppModule_OkHttpClientFactory implements Factory<OkHttpClient> {
  private final AppModule module;

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

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

  public static Factory<OkHttpClient> create(AppModule module) {
    return new AppModule_OkHttpClientFactory(module);
  }
}
实现单列的原理是 DoubleCheck。


component 可以用 scope 标注,遵循两个原则

1. component 只能注入无 scope 或者相同 scope 的依赖。

2. 不同 component 不能使用相同的 scope。


scope 划分了另一种归属性质,比 module 细度更高,直接作用于依赖本身。

(实际上 sub component 能够注入不同 scope 的依赖,通过 parent component )

@Scope
@MustBeDocumented
@kotlin.annotation.Retention(AnnotationRetention.RUNTIME)
annotation class App
假设 sub com install sub module,sub module 提供三种依赖 @Sub @Other 无Scope

app com install app module, sub com 是 app com 的 subcompent

则 sub com 可注入依赖为: sub module 中 @Sub  无Scope, app com 可注入的依赖,全局依赖中 @Sub 无Scope。


Qualifiers

有时候会需要多个单列,retrofit 不提供修改 baseUrl 的方法。

如果需要连接多个服务器,就要持有多个 retrofit 单列。

@Module
class AppModule {

    @Named("t")
    @App
    @Provides
    fun okHttpClient(): OkHttpClient = OkHttpClient.Builder()
            .connectTimeout(60, TimeUnit.SECONDS)
            .readTimeout(60, TimeUnit.SECONDS)
            .build()

    private val baseUrl = "http://v.juhe.cn/movie/"

    @App
    @Provides
    fun retrofit(@Named("s") client: OkHttpClient): Retrofit = Retrofit.Builder()
            .baseUrl(baseUrl)
            .client(client)
            .addConverterFactory(GsonConverterFactory.create(Gson()))
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
            .build()

}
这样运行会报错,因为只提供了名为 t 的 okHttpClient 单列。


Dagger Android

https://google.github.io/dagger/android.html






评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值