Was ist das Adapter-Muster?

Das Adapter-Muster (Adapter Pattern) ist ein strukturelles Entwurfsmuster, das es Klassen mit inkompatiblen Schnittstellen ermöglicht, zusammenzuarbeiten. Es fungiert als eine Hülle, die die Schnittstelle einer Klasse in eine andere umwandelt, die vom Client erwartet wird.

Anwendungen:

• Integration von Drittanbieterbibliotheken mit inkompatiblen Schnittstellen.
• Verwendung bestehender Klassen in neuen Systemen ohne deren Modifikation.
• Sicherstellung der Interaktion zwischen unabhängig entwickelten Klassen.

Implementierungsbeispiel (Objektadapter):

Angenommen, es gibt eine Klasse LegacyService mit einer Methode oldRequest():

class LegacyService {
    public void oldRequest() {
        // alter Code
    }
}

Und eine neue Schnittstelle NewService mit einer Methode newRequest():

interface NewService {
    void newRequest();
}

Der ServiceAdapter implementiert NewService und enthält eine Referenz auf LegacyService:

class ServiceAdapter implements NewService {
    private LegacyService legacyService;

    public ServiceAdapter(LegacyService legacyService) {
        this.legacyService = legacyService;
    }

    @Override
    public void newRequest() {
        // Umwandlung des Aufrufs der neuen Methode in den alten
        legacyService.oldRequest();
    }
}

Der Client kann LegacyService über die Schnittstelle NewService verwenden:

NewService service = new ServiceAdapter(new LegacyService());
service.newRequest(); // Ruft oldRequest() in LegacyService auf

Es gibt auch eine Variante — Klassenadapter, der Mehrfachvererbung (falls vom Sprach unterstützt) oder Vererbung von der zu adaptierenden Klasse und Implementierung der Zielschnittstelle nutzt. In Java, aufgrund des Fehlens von Mehrfachvererbung, wird dies durch Vererbung von der adaptierbaren Klasse und Implementierung der Adapter-Schnittstelle realisiert, was jedoch weniger flexibel ist. Der Objektadapter ist vorzuziehen, da er die Anpassung von Subklassen ermöglicht und eine starre Kopplung vermeidet.

Vorteile:

• Erlaubt die Wiederverwendung inkompatibler Klassen.
• Kapselt die Details der Schnittstellenumwandlung.
• Erhöht die Flexibilität des Systems.

Nachteile:

• Kann die Komplexität erhöhen, indem eine neue Klasse hinzugefügt wird.
• Die Leistung kann aufgrund einer zusätzlichen Abstraktionsebene leicht sinken.