Publish-Subscribe (Pub-Sub) Design Pattern

Publish-Subscribe (Pub-Sub) is a recognized design pattern, particularly in the context of software architecture and distributed systems. It is not one of the classic "Gang of Four" design patterns, but it is widely used and categorized as a messaging pattern or architectural pattern.

What is the Publish-Subscribe Pattern?

The Publish-Subscribe pattern allows communication between components by decoupling the message sender (publisher) from the message receiver (subscriber). Publishers do not need to know who the subscribers are, and subscribers do not need to know who the publishers are. This is often mediated by a message broker or an event bus.

Key Characteristics:

Decoupling: Publishers and subscribers are independent; they interact indirectly through a messaging infrastructure.
Asynchronous Communication: Subscribers can receive messages asynchronously.
One-to-Many Communication: A single message can be sent to multiple subscribers.
Topic-Based Routing: Messages are categorized into topics or channels, and subscribers receive messages for the topics they are interested in.

Examples of Use:

Event-Driven Architectures: Reacting to events such as user actions, data changes, or system events.
Message Brokers: RabbitMQ, Apache Kafka, and ActiveMQ use the Pub-Sub pattern to handle distributed messaging.
Real-Time Applications: Chat applications, stock trading platforms, or notifications systems often rely on Pub-Sub.

Common Implementations:

Message Brokers (e.g., RabbitMQ, Kafka): Handle message distribution between publishers and subscribers.
Event Bus: Centralizes event processing in an application.
Observer Pattern: A specific implementation where objects (observers) subscribe to a subject and get notified of changes.

How it Differs from Other Patterns:

While similar to the Observer Pattern, the Publish-Subscribe pattern typically involves:

Multiple subscribers (not just one-to-one relationships).
Middleware or brokers for message distribution, rather than direct object-to-object interaction.

The Publish-Subscribe pattern is critical in modern software systems, enabling loose coupling and scalability in distributed and event-driven architectures.

Here’s an example of the Publish-Subscribe (Pub-Sub) pattern implemented in both a basic code example and a real-world use case.

Basic Code Example in JavaScript

This example demonstrates a simple Pub-Sub system without external libraries:

class PubSub {
  constructor() {
    this.subscribers = {}; // Stores events and their associated callbacks
  }

  // Subscribe to an event
  subscribe(event, callback) {
    if (!this.subscribers[event]) {
      this.subscribers[event] = [];
    }
    this.subscribers[event].push(callback);
  }

  // Publish an event with data
  publish(event, data) {
    if (this.subscribers[event]) {
      this.subscribers[event].forEach(callback => callback(data));
    }
  }

  // Unsubscribe from an event
  unsubscribe(event, callback) {
    if (this.subscribers[event]) {
      this.subscribers[event] = this.subscribers[event].filter(cb => cb !== callback);
    }
  }
}

// Example usage
const pubSub = new PubSub();

// Subscriber 1
pubSub.subscribe("news", (data) => {
  console.log("Subscriber 1 received:", data);
});

// Subscriber 2
pubSub.subscribe("news", (data) => {
  console.log("Subscriber 2 received:", data);
});

// Publish an event
pubSub.publish("news", { headline: "Breaking News!", details: "Details of the news..." });

// Output:
// Subscriber 1 received: { headline: 'Breaking News!', details: 'Details of the news...' }
// Subscriber 2 received: { headline: 'Breaking News!', details: 'Details of the news...' }

Real-World Implementation with RabbitMQ (Node.js Example)

Using RabbitMQ as the message broker, we implement the Pub-Sub pattern for distributed messaging.
First, ensure RabbitMQ is installed and running locally or in the cloud.

Publisher Code:

const amqp = require('amqplib');

async function publishMessage() {
  const connection = await amqp.connect('amqp://localhost');
  const channel = await connection.createChannel();
  const exchange = 'logs';

  await channel.assertExchange(exchange, 'fanout', { durable: false });

  const message = 'Hello Subscribers!';
  channel.publish(exchange, '', Buffer.from(message));

  console.log(`Message sent: ${message}`);
  setTimeout(() => {
    connection.close();
  }, 500);
}

publishMessage().catch(console.error);

Subscriber Code:

const amqp = require('amqplib');

async function subscribeToMessages() {
  const connection = await amqp.connect('amqp://localhost');
  const channel = await connection.createChannel();
  const exchange = 'logs';

  await channel.assertExchange(exchange, 'fanout', { durable: false });

  const queue = await channel.assertQueue('', { exclusive: true });
  console.log(`Waiting for messages in queue: ${queue.queue}`);

  channel.bindQueue(queue.queue, exchange, '');

  channel.consume(queue.queue, (msg) => {
    if (msg.content) {
      console.log(`Received: ${msg.content.toString()}`);
    }
  }, { noAck: true });
}

subscribeToMessages().catch(console.error);

How It Works in This Example:

Publisher:
- Connects to RabbitMQ and publishes a message to the logs exchange.
- The fanout exchange type ensures the message is broadcasted to all bound queues.
Subscriber:
- Listens to messages on the logs exchange by creating a temporary queue.
- Receives and processes any messages published to the exchange.

Output Example:

Run the subscriber script first:

node subscriber.js

Output:

Waiting for messages in queue: amq.gen-J5TVd8...

Run the publisher script:

node publisher.js

Output:

Message sent: Hello Subscribers!

Subscriber Output:
```
Received: Hello Subscribers!
```

This is a practical implementation of the Publish-Subscribe pattern using RabbitMQ. Let me know if you need an example in another programming language or more complex scenarios!

Search This Blog

Hany Ouf