Cos'è il pattern Adapter?

Il pattern Adapter (Adapter Pattern) è un pattern strutturale di progettazione che consente a classi con interfacce incompatibili di lavorare insieme. Funziona come una copertura che trasforma l'interfaccia di una classe in un'altra attesa dal cliente.

Applicazioni:

• Integrazione di librerie di terze parti con interfacce incompatibili.
• Uso di classi esistenti in nuovi sistemi senza modificarle.
• Garantire l'interazione tra classi sviluppate indipendentemente.

Esempio di implementazione (adattatore oggetto):

Supponiamo che esista una classe LegacyService con un metodo oldRequest():

class LegacyService {
    public void oldRequest() {
        // codice vecchio
    }
}

E una nuova interfaccia NewService con un metodo newRequest():

interface NewService {
    void newRequest();
}

L'adattatore ServiceAdapter implementa NewService e contiene un riferimento a LegacyService:

class ServiceAdapter implements NewService {
    private LegacyService legacyService;

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

    @Override
    public void newRequest() {
        // Trasformazione della chiamata del nuovo metodo in quella vecchia
        legacyService.oldRequest();
    }
}

Il cliente può usare LegacyService tramite l'interfaccia NewService:

NewService service = new ServiceAdapter(new LegacyService());
service.newRequest(); // Chiamerà oldRequest() in LegacyService

Esiste anche una variante chiamata adattatore di classe, che utilizza l'ereditarietà multipla (se supportata dal linguaggio) o l'ereditarietà dalla classe da adattare e l'implementazione dell'interfaccia di destinazione. In Java, a causa dell'assenza di ereditarietà multipla, si realizza tramite ereditarietà dalla classe adattabile e implementazione dell'interfaccia dell'adattatore, ma questo approccio è meno flessibile. L'adattatore oggetto è preferibile perché permette di adattare le sottoclassi ed evitare un legame rigido.

Vantaggi:

• Permette il riutilizzo di classi incompatibili.
• Incapsula i dettagli della trasformazione delle interfacce.
• Aumenta la flessibilità del sistema.

Svantaggi:

• Può aumentare la complessità aggiungendo una nuova classe.
• La performance può diminuire leggermente a causa di un livello di astrazione aggiuntivo.