Bridge Design pattern - Real time example [Send Message]

Master Software Architecture & Clean Code!

Subscribe to Ram N Java for clean code, design pattern implementations, and practical Java tutorials!

SUBSCRIBE NOW

Decoupling Message Abstraction from Transport Implementation

In modern enterprise systems, messaging mechanisms constantly grow across two orthogonal axes: the nature of the message (such as short, long, urgent, or encrypted messages) and the communication medium (such as Email, SMS, or Push Notification). Binding them tightly with inheritance results in an unmanageable class explosion.

The Bridge Design Pattern solves this challenge by separating the message abstraction hierarchy from the sender implementation hierarchy, bridging them through composition.

Complete Java Code Walkthrough

Here is an end-to-end, clean implementation showing how message abstractions delegate actual delivery to message sender implementors:

// 1. Implementor Interface
interface MessageSender {
    void sendMessage(String message);
}

// 2. Concrete Implementors
class EmailSender implements MessageSender {
    @Override
    public void sendMessage(String message) {
        System.out.println("Email Provider: Sending -> " + message);
    }
}

class SmsSender implements MessageSender {
    @Override
    public void sendMessage(String message) {
        System.out.println("SMS Gateway: Sending -> " + message);
    }
}

// 3. Abstraction (Bridge Connection)
abstract class Message {
    protected MessageSender messageSender;

    public Message(MessageSender messageSender) {
        this.messageSender = messageSender;
    }

    public abstract void send(String content);
}

// 4. Refined Abstractions
class ShortMessage extends Message {
    public ShortMessage(MessageSender messageSender) {
        super(messageSender);
    }

    @Override
    public void send(String content) {
        if (content.length() > 50) {
            content = content.substring(0, 47) + "...";
        }
        messageSender.sendMessage("[Short Message] " + content);
    }
}

class UrgentMessage extends Message {
    public UrgentMessage(MessageSender messageSender) {
        super(messageSender);
    }

    @Override
    public void send(String content) {
        messageSender.sendMessage("[PRIORITY HIGH] " + content);
    }
}

// 5. Client Application
public class MessageBridgeDemo {
    public static void main(String[] args) {
        // Send a short message via SMS
        MessageSender sms = new SmsSender();
        Message quickAlert = new ShortMessage(sms);
        quickAlert.send("Your verification code is 482910.");

        // Send an urgent message via Email
        MessageSender email = new EmailSender();
        Message criticalEmail = new UrgentMessage(email);
        criticalEmail.send("Database replica lag exceeded SLA threshold!");

        // Switch transport medium dynamically at runtime
        Message urgentSms = new UrgentMessage(sms);
        urgentSms.send("Database connection lost!");
    }
}

Key Architectural Benefits

• Eliminates Subclass Proliferation: Avoids creating combinations like ShortEmailMessage, UrgentEmailMessage, ShortSmsMessage, etc.
• Loose Coupling: Transport protocols (SMTP, Twilio SMS, etc.) are hidden behind the Implementor interface, keeping message logic clean.
• Open/Closed Principle: Adding a new channel (e.g., WhatsApp) or a new message format requires adding a single class without modifying existing components.

Watch More Related Design Pattern Tutorials

• Bridge Design Pattern in Action: Message Sending Implementation
• Bridge Design Pattern Explained: Real-Time Message Publishing Use Case
• Bridge Design Pattern Implementation: Message Publishing Example

---

Click here to watch in Youtube : https://www.youtube.com/watch?v=I4Q8tXSDkdM

Click the below Image to Enlarge

Bridge Design pattern - Real time example [Send Message]

See also: