What is the Facade pattern?

The Facade pattern provides a unified interface to a set of interfaces in a subsystem. It defines a higher-level interface that makes the subsystem easier to use.

Main characteristics:

• Hides the complexity of the system by providing a simple interface.
• Reduces client dependency on the direct work with the subsystem.
• Combines various classes and methods of the subsystem into a single facade class.

Example of usage:

Suppose we have a complex audio subsystem including classes for loading, decoding, and playing.

# Part of a complex audio subsystem
class AudioLoader:
    def load_file(self, filename):
        print(f"loading {filename}...")
        # Complex loading logic

class AudioDecoder:
    def decode_data(self, data):
        print("decoding data...")
        # Complex decoding logic
        return "decoded_audio_data"

class AudioPlayer:
    def play_audio(self, data):
        print("playing audio...")
        # Complex playback logic

Without Facade, the client would have to work directly with these classes:

# Client code without Facade
loader = AudioLoader()
decoder = AudioDecoder()
player = AudioPlayer()

loaded_data = loader.load_file("track.mp3")
decoded_data = decoder.decode_data(loaded_data)
player.play_audio(decoded_data)

Using the Facade simplifies this process:

class AudioFacade:
    def __init__(self):
        self._loader = AudioLoader()
        self._decoder = AudioDecoder()
        self._player = AudioPlayer()

    def play_audio_file(self, filename):
        data = self._loader.load_file(filename)
        decoded_data = self._decoder.decode_data(data)
        self._player.play_audio(decoded_data)

# Client code with Facade
audio_facade = AudioFacade()
audio_facade.play_audio_file("track.mp3")

Advantages:

• Simplification: Provides a simple API.
• Encapsulation: Hides the implementation details of the subsystem.
• Loose coupling: The client depends only on the Facade, not on many classes of the subsystem.

Disadvantages:

• The Facade can become a "god object" if it gathers too much logic.

Applicability:

• When a simple interface to a complex subsystem is needed.
• To reduce dependencies between the client and subsystem components.
• To structure the subsystem into levels.