Как использовать Dagger, чтобы минимизировать время сборки приложения?

Оптимизация времени сборки с Dagger: Стратегии и практики

Dagger, как компиляторный фреймворк внедрения зависимостей (DI), уже изначально дает преимущества в производительности сборки по сравнению с рефлексивными аналогами (например, Spring). Однако при неправильном использовании он может стать "бутылочным горлышком". Вот комплексный подход к минимизации времени сборки.

1. Грамотная модульная архитектура

Ключевой принцип — декомпозиция графа зависимостей. Вместо одного гигантского AppComponent разбивайте его на субкомпоненты (Subcomponents) и компоненты зависимостей (Dependency Components).

// Плохо: все в одном компоненте
@Singleton
@Component(modules = [NetworkModule::class, DatabaseModule::class, 
                      FeatureAModule::class, FeatureBModule::class])
interface AppComponent {
    fun inject(activity: MainActivity)
}

// Лучше: разделение на подкомпоненты
@FeatureAScope
@Subcomponent(modules = [FeatureAModule::class])
interface FeatureAComponent {
    fun inject(fragment: FeatureAFragment)
}

@Singleton
@Component(modules = [CoreModule::class])
interface AppComponent {
    fun featureAComponent(): FeatureAComponent.Factory
}

Преимущества:

• При изменении в FeatureAModule пересобирается только FeatureAComponent
• Параллельная сборка независимых компонентов
• Инкрементальная компиляция работает эффективнее

2. Оптимизация модулей и предоставлений

Используйте @Binds вместо @Provides для интерфейсов, когда это возможно:

// Вместо этого (генерирует больше кода):
@Module
class NetworkModule {
    @Provides
    fun provideApiService(retrofit: Retrofit): ApiService {
        return retrofit.create(ApiService::class.java)
    }
}

// Используйте это (оптимизировано Dagger):
@Module
interface NetworkModule {
    @Binds
    fun bindApiService(impl: ApiServiceImpl): ApiService
}

Почему это важно: @Binds генерирует меньше шаблонного кода, что ускоряет компиляцию и уменьшает размер сгенерированных классов.

3. Контроль над графом зависимостей

• Избегайте циклических зависимостей — они усложняют анализ и замедляют компиляцию
• Используйте @Component.dependencies для явного разделения компонентов:

@Singleton
@Component(modules = [CoreModule::class])
interface CoreComponent {
    fun repository(): DataRepository
}

@FeatureScope
@Component(dependencies = [CoreComponent::class], 
           modules = [FeatureModule::class])
interface FeatureComponent {
    fun inject(activity: FeatureActivity)
}

4. Настройка Dagger компилятора

В gradle.properties или build.gradle добавьте:

// Включение параллельной обработки аннотаций
android {
    defaultConfig {
        javaCompileOptions {
            annotationProcessorOptions {
                arguments["dagger.fastInit"] = "enabled"
                arguments["dagger.formatGeneratedSource"] = "disabled"
            }
        }
    }
}

// Оптимизация для KAPT (если используете Kotlin)
kapt {
    useBuildCache = true
    keepJavacAnnotationProcessors = true
}

Критические параметры:

• dagger.fastInit — ускоряет инициализацию
• dagger.experimentalDaggerErrorMessages — улучшает диагностику без потерь производительности

5. Стратегическое использование скоупов

Чрезмерное количество кастомных скоупов создает сложный граф:

// Создавайте скоупы осмысленно
@Scope
@Retention(AnnotationRetention.RUNTIME)
annotation class UserSessionScope // Для зависимостей сессии

@Scope  
@Retention(AnnotationRetention.RUNTIME)
annotation class FeatureScope // Для функциональности

Рекомендация: Используйте @Singleton для действительно глобальных объектов, создавайте кастомные скоупы только для четко ограниченных жизненных циклов.

6. Профилирование и анализ

1. Включите логирование Dagger для диагностики:

./gradlew assembleDebug --info | grep -i "dagger"

1. Анализируйте сгенерированный код в build/generated/source/apt/

   • Ищите слишком большие файлы *_Factory.java
   • Проверяйте отсутствие дублирующихся предоставлений

2. Используйте Dagger's GraphViz вывод для визуализации графа:

@Component(modules = [...])
interface AppComponent {
    @Component.Factory
    interface Factory {
        fun create(@BindsInstance graphviz: GraphvizOutput): AppComponent
    }
}

7. Инкрементальная сборка и кэширование

• Убедитесь, что KAPT инкрементальный (по умолчанию в AGP 4.0+)
• Настройте кэширование Gradle:

org.gradle.caching=true
org.gradle.parallel=true
org.gradle.configureondemand=true

8. Альтернативы и дополнения

Для критичных к времени сборки проектов рассмотрите:

• Dagger Hilt — абстракция над Dagger с оптимизированными конвенциями
• Anvil (для Kotlin) — позволяет заменять часть KAPT на Kotlin Symbol Processing
• Manual DI для самых простых случаев

Заключение

Оптимизация сборки с Dagger — это баланс между:

1. Архитектурной чистотой (разделение компонентов)
2. Минимализмом кодогенерации (предпочтение @Binds)
3. Правильной конфигурацией инструментов (параметры компилятора)

Наиболее значимый выигрыш достигается при модульной архитектуре, где каждый функциональный модуль имеет свой компонент. Это позволяет Gradle распараллеливать сборку и минимизировать перекомпиляцию при изменениях.

Помните: преждевременная оптимизация может навредить. Сначала добейтесь работоспособности и читаемости кода, затем профилируйте сборку и точечно применяйте описанные техники.