Wat is dependency injection in Android (Hilt, Dagger)?

Question

Accepted Answer

**Dependency injection (DI)** is een patroon waarbij objecten hun afhankelijkheden van buiten ontvangen in plaats van deze zelf aan te maken — wat testbaarheid, onderhoudbaarheid en flexibiliteit verbetert. In Android is **Hilt** (gebouwd op Dagger) het aanbevolen DI-framework.

## Wat DI is en waarom

```text
WITHOUT DI: a class CREATES its own dependencies (tightly coupled, hard to test/change):
  class UserRepo { val api = ApiService() }   // creates its own dependency — rigid
WITH DI: dependencies are PROVIDED from outside (injected):
  class UserRepo(val api: ApiService)          // receives it → flexible, testable
→ Benefits: TESTABILITY (inject mocks/fakes in tests), DECOUPLING, easier to swap
  implementations, centralized dependency management, less boilerplate (with a framework).
```

## Hilt — het aanbevolen Android DI-framework

```kotlin
// Hilt (built on Dagger) generates/manages dependency wiring for you
@HiltAndroidApp class MyApp : Application()      // set up Hilt

@AndroidEntryPoint class MainActivity : AppCompatActivity() {
  @Inject lateinit var repository: UserRepository  // Hilt INJECTS this automatically
}

// tell Hilt how to provide things
@Module @InstallIn(SingletonComponent::class)
object AppModule {
  @Provides fun provideApi(): ApiService = Retrofit.Builder()...create()
}
```

Hilt verzorgt het aanmaken en leveren van afhankelijkheden (met juiste scoping/lifecycles), waardoor handmatige wiring-boilerplate wordt gereduceerd.

## Waarom DI belangrijk is voor architectuur

```text
✓ TESTABILITY — inject test doubles (mocks/fakes) → unit-test in isolation (the big win)
✓ Works with architecture (MVVM): inject repositories into ViewModels, data sources into
  repositories → clean, decoupled, testable layers
✓ SCOPING — manage dependency lifecycles (singleton, per-activity, etc.)
✓ Less boilerplate than manual DI; standardized; Google-recommended (Hilt)
```

## Waarom het belangrijk is

Begrip van dependency injection is belangrijke kennis op senior-niveau omdat het een **sleutelpatroon is voor testbare, onderhoudbare Android-architectuur**, en Hilt is het aanbevolen framework, dus het is waardevol voor kwalitatieve Android-ontwikkeling.

Het kerneconcept — objecten **ontvangen hun afhankelijkheden van buiten** in plaats van deze zelf aan te maken — biedt aanzienlijke voordelen: het belangrijkste is **testbaarheid** (je kunt mocks of fakes in tests injecteren, wat geïsoleerd unit testing mogelijk maakt — het belangrijkste voordeel, omdat classes die hun eigen afhankelijkheden aanmaken moeilijk te testen zijn), plus **decoupling** (classes hangen niet af van concrete implementaties), flexibiliteit (eenvoudig om implementaties uit te wisselen), en gecentraliseerd afhankelijkheidsbeheer.

Begrip van **Hilt** (het aanbevolen Android DI-framework, gebouwd op Dagger) — hoe het automatisch afhankelijkheden aanmaakt, levert en scoped, waardoor handmatige wiring-boilerplate wordt gereduceerd — is de praktische kennis voor het implementeren van DI in modern Android.

Begrip van **waarom DI belangrijk is voor architectuur** is het sleutelinzicht: het werkt samen met patronen zoals MVVM (repositories injecteren in ViewModels, databronnen in repositories) om **schone, ontkoppelde, testbare lagen** te creëren — waardoor DI essentieel is voor het bouwen van goed-gearchitecteerde, testbare apps die aanbevolen Android-architectuur nastreeft.

Juiste **scoping** (het beheren van afhankelijkheidslifecycles) en verminderde boilerplate (versus handmatige DI) maken Hilt praktisch.

DI is een hoeksteen van professionele Android-architectuur omdat het de testbaarheid en decoupling mogelijk maakt die onderhoudbare apps vereisen.

Omdat DI een sleutelpatroon is voor testbare, onderhoudbare architectuur (waarbij het testbaarheidvoordeel centraal staat voor goed Android-development) en Hilt het aanbevolen framework is dat het praktisch maakt, en omdat begrip van DI en Hilt belangrijk is voor het bouwen van goed-gearchitecteerde, testbare apps, is begrip van dependency injection in Android belangrijke kennis op senior-niveau — een hoeksteen van professionele Android-architectuur die testbaarheid en decoupling mogelijk maakt, werkt samen met patronen zoals MVVM om onderhoudbare apps te bouwen, en weerspiegelt de architecturale geavanceerdheid die voor senior Android-rollen wordt verwacht.