Facade pattern in LLD - Architecture Diagram

System Overview - Facade pattern

The Facade pattern provides a simple interface to a complex system of classes or subsystems. It helps users interact with the system easily without knowing the details inside. This pattern is useful when you want to hide complexity and provide a clear entry point.

Architecture Diagram

User
  |
  v
Facade
  |
  +---------------------+
  |                     |
Subsystem A          Subsystem B
  |                     |
Subsystem C          Subsystem D

Components

User

actor

The client or user who interacts with the system through the Facade.

Facade

facade

Provides a simple unified interface to the complex subsystems.

Subsystem A

subsystem

Handles part of the system's functionality.

Subsystem B

subsystem

Handles another part of the system's functionality.

Subsystem C

subsystem

Supports Subsystem A with specific tasks.

Subsystem D

subsystem

Supports Subsystem B with specific tasks.

Request Flow - 10 Hops

User → Facade

Facade → Subsystem A

Facade → Subsystem B

Subsystem A → Subsystem C

Subsystem B → Subsystem D

Subsystem C → Subsystem A

Subsystem A → Facade

Subsystem D → Subsystem B

Subsystem B → Facade

Facade → User

Failure Scenario

Component Fails:Subsystem C

Impact:Subsystem A cannot get support from Subsystem C, causing partial failure in the operation.

Mitigation:Facade can catch errors from Subsystem A and provide fallback responses or notify the user gracefully.

Architecture Quiz - 3 Questions

What is the main role of the Facade component in this architecture?

A To store data permanently

B To provide a simple interface hiding complex subsystems

C To handle user authentication

D To replace all subsystems

Design Principle

The Facade pattern simplifies complex systems by providing a single entry point. It hides internal subsystem details and reduces dependencies for the user, improving maintainability and usability.

Practice

1. What is the main purpose of the Facade pattern in system design?

easy

A. To make the system slower by adding extra layers

B. To increase the number of classes in a system

C. To provide a simple interface to a complex system

D. To replace all subsystem classes with one class

Solution

1. Step 1: Understand the Facade pattern role

   The Facade pattern is designed to simplify interactions by providing a single interface to a complex system.

2. Step 2: Compare options with the pattern's purpose

   To provide a simple interface to a complex system correctly states the purpose. Options A, B, and C describe incorrect or harmful effects.

3. Final Answer:

   To provide a simple interface to a complex system -> Option C

4. Quick Check:

   Facade pattern = Simple interface [OK]

Hint: Facade means simple front for complex system [OK]

Common Mistakes:

• Thinking Facade replaces all classes
• Believing Facade adds complexity
• Confusing Facade with Singleton pattern

2. Which of the following is the correct way to define a Facade class method in a typical object-oriented language?

easy

A. private void complexOperation() { subsystem1.action(); }

B. public int complexOperation() { subsystem1.action(); subsystem2.action(); return 0; }

C. void complexOperation() { return subsystem1.action(); }

D. public void complexOperation() { subsystem1.action(); subsystem2.action(); }

Solution

1. Step 1: Identify Facade method visibility and calls

   Facade methods are usually public to expose simplified operations and call multiple subsystems internally.

2. Step 2: Check each option's correctness

   public void complexOperation() { subsystem1.action(); subsystem2.action(); } is public and calls multiple subsystems, matching Facade pattern. private void complexOperation() { subsystem1.action(); } is private, so not accessible. void complexOperation() { return subsystem1.action(); } returns a value but calls only one subsystem. public int complexOperation() { subsystem1.action(); subsystem2.action(); return 0; } returns int unnecessarily.

3. Final Answer:

   public void complexOperation() { subsystem1.action(); subsystem2.action(); } -> Option D

4. Quick Check:

   Facade method = public + multiple calls [OK]

Hint: Facade methods are public and call multiple subsystems [OK]

Common Mistakes:

• Making Facade methods private
• Returning values unnecessarily
• Calling only one subsystem inside Facade

3. Given this Facade code snippet, what will be the output?

class SubsystemA {
  void operationA() { print('A'); }
}
class SubsystemB {
  void operationB() { print('B'); }
}
class Facade {
  SubsystemA a = SubsystemA();
  SubsystemB b = SubsystemB();
  void doWork() {
    a.operationA();
    b.operationB();
  }
}
void main() {
  Facade f = Facade();
  f.doWork();
}

medium

A. BA

B. AB

C. A B

D. No output

Solution

1. Step 1: Trace Facade's doWork method calls

   doWork calls operationA() then operationB(), which print 'A' and 'B' respectively.

2. Step 2: Determine output sequence

   Since operationA prints 'A' first, then operationB prints 'B', output is 'AB' without spaces.

3. Final Answer:

   AB -> Option B

4. Quick Check:

   Facade calls order = AB [OK]

Hint: Follow method calls in order to find output [OK]

Common Mistakes:

• Assuming output is 'BA' reversing calls
• Expecting spaces between prints
• Thinking no output due to missing return

4. Identify the error in this Facade implementation:

class Subsystem {
  void action() { print('Action'); }
}
class Facade {
  Subsystem subsystem;
  void doTask() {
    subsystem.action();
  }
}
void main() {
  Facade f = Facade();
  f.doTask();
}

medium

A. Subsystem object is not initialized before use

B. Facade class should not call subsystem methods

C. doTask method should return a value

D. Subsystem class should be abstract

Solution

1. Step 1: Check subsystem object usage in Facade

   The Facade has a subsystem field but never initializes it before calling action(), causing a null reference error.

2. Step 2: Validate other options

   Facade class should not call subsystem methods is wrong because Facade should call subsystem methods. doTask method should return a value is not required. Subsystem class should be abstract is unnecessary.

3. Final Answer:

   Subsystem object is not initialized before use -> Option A

4. Quick Check:

   Uninitialized object = runtime error [OK]

Hint: Always initialize objects before calling methods [OK]

Common Mistakes:

• Ignoring null object initialization
• Thinking Facade should not call subsystems
• Expecting return values unnecessarily

5. You are designing a home automation system with many devices: lights, thermostat, security cameras, and music system. How would applying the Facade pattern help in this scenario?

hard

A. Create a single HomeAutomationFacade class that provides simple methods like turnOnAll() and setTemperature() to control all devices

B. Replace all device classes with one large class containing all device logic

C. Make each device class inherit from a common Facade superclass

D. Use Facade pattern to split each device into smaller classes

Solution

1. Step 1: Understand Facade's role in simplifying complex systems

   Facade groups multiple subsystem calls into simple methods, hiding complexity from users.

2. Step 2: Apply this to home automation

   Create a single HomeAutomationFacade class that provides simple methods like turnOnAll() and setTemperature() to control all devices correctly describes creating a Facade class with simple methods controlling multiple devices. Options A, B, and D misunderstand Facade's purpose.

3. Final Answer:

   Create a single HomeAutomationFacade class that provides simple methods like turnOnAll() and setTemperature() to control all devices -> Option A

4. Quick Check:

   Facade = simple interface for complex devices [OK]

Hint: Facade groups complex calls into simple methods [OK]

Common Mistakes:

• Merging all logic into one big class
• Confusing Facade with inheritance
• Splitting devices further instead of simplifying