Was ist das Adapter-Muster?

Question

Accepted Answer

Das **Adapter**-Muster ermöglicht es Objekten mit **inkompatiblen Schnittstellen**, zusammenzuarbeiten, indem eines mit der Schnittstelle versehen wird, die das andere erwartet. Es fungiert als Übersetzer zwischen zwei Schnittstellen und ermöglicht die Integration, ohne vorhandenen Code zu ändern.

## Was das Adapter-Muster tut

```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
```

## Beispiel

```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
```

## Verwendungszwecke und Vorteile

```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
```

## Warum es wichtig ist

Das Verständnis des Adapter-Musters ist wertvoll, weil es ein **sehr häufiges, praktisches Strukturmuster** für die Integration inkompatible Code ist, daher ist es relevantes Design-Wissen.

Das Adapter-Muster ermöglicht es Objekten mit **inkompatiblen Schnittstellen, zusammenzuarbeiten**, indem eines mit der Schnittstelle versehen wird, die das andere erwartet — fungiert als Übersetzer zwischen Schnittstellen.

Zu verstehen, was es tut (ein Objekt mit einer inkompatiblen Schnittstelle versehen, um die Schnittstelle offenzulegen, die ein Client benötigt, und zwischen den beiden übersetzen), ist das Kernwissen.

Das Verständnis der **Verwendungszwecke** ist besonders wertvoll, weil sie häufig und echte Anforderungen darstellen: **Integration von Drittanbieter-Bibliotheken** mit inkompatiblen Schnittstellen (eine häufige Situation — Sie müssen eine Bibliothek verwenden, aber ihre Schnittstelle passt nicht zu Ihrem Code), **Legacy-Code mit neuem Code kompatibel machen**, verschiedene APIs hinter einer gemeinsamen Schnittstelle vereinheitlichen und Implementierungen austauschen ermöglichen.

These Integrationsbedürfnisse entstehen ständig in der realen Entwicklung.

Das Verständnis der **Vorteile** — **Integration** (inkompatible Schnittstellen funktionsfähig machen, ohne eine zu ändern, was häufig erforderlich ist, wenn Sie Drittanbieter- oder Legacy-Code nicht ändern können), und **Entkopplung** (Ihr Code hängt von Ihrer eigenen Schnittstelle ab, während Adapter externe/inkompatible Code isolieren, sodass Sie Abhängigkeiten hinter dem Adapter austauschen oder upgraden können — ein wertvoller architektonischer Vorteil) — macht deutlich, warum Adapter praktisch wichtig ist.

Das Adapter-Muster ist eines der praktischesten Muster, weil die Integration von inkompatiblem Code (Drittanbieter-Bibliotheken, Legacy-Systeme, verschiedene APIs) ein konstantes, echtes Entwicklungsbedürfnis ist.

Da das Adapter-Muster ein sehr häufiges, praktisches Muster zur Integration inkompatible Schnittstellen (Drittanbieter-Bibliotheken, Legacy-Code, verschiedene APIs) ohne Änderung einer von ihnen darstellt — ein konstantes echtes Bedürfnis — und wertvolle Entkopplung bietet, und da das Verständnis, was es tut, seine Verwendungszwecke und Vorteile relevant für echte Integrationsarbeit ist, ist das Verständnis des Adapter-Musters wertvoll, praktisch relevantes Design-Wissen — ein häufig benötigtes Muster für die gemeinsame Aufgabe der Integration von inkompatiblem Code, bereitstellung von Integration und Entkopplung, und wichtiges Design-Wissen für die echte, wiederkehrende Herausforderung, verschiedene Teile von Code zum Zusammenarbeiten zu bringen.