Ketergantungan komponen - Gunakan ini saat Anda ingin menjaga dua komponen tetap independen.
Subkomponen - Gunakan ini saat Anda ingin tetap menyatukan dua komponen.
Saya akan menggunakan contoh di bawah ini untuk menjelaskan dependensi dan Subkomponen Komponen . Beberapa poin yang perlu diperhatikan tentang contoh ini adalah:
SomeClassA1
dapat dibuat tanpa ketergantungan. ModuleA
menyediakan dan contoh SomeClassA1
melalui provideSomeClassA1()
metode ini.
SomeClassB1
tidak dapat dibuat tanpa SomeClassA1
. ModuleB
dapat memberikan instance SomeClassB1
hanya jika instance SomeClassA1
dilewatkan sebagai argumen ke provideSomeClassB1()
metode.
@Module
public class ModuleA {
@Provides
public SomeClassA1 provideSomeClassA1() {
return new SomeClassA1();
}
}
@Module
public class ModuleB {
@Provides
public SomeClassB1 provideSomeClassB1(SomeClassA1 someClassA1) {
return new SomeClassB1(someClassA1);
}
}
public class SomeClassA1 {
public SomeClassA1() {}
}
public class SomeClassB1 {
private SomeClassA1 someClassA1;
public SomeClassB1(SomeClassA1 someClassA1) {
this.someClassA1 = someClassA1;
}
}
Belati akan mengurus lewat instance SomeClassA1
sebagai argumen untuk provideSomeClassB1()
metode pada ModuleB
setiap kali Komponen / Subkomponen menyatakan mendeklarasikan ModuleB
diinisialisasi. Kita perlu menginstruksikan Belati bagaimana memenuhi ketergantungan. Ini dapat dilakukan dengan menggunakan ketergantungan Komponen atau Subkomponen .
Ketergantungan komponen
Perhatikan poin-poin berikut dalam contoh ketergantungan Komponen di bawah ini:
ComponentB
harus mendefinisikan ketergantungan melalui dependencies
metode pada @Component
anotasi.
ComponentA
tidak perlu mendeklarasikan ModuleB
. Ini menjaga dua komponen independen.
public class ComponentDependency {
@Component(modules = ModuleA.class)
public interface ComponentA {
SomeClassA1 someClassA1();
}
@Component(modules = ModuleB.class, dependencies = ComponentA.class)
public interface ComponentB {
SomeClassB1 someClassB1();
}
public static void main(String[] args) {
ModuleA moduleA = new ModuleA();
ComponentA componentA = DaggerComponentDependency_ComponentA.builder()
.moduleA(moduleA)
.build();
ModuleB moduleB = new ModuleB();
ComponentB componentB = DaggerComponentDependency_ComponentB.builder()
.moduleB(moduleB)
.componentA(componentA)
.build();
}
}
Subkomponen
Perhatikan poin-poin berikut dalam contoh SubComponent:
- Karena
ComponentB
belum mendefinisikan ketergantungan ModuleA
, ia tidak dapat hidup mandiri. Itu menjadi tergantung pada komponen yang akan menyediakan ModuleA
. Karenanya ia memiliki @Subcomponent
anotasi.
ComponentA
telah dideklarasikan ModuleB
melalui metode antarmuka componentB()
. Ini membuat kedua komponen tersebut berpasangan. Bahkan, ComponentB
hanya dapat diinisialisasi melalui ComponentA
.
public class SubComponent {
@Component(modules = ModuleA.class)
public interface ComponentA {
ComponentB componentB(ModuleB moduleB);
}
@Subcomponent(modules = ModuleB.class)
public interface ComponentB {
SomeClassB1 someClassB1();
}
public static void main(String[] args) {
ModuleA moduleA = new ModuleA();
ComponentA componentA = DaggerSubComponent_ComponentA.builder()
.moduleA(moduleA)
.build();
ModuleB moduleB = new ModuleB();
ComponentB componentB = componentA.componentB(moduleB);
}
}
SomeClassB1
Tergantung padaSomeClassA1
.ComponentA
harus secara eksplisit menentukan ketergantungan." ==> Sudahkah Anda bermaksud "ComponentB
harus secara eksplisit mendefinisikan ketergantungan"?SomeClassB1
tergantung padaSomeClassA1
. TidakComponentA
perlu mendefinisikan ketergantungan secara eksplisit." Anda berarti "ComponentB
tidak perlu mendefinisikan ketergantungan secara eksplisit."Menurut dokumentasi :
Component Dependency
memberi Anda akses hanya ke bindings yang diekspos sebagai metode penyediaan melalui dependensi komponen, yaitu Anda memiliki akses ke hanya tipe yang dideklarasikan di indukComponent
.SubComponent
memberi Anda akses ke seluruh grafik yang mengikat dari induknya ketika dideklarasikan, yaitu Anda memiliki akses ke semua objek yang dideklarasikan dalamModule
s.Mari mengatakan, Anda memiliki
ApplicationComponent
yang berisi semuaAndroid
hal yang terkait (LocationService
,Resources
,SharedPreference
, dll). Anda juga ingin memilikiDataComponent
tempat Anda mengelola hal-hal untuk kegigihan bersamaWebService
untuk berurusan dengan API. Satu-satunya kekurangan AndaDataComponent
adalahApplication Context
yang tinggalApplicationComponent
. Cara paling sederhana untuk mendapatkanContext
dariDataComponent
akan menjadi ketergantunganApplicationComponent
. Anda harus memastikan bahwa Anda telahContext
mendeklarasikan secara eksplisitApplicationComponent
karena Anda hanya memiliki akses ke hal-hal yang dinyatakan. Dalam hal ini, tidak ada pekerjaan manual, yang berarti Anda tidak perlu menentukanSubmodules
dalam indukComponent
dan secara eksplisit menambahkan submodule Anda ke modul induk seperti:Sekarang pertimbangkan kasus di mana Anda ingin menyuntikkan
WebService
dariDataComponent
danLocationService
dariApplicationComponent
AndaFragment
yang mengikat menggunakan@Submodule
plus
fitur di atas. Yang keren di sini adalah bahwa komponen yang Anda ikat (ApplicationComponent
) tidak perlu dibukaWebService
atauLocationService
karena Anda memiliki akses ke seluruh grafik segera.sumber
@Submodule
. Apakah ini salah ketik?classes
sebagai contoh dan lebih banyak gambar untuk menggambarkan titik yang tepat.Berikut ini contoh kode dengan tangkapan layar untuk lebih memahami Komponen dan Subkomponen:
Komponen:
Subkomponen:
Dan Diagram Pictorial:
Sumber: tautan
sumber
Satu hal lain yang saya tidak sadari sampai sekarang adalah:
@Subcomponent
instance memiliki tepat satu komponen induk (walaupun komponen yang berbeda dapat membuat instance yang sama@Subcomponent
dan menjadi induk instance itu)@Component
mungkin memiliki nol, satu, atau banyak komponen "induk" yang dideklarasikan melalui dependensi komponensumber