Understanding the Bridge Design Pattern in Java

-

The Bridge Design Pattern is a structural design pattern that decouples an abstraction from its implementation, allowing them to vary independently. This pattern is especially useful when dealing with complex class hierarchies that would otherwise lead to an explosion of subclasses.

This post explains the Bridge Pattern using a practical example of video streaming platforms and video quality options, demonstrating how to avoid excessive subclassing through composition.

What is the Bridge Design Pattern?

Instead of using inheritance to combine abstraction and implementation, the Bridge Pattern uses composition to separate these concerns into different class hierarchies. This approach prevents subclass explosion and provides more flexibility in combining behaviors at runtime.

Problem Illustration

Consider video streaming platforms like YouTube and Netflix offering various video qualities such as HD, 4K, and 8K. A naive design would create subclasses for every combination (e.g., YouTubeHDVideo, Netflix4KVideo), rapidly increasing the number of classes as new platforms and qualities are added.

How Bridge Solves This Problem

The Bridge Pattern splits these responsibilities into two separate hierarchies:

  • Video Abstraction Hierarchy: Represents different platforms (YouTube, Netflix, Prime).
  • Video Processor Hierarchy: Represents various video qualities and processing strategies (HD, 4K, HDR).

The video abstraction holds a reference to a video processor object. This has-a relationship (composition) replaces the extensive inheritance model, allowing combinations to be made at runtime.

Java Code Example

// Implementor
public interface VideoProcessor {
    void process(String videoFile);
}

// Concrete Implementors
public class HDProcessor implements VideoProcessor {
    @Override
    public void process(String videoFile) {
        System.out.println("Processing video in HD quality: " + videoFile);
    }
}

public class UHD4KProcessor implements VideoProcessor {
    @Override
    public void process(String videoFile) {
        System.out.println("Processing video in 4K UHD quality: " + videoFile);
    }
}

// Abstraction
public abstract class Video {
    protected VideoProcessor processor;

    protected Video(VideoProcessor processor) {
        this.processor = processor;
    }

    public abstract void play(String videoFile);
}

// Refined Abstractions
public class YouTubeVideo extends Video {
    public YouTubeVideo(VideoProcessor processor) {
        super(processor);
    }

    @Override
    public void play(String videoFile) {
        System.out.print("YouTube playing - ");
        processor.process(videoFile);
    }
}

public class NetflixVideo extends Video {
    public NetflixVideo(VideoProcessor processor) {
        super(processor);
    }

    @Override
    public void play(String videoFile) {
        System.out.print("Netflix playing - ");
        processor.process(videoFile);
    }
}

Using the Bridge Pattern

public class BridgePatternDemo {
    public static void main(String[] args) {
        VideoProcessor hdProcessor = new HDProcessor();
        VideoProcessor uhd4kProcessor = new UHD4KProcessor();

        Video youtubeVideo = new YouTubeVideo(hdProcessor);
        youtubeVideo.play("My Holiday");

        Video netflixVideo = new NetflixVideo(uhd4kProcessor);
        netflixVideo.play("Nature Documentary");
    }
}

Benefits of the Bridge Pattern

  • Prevents exponential growth of subclasses by separating concerns.
  • Supports runtime flexibility by combining abstraction and implementation dynamically.
  • Enhances code maintainability and scalability in complex systems.

Summary

The Bridge Design Pattern offers an elegant way to manage complexity by breaking inheritance hierarchies into separate dimensions and composing them at runtime. It is very helpful when designing scalable and flexible systems with multiple dimensions of variation.

If this post helped clarify the Bridge Pattern, feel free to ask questions or leave your feedback in the comments. Follow for more detailed Java design pattern tutorials.

Comments

Post a Comment

Popular posts from this blog

Spring Boot on AWS EC2: Upload to S3 Securely Using IAM Role

-
When running a Spring Boot application on AWS EC2 , the most common security mistake is hardcoding AWS access keys inside application.properties . This is unnecessary and risky. AWS already provides a secure mechanism: IAM Roles attached to EC2 . In this blog, you will learn how to upload and download files to Amazon S3 from Spring Boot running on EC2 without any access keys , using: Spring Profiles AWS SDK v2 Instance Metadata Service (IMDS) IAM Roles Why Access Keys Are a Bad Idea on EC2 Typical S3 setups use: Access key Secret key Region Bucket This works only for local development. It should NOT be used on EC2. Problems with access keys: Stored in config or code (high risk) Might leak through Git, logs, or screenshots Require manual rotation Not needed if app runs on EC2 AWS automatically manages temporary credentials using the EC2 Instance Profile (IAM Role) . Architecture: EC2 → IAM Role → S3 Spring Boot app r...
Read more

Java Streams Intermediate Operations Explained with Examples

-
Image
The Java Stream API lets you process collections in a fluent, declarative style. In this post, we’ll walk through the most useful intermediate operations with simple examples. Note: Examples below use Java 8 compatible collect(Collectors.toList()) . If you’re on Java 16+, you can replace it with toList() . 1) filter() — Select elements by a condition Keeps only elements that match the predicate. List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10); List<Integer> res = list.stream() .filter(num -> num % 2 != 0) // keep only odd numbers .collect(Collectors.toList()); System.out.println(res); // [1, 3, 5, 7, 9] 2) map() — Transform each element Applies a function to every element and returns a stream of results. List<String> strs = Arrays.asList("rama", "anjaneya", "krishna"); List<String> upper = strs.stream() .map(String::toUpperCase) .collect(Collectors.toList()); System.o...
Read more

ConcurrentHashMap vs Synchronized HashMap in Java

-
Image
Introduction In multi-threaded Java applications, managing shared data safely and efficiently is crucial. Two common approaches are using Synchronized HashMap (via Collections.synchronizedMap(...) ) and ConcurrentHashMap . While both aim to provide thread-safety, their implementations and performance characteristics differ significantly. This post explores these differences in detail. What is a Synchronized HashMap? Created by wrapping a regular HashMap using: Map<K, V> syncMap = Collections.synchronizedMap(new HashMap<>()); Enforces synchronization at the object level , meaning only one thread can access the map at any time (read or write). Supports null keys and values since it relies on HashMap behavior. Iterators are fail-fast , throwing ConcurrentModificationException if the map is modified while iterating. Simpler implementation, suitable when concurrency is low or performance is not cri...
Read more