Bridge Pattern w Abstrakcji – Przewodnik dla Początkujących

Dlaczego Bridge Pattern jest ważny?

Wyobraź sobie sytuację gdzie tworzysz aplikację obsługującą różne typy baz danych (MySQL, PostgreSQL, Oracle) i różne sposoby komunikacji (HTTP, HTTPS, FTP). Bez odpowiedniego wzorca projektowego szybko skończysz z eksplozją klas – każda kombinacja wymaga osobnej klasy!

Bridge Pattern rozwiązuje ten problem przez oddzielenie „co robimy” (abstrakcja) od „jak to robimy” (implementacja). To oznacza łatwiejsze dodawanie nowych funkcji bez modyfikacji istniejącego kodu.

Czym jest Bridge Pattern?

Bridge Pattern (Most) to wzorzec strukturalny który pozwala oddzielić abstrakcję od implementacji. Główną ideą jest zastąpienie dziedziczenia kompozycją.

Problem który rozwiązuje

Bez Bridge Pattern musielibyśmy tworzyć osobne klasy dla każdej kombinacji:

// Bez Bridge Pattern - eksplozja klas!
class EmailHttpSender { }
class EmailHttpsSender { }
class SMSHttpSender { }
class SMSHttpsSender { }
class PushHttpSender { }
class PushHttpsSender { }
// I tak dalej dla każdej kombinacji...

Z Bridge Pattern mamy tylko kilka podstawowych klas:

// Z Bridge Pattern - czysto i elastycznie
abstract class Notification { } // Abstrakcja
class EmailNotification extends Notification { } // Konkretna abstrakcja
class SMSNotification extends Notification { } // Konkretna abstrakcja

interface NotificationSender { } // Implementacja
class HttpSender implements NotificationSender { } // Konkretna implementacja
class HttpsSender implements NotificationSender { } // Konkretna implementacja

Implementacja krok po kroku

Zaimplementujmy system powiadomień używając Bridge Pattern:

Krok 1: Definiujemy interfejs implementacji

// Interfejs implementacji - "jak" wysyłamy
public interface NotificationSender {
    void sendMessage(String recipient, String message);
}

Krok 2: Tworzymy konkretne implementacje

// Implementacja przez HTTP
public class HttpSender implements NotificationSender {
    @Override
    public void sendMessage(String recipient, String message) {
        System.out.println("Wysyłanie przez HTTP do: " + recipient);
        System.out.println("Wiadomość: " + message);
        // Tutaj byłaby logika wysyłania przez HTTP
    }
}

// Implementacja przez HTTPS
public class HttpsSender implements NotificationSender {
    @Override
    public void sendMessage(String recipient, String message) {
        System.out.println("Bezpieczne wysyłanie przez HTTPS do: " + recipient);
        System.out.println("Zaszyfrowana wiadomość: " + message);
        // Tutaj byłaby logika wysyłania przez HTTPS
    }
}

// Implementacja przez FTP
public class FtpSender implements NotificationSender {
    @Override
    public void sendMessage(String recipient, String message) {
        System.out.println("Wysyłanie pliku FTP do: " + recipient);
        System.out.println("Zawartość pliku: " + message);
        // Tutaj byłaby logika wysyłania przez FTP
    }
}

Krok 3: Tworzymy abstrakcję

// Abstrakcja - "co" wysyłamy
public abstract class Notification {
    protected NotificationSender sender; // Most do implementacji!
    
    public Notification(NotificationSender sender) {
        this.sender = sender;
    }
    
    public abstract void send(String recipient, String message);
}

Krok 4: Implementujemy konkretne abstrakcje

// Email notification
public class EmailNotification extends Notification {
    
    public EmailNotification(NotificationSender sender) {
        super(sender);
    }
    
    @Override
    public void send(String recipient, String message) {
        String emailMessage = "📧 Email: " + message;
        sender.sendMessage(recipient, emailMessage);
    }
}

// SMS notification  
public class SMSNotification extends Notification {
    
    public SMSNotification(NotificationSender sender) {
        super(sender);
    }
    
    @Override
    public void send(String recipient, String message) {
        // SMS ma limit znaków
        String smsMessage = message.length() > 160 ? 
            message.substring(0, 157) + "..." : message;
        sender.sendMessage(recipient, "📱 SMS: " + smsMessage);
    }
}

// Push notification
public class PushNotification extends Notification {
    
    public PushNotification(NotificationSender sender) {
        super(sender);
    }
    
    @Override
    public void send(String recipient, String message) {
        String pushMessage = "🔔 Push: " + message;
        sender.sendMessage(recipient, pushMessage);
    }
}

Krok 5: Używamy wzorca

public class NotificationDemo {
    public static void main(String[] args) {
        // Różne kombinacje abstrakcji i implementacji
        
        // Email przez HTTP
        Notification emailHttp = new EmailNotification(new HttpSender());
        emailHttp.send("jan@kowalski.pl", "Witaj w naszym systemie!");
        
        System.out.println();
        
        // SMS przez HTTPS (bezpieczny)
        Notification smsHttps = new SMSNotification(new HttpsSender());
        smsHttps.send("+48123456789", "Twój kod weryfikacyjny: 1234");
        
        System.out.println();
        
        // Push przez FTP
        Notification pushFtp = new PushNotification(new FtpSender());
        pushFtp.send("user123", "Masz nową wiadomość!");
    }
}

Korzyści Bridge Pattern

1. Elastyczność

Możemy dodawać nowe typy powiadomień lub sposoby wysyłania niezależnie:

// Nowy typ powiadomienia
public class SlackNotification extends Notification {
    public SlackNotification(NotificationSender sender) {
        super(sender);
    }
    
    @Override
    public void send(String recipient, String message) {
        sender.sendMessage(recipient, "💬 Slack: " + message);
    }
}

// Nowy sposób wysyłania
public class WebSocketSender implements NotificationSender {
    @Override
    public void sendMessage(String recipient, String message) {
        System.out.println("Wysyłanie przez WebSocket do: " + recipient);
        System.out.println("Real-time: " + message);
    }
}

2. Testowanie

Łatwo mockujemy implementację do testów:

// Mock implementacja do testów
public class MockSender implements NotificationSender {
    private String lastRecipient;
    private String lastMessage;
    
    @Override
    public void sendMessage(String recipient, String message) {
        this.lastRecipient = recipient;
        this.lastMessage = message;
    }
    
    // Gettery do weryfikacji w testach
    public String getLastRecipient() { return lastRecipient; }
    public String getLastMessage() { return lastMessage; }
}

Praktyczne zastosowania

System płatności

// Abstrakcja płatności
abstract class Payment {
    protected PaymentProcessor processor;
    
    public Payment(PaymentProcessor processor) {
        this.processor = processor;
    }
    
    public abstract void processPayment(double amount);
}

// Implementacje procesorów
interface PaymentProcessor {
    void process(double amount, String type);
}

class PayPalProcessor implements PaymentProcessor {
    public void process(double amount, String type) {
        System.out.println("PayPal: " + amount + " PLN (" + type + ")");
    }
}

class StripeProcessor implements PaymentProcessor {
    public void process(double amount, String type) {
        System.out.println("Stripe: " + amount + " PLN (" + type + ")");
    }
}

// Konkretne płatności
class CreditCardPayment extends Payment {
    public CreditCardPayment(PaymentProcessor processor) {
        super(processor);
    }
    
    public void processPayment(double amount) {
        processor.process(amount, "Karta kredytowa");
    }
}

class BankTransferPayment extends Payment {
    public BankTransferPayment(PaymentProcessor processor) {
        super(processor);
    }
    
    public void processPayment(double amount) {
        processor.process(amount, "Przelew bankowy");
    }
}

Najczęstsze błędy

Kiedy NIE używać Bridge Pattern:

• Gdy masz tylko jedną implementację i nie planujesz więcej
• W prostych aplikacjach gdzie elastyczność nie jest priorytetem
• Gdy performance jest krytyczne (dodatkowa warstwa może spowalniać)

Kiedy używać Bridge Pattern:

• Masz wiele sposobów implementacji tej samej funkcjonalności
• Chcesz unikać stałego wiązania abstrakcji z implementacją
• Planujesz rozszerzać system o nowe implementacje lub abstrakcje
• Implementacja może się zmieniać w runtime

Przydatne zasoby:

• Refactoring Guru – Bridge Pattern
• Oracle Java Tutorial – Interfaces
• Baeldung – Bridge Pattern in Java

Bridge Pattern to elegancki sposób na tworzenie elastycznych systemów. Pamiętaj: kompozycja ponad dziedziczenie! Czy masz już pomysł gdzie wykorzystasz ten wzorzec w swoim projekcie?