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

> Il Bridge pattern spiegato: separare astrazione e implementazione, i vantaggi e un esempio in PHP con metodi di pagamento (carta di credito, PayPal) e conti personali o aziendali.

- URL: https://mautoblog.com/posts/design-patterns/bridge/
- Lingua: it
- Pubblicato: 2024-09-27
- Aggiornato: 2026-10-16
- Autore: Mauto
- Categorie: Sviluppo Software, Tecnologia
- Tags: Architettura Software, Best Practices, PHP
- Guida: Design Patterns (parte 8)
- Traduzione (en): https://mautoblog.com/en/posts/design-patterns/bridge/

---
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.
```php
// 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](/posts/design-patterns/)
