Что такое Lazy в Dagger?

Что такое Lazy в Dagger?

В Dagger (популярная библиотека для внедрения зависимостей в Android и Java) Lazy — это специальный тип, предоставляемый фреймворком, который позволяет отложить создание объекта до момента его первого фактического использования. Это одна из форм ленивой инициализации (lazy initialization), которая может быть полезна для оптимизации производительности, особенно при работе с "тяжёлыми" зависимостями.

Основная цель Lazy

Главная задача Lazy<T> — избежать ненужного создания объектов, которые могут не потребоваться в течение жизненного цикла компонента. Вместо непосредственного предоставления экземпляра T, Dagger внедряет обёртку Lazy<T>, которая инкапсулирует логику: "создать объект только тогда, когда он впервые запрошен". Это полезно, когда:

• Зависимость ресурсоёмкая (например, требует длительных вычислений, сетевых запросов).
• Объект может не понадобиться вовсе в зависимости от условий выполнения.
• Вы хотите ускорить инициализацию компонента, отложив создание не критичных зависимостей.

Как используется Lazy в коде

Dagger предоставляет интерфейс Lazy<T> из пакета javax.inject. Вот пример его применения:

// Пример на Kotlin
import javax.inject.Inject
import javax.inject.Provider
import dagger.Lazy

class MyViewModel @Inject constructor(
    private val heavyServiceLazy: Lazy<HeavyService>
) {
    fun performAction() {
        // Объект HeavyService создаётся только здесь, при первом вызове get()
        val heavyService = heavyServiceLazy.get()
        heavyService.doWork()
    }
}

// "Тяжёлый" сервис
class HeavyService @Inject constructor() {
    init {
        // Имитация ресурсоёмкой инициализации
        Thread.sleep(1000)
    }
    fun doWork() {
        println("Work done!")
    }
}

// Пример на Java
import javax.inject.Inject;
import dagger.Lazy;

public class MyService {
    private final Lazy<ExpensiveDatabase> databaseLazy;

    @Inject
    public MyService(Lazy<ExpensiveDatabase> databaseLazy) {
        this.databaseLazy = databaseLazy;
    }

    public void fetchData() {
        // Создание объекта происходит только при первом вызове get()
        ExpensiveDatabase database = databaseLazy.get();
        database.query();
    }
}

Ключевые особенности Lazy

• Однократное создание: После первого вызова Lazy.get(), возвращённый объект кэшируется. Все последующие вызовы get() возвращают тот же экземпляр (если область видимости позволяет). Это похоже на by lazy в Kotlin.
• Потокобезопасность: Реализация Lazy в Dagger по умолчанию безопасна для многопоточных сред, что гарантирует корректное создание объекта даже при одновременных вызовах.
• Отличие от Provider: Важно не путать Lazy<T> с Provider<T>. Provider создаёт новый экземпляр при каждом вызове get(), в то время как Lazy — только один раз. Lazy — это, по сути, мемоизированный Provider.
• Области видимости (Scoping): Поведение Lazy тесно связано с областью видимости зависимости. Например, если HeavyService имеет область @Singleton, то даже через Lazy будет возвращён один и тот же экземпляр в рамках графа зависимостей.

Преимущества использования

1. Ускорение инициализации: Компоненты Dagger (например, ApplicationComponent) создаются быстрее, так как тяжёлые зависимости не инициализируются сразу.
2. Экономия ресурсов: Избегаются затраты на создание объектов, которые могут никогда не использоваться.
3. Гибкость: Позволяет управлять временем инициализации в runtime, что полезно для условной логики.

Ограничения и рекомендации

• Не стоит использовать Lazy для всех зависимостей без необходимости, так как это добавляет небольшие накладные расходы на обёртку и усложняет код.
• Целесообразно применять для объектов с дорогой инициализацией или чьё создание зависит от внешних условий.
• В Android Lazy может быть особенно полезен в Activity или Fragment, чтобы отложить создание зависимостей до onCreate или позже, ускоряя запуск.

Вывод

Lazy в Dagger — это мощный инструмент для оптимизации графа зависимостей, реализующий шаблон ленивой инициализации. Он помогает контролировать производительность приложения, откладывая создание ресурсоёмких объектов до момента их фактической необходимости, при этом обеспечивая безопасность и однократность инициализации. Использование Lazy требует баланса: оно должно быть оправдано сценарием, чтобы не усложнять архитектуру без нужды.