Wat is het Adapter-patroon?

Question

Accepted Answer

Het **Adapter**-patroon stelt objecten met **incompatibele interfaces** in staat om samen te werken door er één in te pakken met een interface die de ander verwacht. Het fungeert als vertaler tussen twee interfaces, waardoor integratie mogelijk is zonder bestaande code aan te passen.

## Wat het Adapter-patroon doet

```text
ADAPTER → convert one interface into another that a client expects (a "translator"):
  → wrap an object whose interface is INCOMPATIBLE, exposing the interface the client needs
  → the adapter translates calls/data between the two interfaces
→ makes incompatible things work together WITHOUT changing either's code
```

## Voorbeeld

```js
// a third-party library with an incompatible interface
class ThirdPartyLogger { logMessage(text) { /* ... */ } }

// our code expects a .log(msg) interface → adapt it
class LoggerAdapter {
  constructor(thirdParty) { this.logger = thirdParty; }
  log(msg) { this.logger.logMessage(msg); }   // translate our interface to theirs
}
const logger = new LoggerAdapter(new ThirdPartyLogger());
logger.log('hello');   // our code uses .log; the adapter calls .logMessage
```

## Toepassingen en voordelen

```text
USES → integrate THIRD-PARTY libraries with incompatible interfaces; make legacy code work
  with new code; unify different APIs behind a common interface; swap implementations
BENEFITS:
  ✓ INTEGRATION → make incompatible interfaces work together without modifying either
  ✓ DECOUPLING → your code depends on YOUR interface; adapters isolate external/incompatible
    code → swap or upgrade dependencies behind the adapter
  ✓ Reuse existing code that doesn't quite fit
```

## Waarom het belangrijk is

Het begrijpen van het Adapter-patroon is waardevol omdat het een **zeer gebruikelijk, praktisch structureel patroon** is voor het integreren van incompatibele code, dus het is relevante ontwerp-kennis.

Het Adapter-patroon stelt objecten met **incompatibele interfaces in staat om samen te werken** door er één in te pakken met de interface die de ander verwacht — en fungeert als vertaler tussen interfaces.

Begrijpen wat het doet (een object met een incompatibele interface inpakken om de interface die een client nodig heeft bloot te stellen, en tussen de twee vertalen) is de kernkennis.

Het begrijpen van de **toepassingen** is vooral waardevol omdat ze gebruikelijk zijn, echte behoeften: **integrasie van externe bibliotheken** met incompatibele interfaces (een frequente situatie — je moet een bibliotheek gebruiken maar de interface past niet bij je code), het laten **werken van legacy code met nieuwe code**, het verenigen van verschillende API's achter een gemeenschappelijke interface, en het mogelijk maken om implementaties uit te wisselen.

Deze integratiebehoeften ontstaan voortdurend in echte ontwikkeling.

Het begrijpen van de **voordelen** — **integratie** (incompatibele interfaces laten samenwerken zonder beide aan te passen, wat vaak nodig is wanneer je code van derden of legacy code niet kunt wijzigen), en **ontkoppeling** (je code hangt af van je eigen interface terwijl adapters externe/incompatibele code isoleren, zodat je afhankelijkheden achter de adapter kunt wisselen of bijwerken — een waardevol architecturaal voordeel) — verduidelijkt waarom Adapter praktisch belangrijk is.

Het Adapter-patroon is een van de meest praktisch bruikbare patronen omdat het integreren van incompatibele code (externe bibliotheken, legacy-systemen, verschillende API's) een voortdurende, echte behoefte is in ontwikkeling.

Omdat het Adapter-patroon een zeer gebruikelijk, praktisch patroon is voor het integreren van incompatibele interfaces (externe bibliotheken, legacy code, verschillende API's) zonder beide aan te passen — een voortdurende echte behoefte — en waardevol ontkoppeling biedt, en omdat het begrijpen van wat het doet, de toepassingen en voordelen ervan relevant is voor echt integratiewerk, is het begrijpen van het Adapter-patroon waardevol, praktisch relevante ontwerp-kennis — een frequently-nodig patroon voor de gebruikelijke taak van het integreren van incompatibele code, wat integratie en ontkoppeling biedt, en belangrijke ontwerp-kennis voor de echte, terugkerende uitdaging om verschillende onderdelen van code samen te laten werken.