В данной статье рассмотрены особенности применения мульбайндинга, который может помочь решить множество проблем связанных с предоставлением зависимостей.
Для данной статьи необходимы базовые знания по Dagger 2. В примерах использовался Dagger версии 2.11
Dagger 2 позволяет забайндить несколько объектов в коллекцию, даже в тех случаях, когда байндинг этих объектов происходит в разных модулях. Dagger 2 поддерживает Set и Map мультибайндинг.
Set multibindings
Для того чтобы добавить элемент в Set, достаточно добавить аннотацию @IntoSet над @Provides методом в модуле:
@Module
public class ModuleA {
@IntoSet
@Provides
public FileExporter xmlFileExporter(Context context) {
return new XmlFileExporter(context);
}
}
@Module
public class ModuleB {
@IntoSet
@Provides
public FileExporter provideCSVFileExporter(Context context) {
return new CSVFileExporter(context);
}
}Добавим два этих модуля в наш компонент:
@Component(modules = {ModuleA.class, ModuleB.class})
public interface AppComponent {
//inject methods
}Т.к. мы объединили наши два модуля, которые содержат байндинг элементов в сет в один компонент, даггер объединит эти элементы в одну коллекцию:
public class Values {
@Inject
public Values(Set<FileExporter> values) {
//значения в values: [XmlFileExporter, CSVFileExporter]
}
}Мы также можем добавить несколько элементов за один раз, для этого нам надо, чтобы наш @Provide метод имел возвращаемый тип Set и поставить аннотацию @ElementsIntoSet над @Provide методом.
Заменим наш ModuleB:
@Module
public class ModuleB {
@ElementsIntoSet
@Provides
public Set<FileExporter> provideFileExporters(Context context) {
return new HashSet<>(Arrays.asList(new CSVFileExporter(context),
new JSONFileExporter(context)));
}
}Результат:
public class Values {
@Inject
public Values(Set<FileExporter> values) {
//значения в values: [XmlFileExporter, CSVExporter, JSONFileExporter]
}
}Можно предоставлять зависимость через компонент:
@Component(modules = {ModuleA.class, ModuleB.class})
public interface AppComponent {
Set<FileExporter> fileExporters();
}
Set<FileExporter> fileExporters = DaggerAppComponent
.builder()
.context(this)
.build()
.fileExporters();Также мы можем предоставлять коллекции с использованием @Qualifier над @Provides методом, тем самым разделять их.
Заменим еще раз наш ModuleB:
@Module
public class ModuleB {
@ElementsIntoSet
@Provides
@Named("CSV_JSON")
public Set<FileExporter> provideFileExporters(Context context) {
return new HashSet<>(Arrays.asList(new CSVFileExporter(context),
new JSONFileExporter(context)));
}
}
// Без Qualifier
public class Values {
@Inject
public Values(Set<FileExporter> values) {
//значения в values: [XmlFileExporter].
//Здесь мы указали без кваливайра, поэтому
//будут собраны объекты c ModuleA.
}
}
// С Qualifier
public class Values {
@Inject
public Values(@Named("CSV_JSON") Set<FileExporter> values) {
//значения в values: [CSVExporter, JSONFileExporter]
}
}
//Через компонент
@Component(modules = {ModuleA.class, ModuleB.class})
public interface AppComponent {
@Named("CSV_JSON") Set<FileExporter> fileExporters();
}
Dagger 2 предоставляет возможность отложить инициализацию объектов до первого вызова, и эта возможность есть и для коллекций. В арсенале Dagger 2 есть два способа для достижения отложенной инициализации: с использованием интерфейсов Provider<T> и Lazy<T>.
Lazy injections
Для любой зависимости T, вы можете применить Lazy<T>, данный способ позволяет отложить инициализацию до первого вызова Lazy<T>.get(). Если T синглтон, то будет возвращаться всегда один и тот же экземпляр. Если же T unscope, тогда зависимость T будет создана в момент вызова Lazy<T>.get и помещена в кэш внутри Lazy<T> и каждый последующий вызов именно этого Lazy<T>.get(), будет возвращать кэшированное значение.
Пример:
@Module
public class AppModule {
@Singleton
@Provides
public GroupRepository groupRepository(Context context) {
return new GroupRepositoryImpl(context);
}
@Provides
return new UserRepositoryImpl(context);
public UserRepository userRepository(Context context) {
}
}
public class MainActivity extends AppCompatActivity {
@Inject
Lazy<GroupRepository> groupRepositoryInstance1;
@Inject
Lazy<GroupRepository> groupRepositoryInstance2;
@Inject
Lazy<UserRepository> userRepositoryInstance1;
@Inject
Lazy<UserRepository> userRepositoryInstance2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerAppComponent
.builder()
.context(this)
.build()
.inject(this);
//GroupRepository @Singleton scope
GroupRepository groupRepository1 = groupRepositoryInstance1.get();
GroupRepository groupRepository2 = groupRepositoryInstance1.get();
GroupRepository groupRepository3 = groupRepositoryInstance2.get();
//UserRepository unscope
UserRepository userRepository1 = userRepositoryInstance1.get();
UserRepository userRepository2 = userRepositoryInstance1.get();
UserRepository userRepository3 = userRepositoryInstance2.get();
}
}Инстансы groupRepository1, groupRepository2 и groupRepository3 будут равны, т.к. они имет скоуп синглтон.
Инстансы userRepository1 и userRepository2 будут равны, т.к. при первом обращении к userRepositoryInstance1.get() был создан объект и помещен в кэш внутри userRepositoryInstance1, а вот userRepository3 будет иметь другой инстанс, т.к. он имеет другой Lazy и для него был вызван первый раз get().
Provider injections
Provider<T> также позволяет отложить инициализацию объектов, но в отличии от Lazy<T>, значения unscope зависимостей не кэшируется в Provider<T> и возвращают каждый раз новый инстанс. Такой подход может понадобится к примеру когда у нас есть некая фабрика со скопом синглтон и эта фабрика должна предоставлять каждый раз новые объекты, рассмотрим пример:
@Module
public class AppModule {
@Provides
public Holder provideHolder() {
return new Holder();
}
@Provides
@Singleton
public HolderFactory provideHolderFactory(Provider<Holder> holder) {
return new HolderFactoryImpl(holder);
}
}
public class HolderFactoryImpl implements HolderFactory {
private Provider<Holder> holder;
public HolderFactoryImpl(Provider<Holder> holder) {
this.holder = holder;
}
public Holder create() {
return holder.get();
}
}
public class MainActivity extends AppCompatActivity {
@Inject
HolderFactory holderFactory;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerAppComponent
.builder()
.context(this)
.build()
.inject(this);
Holder holder1 = holderFactory.create();
Holder holder2 = holderFactory.create();
}
}Здесь у нас holder1 и holder2 будут иметь разные инстансы, если бы мы использовали бы Lazy<T> вместо Provider<T> у нас бы эти объекты имели бы один инстанс из за кэширования.
Отложенную инициализацию можно применить и к Set:
Lazy<Set<T>> или Provider<Set<T>>, нельзя использовать так: Set<Lazy<T>>.
public class MainActivity extends AppCompatActivity {
@Inject
Lazy<Set<FileExporter>> fileExporters;
//…
// Set<FileExporter> exporters = fileExporters.get();
}Map multibindings
Для того чтобы добавить элемент в Map, необходимо добавить аннотацию @IntoMap и аннотацию ключа (Наследники @MapKey) над @Provides методом в модуле:
@Module
public class ModuleA {
@IntoMap
@Provides
@StringKey("xml")
public FileExporter xmlFileExporter(Context context) {
return new XmlFileExporter(context);
}
}
@Module
public class ModuleB {
@IntoMap
@StringKey("csv")
@Provides
public FileExporter provideCSVFileExporter(Context context) {
return new CSVFileExporter(context);
}
}
@Component(modules = {ModuleA.class, ModuleB.class})
public interface AppComponent {
//inject methods
}Результат:
public class Values {
@Inject
public Values(Map<String, FileExporter> values) {
//значения в values {xml=XmlFileExporter,csv=CSVExporter}
}
}Также как и с Set, мы указали два наших модуля в компоненте, таким образом Dagger объединил наши значения в единую Map. Также можно использовать @Qualifier.
Стандартные типы ключей для Map:
- IntKey
- LongKey
- StringKey
- ClassKey
Стандартные типы ключей дополнительного модуля Dagger-Android:
- ActivityKey
- BroadcastReceiverKey
- ContentProviderKey
- FragmentKey
- ServiceKey
Как выглядит реализация к примеру ActivityKey:
@MapKey
@Target(METHOD)
public @interface ActivityKey {
Class<? extends Activity> value();
}Можно создавать свои типы ключей, как выше описано или к примеру с enum:
public enum Exporters {
XML,
CSV
}
@MapKey
@Target(METHOD)
public @interface ExporterKey {
Exporters value();
}
@Module
public class ModuleA {
@IntoMap
@Provides
@ExporterKey(Exporters.XML)
public FileExporter xmlFileExporter(Context context) {
return new XmlFileExporter(context);
}
}
@Module
public class ModuleB {
@IntoMap
@ExporterKey(Exporters.CSV)
@Provides
public FileExporter provideCSVFileExporter(Context context) {
return new CSVFileExporter(context);
}
}
public class Values {
@Inject
public Values(Map<Exporters, FileExporter> values) {
//значения в values {XML=XmlFileExporter,CSV=CSVExporter}
}
}Как и с Set мы можем применять отложенную инициализацию:
Lazy<Map<K,T>>, Provider<Map<K,T>>.
С Map мы можем использовать отложенную не только инициализацию самой коллекции, но инициализацию отдельного элемента и получать по ключу каждый раз новое значение (Map<K,Provider<T>>):
public class MainActivity extends AppCompatActivity {
@Inject
Map<Exporters, Provider<FileExporter>> exporterMap;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerAppComponent
.builder()
.context(this)
.build();
FileExporter fileExporter1 = exporterMap.get(Exporters.CSV).get();
FileExporter fileExporter2 = exporterMap.get(Exporters.CSV).get();
}
}fileExporter1 и fileExporter2 будут иметь разные инстансы. А элемент Exports.XML даже и не проинициализируется, т.к. мы к нему не обращались.
Мы не можем использовать Map<K, Lazy<T>>.
Чтобы запровайдить пустую коллекцию, нам необходимо добавить аннотацию @Multibinds над абстрактным методом:
@Module
public abstract class AppModule {
@Multibinds
abstract Map<Exporters, FileExporter> exporters();
}Это может понадобиться например когда мы хотим уже использовать эту коллекцию, но модуль с реализациями еще не доступен (не реализован), а когда модуль реализуем и добавим, он объединит значения в общую коллекцию.
Subcomponents и мультибайндинг
Родительскому компоненту доступны коллекции указанные только в модулях родительского компонента, а сабкомпонент “наследует” все коллекции родительского компонента и объединяет их с коллекциями сабкомпонента:
@Module
public class AppModule {
@IntoMap
@Provides
@ExporterKey(Exporters.XML)
public FileExporter xmlFileExporter(Context context) {
return new XmlFileExporter(context);
}
}
@Module
public class ActivityModule {
@IntoMap
@ExporterKey(Exporters.CSV)
@Provides
public FileExporter provideCSVFileExporter(Context context) {
return new CSVFileExporter(context);
}
}
@Singleton
@Component(modules = {AppModule.class})
public interface AppComponent {
ActivitySubComponent provideActivitySubComponent();
//значения в коллекции {xml=XmlFileExporter}
Map<Exporters, FileExporter> exporters();
@Component.Builder
interface Builder {
@BindsInstance
Builder context(Context context);
AppComponent build();
}
}
@ActivityScope
@Subcomponent(modules = {ActivityModule.class})
public interface ActivitySubComponent {
//значения в коллекции {XML=XmlFileExporter,CSV=CSVExporter}
Map<Exporters, FileExporter> exporters();
}
@Binds + multibindings
Dagger 2 позволяет забайндить объекты в коллекцию с использованием абстрактных @Binds методов:
@Module
public abstract class LocationTrackerModule {
@Binds
@IntoSet
public abstract LocationTracker netLocationTracker(NetworkLocationTracker
tracker);
@Binds
@IntoSet
public abstract LocationTracker fileLocationTracker(FileLocationTracker
tracker);
}Plugins
Для построения plugin-architected приложения, мы используем депенденси инджекшн фреймворк для того чтобы разделить интерфейсы от реализации, таким образом “Plugin” может быть повторно использован в различных приложениях:
С помощью Multibindings мы можем создать интерфейс и провайд метод, который будет являться точкой расширения для множества плагинов:
Вывод
По моему мнению Multibindings предоставляет достаточно широкие возможности для организации предоставления зависимостей, мы можем красиво организовать наши фабрики, а также подходит для реализации архитектуры расширения.
Пример на GitHub