Ce este pattern-ul adaptor?

Modelul de adaptare (Adapter Pattern) este un pattern structural de proiectare care permite claselor cu interfețe incompatibile să lucreze împreună. Acționează ca o înveliș care transformă interfața unei clase într-una așteptată de client.

Aplicații:

• Integrarea bibliotecilor terțe cu interfețe incompatibile.
• Utilizarea claselor existente în noi sisteme fără a le modifica.
• Asigurarea interacțiunii între clase dezvoltate independent.

Exemplu de implementare (adaptator de obiecte):

Să presupunem că există o clasă LegacyService cu o metodă oldRequest():

class LegacyService {
    public void oldRequest() {
        // cod vechi
    }
}

Și o nouă interfață NewService cu o metodă newRequest():

interface NewService {
    void newRequest();
}

Adaptatorul ServiceAdapter implementează NewService și conține o referință la LegacyService:

class ServiceAdapter implements NewService {
    private LegacyService legacyService;

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

    @Override
    public void newRequest() {
        // Transformarea apelului metodei noi în cea veche
        legacyService.oldRequest();
    }
}

Clientul poate folosi LegacyService prin interfața NewService:

NewService service = new ServiceAdapter(new LegacyService());
service.newRequest(); // Va apela oldRequest() în LegacyService

Există și o variantă — adaptator de clasă, care utilizează moștenirea multiplă (dacă limbajul o suportă) sau moștenirea de la clasa de adaptat și implementarea interfeței țintă. În Java, din cauza lipsei moștenirii multiple, aceasta se realizează prin moștenirea de la clasa de adaptat și implementarea interfeței adaptator, dar această abordare este mai puțin flexibilă. Adaptatorul de obiecte este preferat deoarece permite adaptarea subclasei și evită o legătură rigidă.

Avantaje:

• Permite reutilizarea claselor incompatibile.
• Encapsulează detaliile transformării interfeței.
• Crește flexibilitatea sistemului.

Dezavantaje:

• Poate crește complexitatea prin adăugarea unei noi clase.
• Performanța poate scădea ușor din cauza unui nivel suplimentar de abstractizare.