🎉 Hooray! After 3 years of work, I've finally released the ebook on design patterns! Check it out »

Bridge in Python

Bridge is a Conceptual design pattern that divides business logic or huge class into separate class hierarchies that can be developed independently.

One of these hierarchies (often called the Abstraction) will get a reference to an object of the second hierarchy (Implementation). The abstraction will be able to delegate some (sometimes, most) of its calls to the implementations object. Since all implementations will have a common interface, they’d be interchangeable inside the abstraction.

Learn more about Bridge

Usage of the pattern in Python



Usage examples: The Bridge pattern is especially useful when dealing with cross-platform apps, supporting multiple types of database servers or working with several API providers of a certain kind (for example, cloud platforms, social networks, etc.)

Identification: Bridge can be recognized by a clear distinction between some controlling entity and several different platforms that it relies on.

Conceptual Example

This example illustrates the structure of the Bridge design pattern. It focuses on answering these questions:

  • What classes does it consists of?
  • What roles do these classes play?
  • In what way the elements of the pattern are related?

main.py: Conceptual Example

from __future__ import annotations
from abc import ABC, abstractmethod

class Abstraction:
    The Abstraction defines the interface for the "control" part of the two
    class hierarchies. It maintains a reference to an object of the
    Implementation hierarchy and delegates all of the real work to this

    def __init__(self, implementation: Implementation) -> None:
        self.implementation = implementation

    def operation(self) -> str:
        return (f"Abstraction: Base operation with:\n"

class ExtendedAbstraction(Abstraction):
    You can extend the Abstraction without changing the Implementation

    def operation(self) -> str:
        return (f"ExtendedAbstraction: Extended operation with:\n"

class Implementation(ABC):
    The Implementation defines the interface for all implementation classes.
    It doesn't have to match the Abstraction's interface. In fact, the two
    interfaces can be entirely different. Typically the Implementation
    interface provides only primitive operations, while the Abstraction
    defines higher-level operations based on those primitives.

    def operation_implementation(self) -> str:

Each Concrete Implementation corresponds to a specific platform and
implements the Implementation interface using that platform's API.

class ConcreteImplementationA(Implementation):
    def operation_implementation(self) -> str:
        return "ConcreteImplementationA: Here's the result on the platform A."

class ConcreteImplementationB(Implementation):
    def operation_implementation(self) -> str:
        return "ConcreteImplementationB: Here's the result on the platform B."

def client_code(abstraction: Abstraction) -> None:
    Except for the initialization phase, where an Abstraction object gets
    linked with a specific Implementation object, the client code should only
    depend on the Abstraction class. This way the client code can support any
    abstraction-implementation combination.

    # ...

    print(abstraction.operation(), end="")

    # ...

if __name__ == "__main__":
    The client code should be able to work with any pre-configured
    abstraction-implementation combination.

    implementation = ConcreteImplementationA()
    abstraction = Abstraction(implementation)


    implementation = ConcreteImplementationB()
    abstraction = ExtendedAbstraction(implementation)

Output.txt: Output

Abstraction: Base operation with:
ConcreteImplementationA: Here's the result on the platform A.

ExtendedAbstraction: Extended operation with:
ConcreteImplementationB: Here's the result on the platform B.

Bridge in Other Languages

Bridge in Java Bridge in C# Bridge in PHP Bridge in TypeScript