Hvad er dependency injection?

Question

Accepted Answer

**Dependency injection (DI)** er et mønster, hvor et objekt modtager sine **dependencies udefra** (injiceret) i stedet for at oprette dem selv. Det fremmer løs kobbling, testabilitet og fleksibilitet — et grundlæggende, bredt anvendt mønster i moderne software.

## Hvad dependency injection er

```text
WITHOUT DI → a class CREATES its own dependencies (tightly coupled):
  class OrderService { constructor() { this.db = new Database(); } }  // hardcoded dependency
WITH DI → dependencies are PROVIDED (injected) from outside:
  class OrderService { constructor(db) { this.db = db; } }   // db is injected
→ the object doesn't create/control its dependencies → they're given to it
```

## Hvorfor DI betyder noget

```text
✓ TESTABILITY → inject MOCKS/fakes in tests → test the class in isolation (the biggest win)
✓ LOOSE COUPLING → the class depends on an ABSTRACTION/interface, not a concrete class →
  swap implementations easily
✓ FLEXIBILITY → change dependencies without changing the class (different configs, environments)
✓ EXPLICIT dependencies → constructor shows what the class needs (vs hidden creation)
✓ Separation of concerns → creation/wiring is separate from use
```

## Former og frameworks

```text
→ CONSTRUCTOR injection → dependencies via the constructor (most common, preferred)
→ Setter / method injection → via setters or method parameters
→ DI CONTAINERS/frameworks → manage and inject dependencies automatically (Spring, NestJS,
  Angular, Dagger/Hilt, etc.) → wire up the object graph for you
→ inversion of control (IoC) → DI is a form of IoC (the framework/caller controls dependencies)
```

## Hvorfor det betyder noget

At forstå dependency injection er værdifuldt, fordi det er et **grundlæggende, bredt anvendt mønster**, der er centralt for testbar, vedligeholdelig, moderne software, så det er vigtig design-viden.

DI — at have objekter, der modtager deres dependencies udefra i stedet for at oprette dem selv — er et af de vigtigste og mest udbredte mønstre i moderne udvikling.

At forstå kerneideen (en klasse, der modtager dependencies via injection i stedet for at hardcode deres oprettelse) er grundlæggende.

At forstå **hvorfor DI betyder noget** er nøglen: den største fordel er **testabilitet** (at injicere mocks eller fakes for at teste klasser isoleret — da klasser, der opretter deres egne dependencies, er svære at teste, er DI essentiell for unit testing), plus **løs kobbling** (afhængigt af abstraktion i stedet for konkrete klasser, hvilket gør det muligt at bytte implementeringer), **fleksibilitet** (ændring af dependencies uden at ændre klassen, for forskellige konfigurationer og miljøer), **eksplicitte dependencies** (konstruktøren viser, hvad klassen har brug for, versus skjult oprettelse), og separation of concerns (installation adskilt fra brug).

Disse fordele gør DI central for vedligeholdelig, testbar arkitektur.

At forstå **formerne og frameworks** — constructor injection (den mest almindelige og foretrukne form), setter/method injection, **DI containers/frameworks** (Spring, NestJS, Angular, Dagger/Hilt automatisk styring og injektion af dependencies), og forholdet til **inversion of control** — præciserer, hvordan DI anvendes i praksis, da det er indbygget i mange større frameworks.

DI er grundlæggende for moderne software-arkitektur og en hjørnesten i testbar design.

Da dependency injection er et grundlæggende, udbredt mønster, der er centralt for testbar, vedligeholdelig, moderne software (med testabilitet som en afgørende fordel), og da det er indbygget i større frameworks og er en hjørnesten i god arkitektur, og da forståelse af det, dets fordele og dets former er vigtig for moderne udvikling, er forståelse af dependency injection værdifuld, praktisk vigtig design-viden — et grundlæggende mønster centralt for testbar, vedligeholdelig arkitektur, byggnet ind i mange større frameworks, essentiellt for unit testing og løs kobbling, og en hjørnesten i moderne software design, som hver udvikler bør forstå.