Czy znasz użycie Dagger w tworzeniu aplikacji…

Tak, znam. Dagger to framework do wstrzykiwania zależności (Dependency Injection, DI) w Java i Android, który jest kompilowany podczas procesu budowania i pozwala na tworzenie zoptymalizowanego, wydajnego i łatwego do testowania kodu.

Główne koncepcje obejmują:

Moduły (Modules): Dostarczają zależności. Są oznaczone adnotacją @Module. Wewnątrz modułu metody z @Provides opisują, jak utworzyć konkretną zależność.

@Module
public class AppModule {

    @Provides
    // dostarcza kontekst aplikacji
    Context provideAppContext(Application application) {
        return application.getApplicationContext();
    }

    @Provides
    // dostarcza SharedPreferences
    SharedPreferences provideSharedPreferences(Context context) {
        return context.getSharedPreferences("MyPrefs", Context.MODE_PRIVATE);
    }
}

Komponenty (Components): Łączą moduły i wstrzykują zależności. Są oznaczone adnotacją @Component. Komponenty są "grafami zależności".

@Singleton
@Component(modules = {AppModule.class})
// komponent aplikacji
public interface AppComponent {

    // metoda do wstrzykiwania w MainActivity
    void inject(MainActivity activity);

    // metoda do pobierania SharedPreferences z grafu
    SharedPreferences getSharedPreferences();
}

Wstrzykiwanie (Injection): Proces wstrzykiwania zależności. Używa się @Inject dla pól lub konstruktorów.

public class MainActivity extends AppCompatActivity {

    @Inject
    // zależność, którą Dagger wstrzyknie
    SharedPreferences sharedPrefs;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Dagger generuje kod do tworzenia komponentu i wstrzykiwania
        ((MyApplication) getApplication()).getAppComponent().inject(this);

        // teraz sharedPrefs jest dostępny
        String value = sharedPrefs.getString("key", "default");
        Log.d("MainActivity", "Wartość z SharedPreferences: " + value);
    }
}

Zakresy (Scopes): Pozwalają zarządzać cyklem życia zależności. @Singleton dla zależności o cyklu życia aplikacji, niestandardowe adnotacje dla węższych zakresów (np. @PerActivity).
```
@Scope
@Retention(RetentionPolicy.RUNTIME)
// niestandardowy zakres dla aktywności
public @interface PerActivity {}
```

Dagger obsługuje również podkomponenty (@Subcomponent) do tworzenia mniejszych, hierarchicznych grafów zależności, co jest przydatne w modularnych aplikacjach lub dla zależności o krótkim cyklu życia (np. sesje użytkownika lub konkretne ekrany).

Główne zalety korzystania z Dagger:

Wydajność: Generacja kodu w czasie kompilacji minimalizuje koszty w czasie wykonywania w porównaniu do refleksyjnych frameworków DI.
Weryfikowalność: Kompilator sprawdza graf zależności, wykrywając błędy na etapie budowania, a nie w czasie działania.
Testowalność: Ułatwia zamianę rzeczywistych zależności na obiekty mock podczas testów.
Czytelność i utrzymanie: Wyraźnie opisuje zależności komponentów systemu.

Czy znasz użycie Dagger w tworzeniu aplikacji Android?