Design patterns: Bridge, cos'è e come usarlo (esempio PHP)

data: · 3 min
autore: Mauto
serie: Design Patterns/ parte 8/24

I pattern classici della Gang of Four, uno per puntata, con esempi pratici in PHP.

  1. Design Patterns
  2. Design patterns: Singleton
  3. Design patterns: Factory Method
  4. Design patterns: Abstract Factory
  5. Design patterns: Builder
  6. Design patterns: Prototype
  7. Design patterns: Adapter
  8. Design patterns: Bridge, cos’è e come usarlo (esempio PHP)
  9. Design patterns: Composite
  10. Design patterns: Decorator
  11. Design patterns: Facade, cos’è e come usarlo (esempio PHP)
  12. Design patterns: Flyweight
  13. Design patterns: Proxy
  14. Design patterns: Chain of Responsibility, cos’è (esempio PHP)
  15. Design patterns: Command
  16. Design patterns: Interpreter
  17. Design patterns: Iterator
  18. Design patterns: Mediator
  19. Design patterns: Memento
  20. Design patterns: Observer
  21. Design patterns: State, cos’è e come usarlo (esempio PHP)
  22. Design patterns: Strategy
  23. Design patterns: Template Method
  24. Design patterns: Visitor
tutta la guida >

Il Bridge Pattern è un design pattern strutturale che separa l’astrazione dall’implementazione, consentendo loro di variare indipendentemente. Questo pattern è utile quando si vuole evitare un’esplosione di classi derivate dovuta a più dimensioni di variazione.

Caratteristiche del Bridge pattern

  1. Separazione tra astrazione e implementazione: Il Bridge Pattern separa l’astrazione (interfaccia o logica di alto livello) dall’implementazione (dettagli concreti), permettendo loro di variare indipendentemente.
  2. Flessibilità ed estensibilità: Favorisce l’estensibilità, consentendo di aggiungere nuove astrazioni e implementazioni senza modificare il codice esistente. Questo rende il sistema più flessibile e facilmente adattabile a nuovi requisiti.
  3. Riduzione della complessità: Riduce il numero di classi necessarie rispetto all’approccio tradizionale, evitando la proliferazione di classi derivate. Permette di combinare diverse astrazioni e implementazioni senza creare gerarchie multiple.
  4. Supporto per l’Indipendenza delle componenti: L’astrazione dipende solo dall’interfaccia dell’implementazione, non dalle sue classi concrete. Ciò significa che è possibile modificare o sostituire le implementazioni concrete senza influenzare l’astrazione e viceversa, mantenendo le due componenti indipendenti.
  5. Migliore manutenibilità: La separazione delle responsabilità tra astrazione e implementazione facilita la manutenzione del codice. Le modifiche possono essere fatte in una parte senza influenzare l’altra, riducendo il rischio di introdurre errori.
  6. Combinazioni dinamiche: Consente di creare dinamicamente combinazioni tra astrazioni e implementazioni diverse durante il runtime, migliorando la flessibilità operativa.
  7. Utilizzo in sistemi con più piattaforme: Il Bridge Pattern è particolarmente utile quando un sistema deve supportare più piattaforme, poiché consente di mantenere una singola interfaccia astratta che può funzionare con diverse implementazioni specifiche per ogni piattaforma.
  8. Riduzione del coupling (accoppiamento): Promuove un basso accoppiamento tra le classi, poiché l’astrazione conosce l’implementazione solo attraverso la sua interfaccia. Questo riduce la dipendenza diretta tra componenti concreti.

Esempio in PHP:

Immaginiamo di voler rappresentare diversi strumenti di pagamento (es. Carta di Credito e PayPal) per diversi tipi di account (es. Personale e Business). Il Bridge Pattern ci permette di separare i metodi di pagamento dagli account, consentendo di avere combinazioni flessibili senza dover creare una classe per ogni combinazione di account e metodo di pagamento.

// Implementazione: Interfaccia per i metodi di pagamento
interface PaymentMethod {
    public function processPayment($amount);
}

// Implementazione concreta: Carta di Credito
class CreditCard implements PaymentMethod {
    public function processPayment($amount) {
        echo "Pagamento di $amount processato tramite Carta di Credito.\n";
    }
}

// Implementazione concreta: PayPal
class PayPal implements PaymentMethod {
    public function processPayment($amount) {
        echo "Pagamento di $amount processato tramite PayPal.\n";
    }
}

// Abstraction: l'Account
abstract class Account {
    protected $paymentMethod;

    public function __construct(PaymentMethod $paymentMethod) {
        $this->paymentMethod = $paymentMethod;
    }

    abstract public function makePayment($amount);
}

// Refined Abstraction: Account Personale
class PersonalAccount extends Account {
    public function makePayment($amount) {
        echo "Account Personale: ";
        $this->paymentMethod->processPayment($amount);
    }
}

// Refined Abstraction: Account Business
class BusinessAccount extends Account {
    public function makePayment($amount) {
        echo "Account Business: ";
        $this->paymentMethod->processPayment($amount);
    }
}

// Utilizzo
$personalAccountWithCreditCard = new PersonalAccount(new CreditCard());
$personalAccountWithCreditCard->makePayment(100);  // Output: Account Personale: Pagamento di 100 processato tramite Carta di Credito.

$businessAccountWithPayPal = new BusinessAccount(new PayPal());
$businessAccountWithPayPal->makePayment(250);  // Output: Account Business: Pagamento di 250 processato tramite PayPal.

TORNA ALLA GUIDA

Copiato