Wat is het adapterpatroon?

Het Adapter-patroon (Adapter Pattern) is een structureel ontwerppatroon dat het mogelijk maakt dat klassen met incompatibele interfaces samen kunnen werken. Het fungeert als een omhulsel dat de interface van een klasse omzet in een andere die door de client wordt verwacht.

Toepassingen:

• Integratie van externe bibliotheken met incompatibele interfaces.
• Gebruik van bestaande klassen in nieuwe systemen zonder ze te wijzigen.
• Zorgen voor interactie tussen onafhankelijk ontwikkelde klassen.

Voorbeeld van implementatie (objectadapter):

Stel dat er een klasse LegacyService bestaat met een methode oldRequest():

class LegacyService {
    public void oldRequest() {
        // oude code
    }
}

En een nieuwe interface NewService met een methode newRequest():

interface NewService {
    void newRequest();
}

De ServiceAdapter implementeert NewService en bevat een verwijzing naar LegacyService:

class ServiceAdapter implements NewService {
    private LegacyService legacyService;

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

    @Override
    public void newRequest() {
        // Omzetting van de aanroep van de nieuwe methode naar de oude
        legacyService.oldRequest();
    }
}

De client kan LegacyService gebruiken via de interface NewService:

NewService service = new ServiceAdapter(new LegacyService());
service.newRequest(); // Roept oldRequest() aan in LegacyService

Er bestaat ook een variant — klasseadapter, die gebruikmaakt van meervoudige overerving (indien ondersteund door de taal) of overerving van de te adapteren klasse en implementatie van de doelinterface. In Java, vanwege het ontbreken van meervoudige overerving, wordt dit gerealiseerd door overerving van de te adapteren klasse en implementatie van de adapterinterface, maar deze aanpak is minder flexibel. De objectadapter wordt aanbevolen omdat deze subklassen kan aanpassen en een starre koppeling vermijdt.

Voordelen:

• Maakt hergebruik van incompatibele klassen mogelijk.
• Incapsuleert de details van de interface-omzetting.
• Verhoogt de flexibiliteit van het systeem.

Nadelen:

• Kan de complexiteit verhogen door een nieuwe klasse toe te voegen.
• De prestaties kunnen licht dalen door een extra abstractielaag.