Dagger2系列：
Dagger版本：2.11
1. Module里添加subcomponents
上篇的結(jié)尾說到Module內(nèi)可以再包含Component，需要注意的是，這個(gè)Component和之前的Component組件是不一樣的
- 需要用@SubComponent注解
- SubComponent里面還需要再放一個(gè)Builder, interface或者abstract class都可以，標(biāo)注@Subcomponent.Builder
- Builder里必須要有一個(gè)無參數(shù)的返回SubComponent本身的方法
- 如果SubComponent依賴其他Module，必須提供參數(shù)為這個(gè)Module，返回類型為Builder的方法(名字都叫Builder了，也就是建造者模式了，應(yīng)該知道這是要干嘛了吧)
- Builder里的方法的方法名可隨意，不過還是按規(guī)范走吧
先看看SubComponent注解類里的東西吧
/**
* A subcomponent that inherits the bindings from a parent {@link Component} or
* {@link Subcomponent}. The details of how to associate a subcomponent with a parent are described
* in the documentation for {@link Component}.
*
* @author Gregory Kick
* @since 2.0
*/
@Retention(RUNTIME) // Allows runtimes to have specialized behavior interoperating with Dagger.
@Target(TYPE)
@Documented
public @interface Subcomponent {
/**
* A list of classes annotated with {@link Module} whose bindings are used to generate the
* subcomponent implementation. Note that through the use of {@link Module#includes} the full set
* of modules used to implement the subcomponent may include more modules that just those listed
* here.
*/
Class<?>[] modules() default {};
/**
* A builder for a subcomponent. This follows all the rules of {@link Component.Builder}, except
* it must appear in classes annotated with {@link Subcomponent} instead of {@code Component}.
* Components can have methods that return a {@link Subcomponent.Builder}-annotated type,
* allowing the user to set modules on the subcomponent using their defined API.
*/
@Target(TYPE)
@Documented
@interface Builder {}
}
大致意思是說子組件是繼承父組件的，至于如何關(guān)聯(lián)，在Component的文檔里有說明
Subcomponents
The simplest way to relate two components is by declaring a Subcomponent. A subcomponent behaves exactly like a component, but has its implementation generated within a parent component or subcomponent. That relationship allows the subcomponent implementation to inherit the entire binding graph from its parent when it is declared. For that reason, a subcomponent isn't evaluated for completeness until it is associated with a parent.
Subcomponents are declared by listing the class in the Module.subcomponents() attribute of one of the parent component's modules. This binds the Subcomponent.Builder within the parent component.
Subcomponents may also be declared via a factory method on a parent component or subcomponent. The method may have any name, but must return the subcomponent. The factory method's parameters may be any number of the subcomponent's modules, but must at least include those without visible no-arg constructors. The following is an example of a factory method that creates a request-scoped subcomponent from a singleton-scoped parent:@Singleton @Component interface ApplicationComponent { // component methods... RequestComponent newRequestComponent(RequestModule requestModule); }Component dependencies
While subcomponents are the simplest way to compose subgraphs of bindings, subcomponents are tightly coupled with the parents; they may use any binding defined by their ancestor component and subcomponents. As an alternative, components can use bindings only from another component interface by declaring a component dependency. When a type is used as a component dependency, each provision method on the dependency is bound as a provider. Note that only the bindings exposed as provision methods are available through component dependencies.
這里說下我的理解，英文太差很難看懂，如果有錯(cuò)誤請各位大佬指正
-
子組件是完全繼承父組件(一般的Component或者SubComponent都可以)的依賴關(guān)系
例如，子組件聲明了給Target進(jìn)行注入的方法，而Target有兩個(gè)依賴MemberA和MemberB，子組件只注入了能夠提供MemberB的模塊，而父組件中注入了能提供MemberA的模塊，這時(shí)子組件就可以通過父組件的模塊實(shí)現(xiàn)Target中MemberA的注入 -
子組件的實(shí)例化必須要在父組件實(shí)例化完成之后
子組件本來就配置在父組件中的模塊里了，自然只能等父組件實(shí)例化后才能獲得 - 父組件需要聲明提供子組件Builder的方法
示例：
class MemberA
@Module
class MemberAModule {
@Provides
fun provideMemberA(): MemberA = MemberA()
}
class MemberB
@Module
class MemberBModule {
@Provides
fun provideMemberB(): MemberB = MemberB()
}
class Member @Inject constructor(val memberA: MemberA, val memberB: MemberB)
class Target {
@Inject
lateinit var member: Member
}
@Subcomponent(modules = arrayOf(MemberBModule::class))
interface SubMemberComponent {
@Subcomponent.Builder
interface Builder {
// @Subcomponent里的modules寫了什么模塊，就得聲明相對應(yīng)的Builder模式的set方法
fun applyMemberBModule(module: MemberBModule): Builder
// 必須要有一個(gè)無參的，返回SubMemberComponent 本身的方法
fun build(): SubMemberComponent
}
// 子組件對外提供的方法，要是一個(gè)都不寫，還要子組件干嘛
fun inject(target: Target)
}
這個(gè)SubComponent就是Module需要添加的子組件
// 添加了子組件后，這里聲明的Provider或者是依賴這個(gè)模塊的組件中的其他模塊提供的Provider，在子組件中都能繼承下來
@Module(includes = arrayOf(MemberAModule::class), subcomponents = arrayOf(SubMemberComponent::class))
class SubModule
// SubModule里的MemberAModule不寫，寫在這里也是可以的，dagger都能找到這個(gè)MemberA的提供者
@Component(modules = arrayOf(SubModule::class/*, MemberAModule::class*/))
interface TargetComponent {
// 對外提供子組件的Builder
fun getSubComponentBuilder(): SubMemberComponent.Builder
}
接下來看生成的代碼
大體和之前差不多：
-
Member_Factory:Member的工廠，Member依賴MemberA和MemberB，那么這個(gè)工廠就依賴MemberAModule_ProvideMemberAFactory和MemberBModule_ProvideMemberBFactory -
MemberAModule_ProvideMemberAFactory:根據(jù)在MemberAModule聲明過提供MemberA的方法生成的工廠 -
MemberBModule_ProvideMemberBFactory:同樣根據(jù)在MemberBModule聲明過提供MemberB的方法生成的工廠 -
Target_MembersInjector：沒說好說的了，Provider齊全的注入器
重點(diǎn)看DaggerTargetComponent，代碼太多，不截圖了
public final class DaggerTargetComponent implements TargetComponent {
private Provider<SubMemberComponent.Builder> subMemberComponentBuilderProvider;
private Provider<MemberA> provideMemberAProvider;
// 省略。。。
@Override
public SubMemberComponent.Builder getSubComponentBuilder() {
return subMemberComponentBuilderProvider.get();
}
private final class SubMemberComponentBuilder implements SubMemberComponent.Builder {
private MemberBModule memberBModule;
// 省略
}
private final class SubMemberComponentImpl implements SubMemberComponent {
private Provider<MemberB> provideMemberBProvider;
private Provider<Member> memberProvider;
private MembersInjector<Target> targetMembersInjector;
private SubMemberComponentImpl(SubMemberComponentBuilder builder) {
assert builder != null;
initialize(builder);
}
@SuppressWarnings("unchecked")
private void initialize(final SubMemberComponentBuilder builder) {
this.provideMemberBProvider =
MemberBModule_ProvideMemberBFactory.create(builder.memberBModule);
this.memberProvider =
Member_Factory.create(
DaggerTargetComponent.this.provideMemberAProvider, provideMemberBProvider);
this.targetMembersInjector = Target_MembersInjector.create(memberProvider);
}
@Override
public void inject(Target target) {
targetMembersInjector.injectMembers(target);
}
}
}
可以看到，DaggerTargetComponent里面多了兩個(gè)私有內(nèi)部類，SubMemberComponentBuilder就不說了，作用只是傳入provideMemberBProvider而已的，這里主要看SubMemberComponentImpl的initialize方法中的
this.memberProvider =
Member_Factory.create(
DaggerTargetComponent.this.provideMemberAProvider, provideMemberBProvider);
Member_Factory.create()除了傳入了SubMemberComponent自身的provideMemberBProvider外，還傳入了屬于DaggerTargetComponent的provideMemberAProvider，這就再次印證了前面的三點(diǎn):
-
SubMemberComponent是繼承了父組件的依賴關(guān)系了(子組件的實(shí)現(xiàn)是父組件實(shí)現(xiàn)的內(nèi)部類，可以直接調(diào)用父組件的Provider來作為自身的依賴關(guān)系) -
SubMemberComponent只能依存于父組件DaggerTargetComponent(內(nèi)部類) -
SubMemberComponent需要聲明提供子組件Builder的方法getSubComponentBuilder(沒有在內(nèi)部實(shí)例化子組件，需要外部提供MemberBModule)
2.不在module中注入subComponent，直接寫SubComponent
之前一直把子組件放在Module的subComponents里，而父組件里只能聲明返回子組件Builder的方法，但我搜索過一堆子組件的寫法，它們都是直接在父組件中聲明返回子組件本身的，@Component的注釋文檔好像也提到過（跪舔英文T-T），只在官方的介紹頁面看到過這種寫B(tài)uidler的寫法，那么接下來按這種不用聲明Builder的方式再來一次
修改一下TargetComponent和SubMemberComponent
@Subcomponent(modules = arrayOf(MemberBModule::class))
interface SubMemberComponent {
fun inject(target: Target)
}
@Component(modules = arrayOf(MemberAModule::class/*, MemberBModule::class*/))
interface TargetComponent {
fun getSubMemberComponent(module: MemberBModule): SubMemberComponent
}
編譯，生成的代碼
呃。。。完全沒區(qū)別？再看看DaggerTargetComponent
構(gòu)造函數(shù)變了，傳入的參數(shù)不是Builder了，而直接是MemberBModule。。。
呃。。。，總得來說，除此之外基本沒區(qū)別，而且這種方式還不用在Subcomponent里寫冗長的Builder代碼，或許是后面版本做出的改進(jìn)？或者是按本篇的例子，在某種情況下TargetComponent里拿不到MemberBModule的類型？？，望知道的大佬指教。
3.總結(jié)：
本篇講的是子組件SubComponent的兩種寫法，如果沒特殊情況下，第二種寫法是更加值得推薦的，省事省代碼
那么使用SubComponent和Component中添加dependencies的區(qū)別是啥呢?
參考步驟 Dagger2 的 @Scope 和 @Subcomponent：
引用的是stackoverflow上的一個(gè)回答
Component Dependencies - Use this when:
// 你想保持兩個(gè)組件之間的獨(dú)立 you want to keep two components independent. // 你想強(qiáng)調(diào)一個(gè)組件是依賴于另一個(gè)組件 you want to explicitly show what dependencies from one component is used by the other.Subcomponents - Use this when:
// 你想讓一個(gè)組件保持高內(nèi)聚(不想直接暴露子組件的實(shí)例化過程) you want to keep two component cohesive. // 你并不在意明確展示出兩個(gè)組件之間的依賴關(guān)系(哪個(gè)組件依賴哪個(gè)組件) you may not care to explicitly show what dependencies from one component is used by the other.
SubComponent的作用
- 繼承擴(kuò)展功能并綁定生命周期
- 封裝
最后是參考Dagger2 @Component 和@SubComponent 區(qū)別解惑:
Component Dependencies方案
優(yōu)勢
1.可以很清晰的看到Component生成時(shí)依賴于另外一個(gè)Component
2.有兩個(gè)獨(dú)立的DaggerXXXXComponent類需注意
Component僅能獲取它依賴的Component中顯式提供的依賴，如果不聲明，則無法使用依賴的Component中的ProviderSubcomponents 方案
優(yōu)勢
1.不需要在父組件顯式提供依賴
2.不需要使用更多的DaggerXXXXComponent對象來創(chuàng)建依賴
需注意
根據(jù)寫法
1.要在父組件中聲明返回子組件Builder的方法
2.要在父組件中聲明返回子組件的方法(有子組件有的，父組件沒有的模塊時(shí)也需要作為參數(shù)聲明)
參考資料
- [谷歌官方的介紹文檔] https://google.github.io/dagger/subcomponents.html
- [步驟 Dagger2 的 @Scope 和 @Subcomponent]
http://www.zhimengzhe.com/Androidkaifa/163191.html - [Dagger2 入門解析] http://www.cnblogs.com/woshimrf/p/hello-dagger.html(http://www.cnblogs.com/woshimrf/p/hello-dagger.html
- [Dagger2 @Component 和@SubComponent 區(qū)別解惑]
http://blog.csdn.net/soslinken/article/details/70231089
