SOLID violations and fixes in LLD - Architecture Diagram

System Overview - SOLID violations and fixes

This system demonstrates common violations of the SOLID principles in software design and how to fix them. It shows a simple order processing system where each component has a clear responsibility, following best practices for maintainability and scalability.

Architecture Diagram

User
  |
  v
Load Balancer
  |
  v
API Gateway
  |
  v
+----------------+      +----------------+      +----------------+
| Order Service  | ---> | Payment Service| ---> | Notification   |
| (Single Resp.) |      | (Single Resp.) |      | Service        |
+----------------+      +----------------+      +----------------+
       |                       |                       |
       v                       v                       v
+----------------+      +----------------+      +----------------+
| Order Database |      | Payment Gateway|      | Email Service  |
+----------------+      +----------------+      +----------------+
       ^                       ^                       ^
       |                       |                       |
      Cache                  Cache                   Cache

Components

User

user

Initiates requests to the system

Load Balancer

load_balancer

Distributes incoming requests evenly to API Gateway instances

API Gateway

api_gateway

Routes requests to appropriate services and handles authentication

Order Service

service

Manages order creation and retrieval, follows Single Responsibility Principle

Payment Service

service

Handles payment processing separately from order logic

Notification Service

service

Sends notifications like emails or SMS, separated from business logic

Order Database

database

Stores order data persistently

Payment Gateway

external_service

Processes payments securely with external providers

Email Service

external_service

Sends emails for notifications

Cache

cache

Speeds up data retrieval for frequently accessed data

Request Flow - 13 Hops

User → Load Balancer

Load Balancer → API Gateway

API Gateway → Order Service

Order Service → Cache

Cache → Order Service

Order Service → Order Database

Order Service → Payment Service

Payment Service → Payment Gateway

Payment Gateway → Payment Service

Payment Service → Notification Service

Notification Service → Email Service

Notification Service → API Gateway

API Gateway → User

Failure Scenario

Component Fails:Order Database

Impact:New orders cannot be saved, causing order creation failures. Cached data may still be served for reads but will be stale.

Mitigation:Use database replication and failover to a standby database. Implement retry logic and circuit breakers in Order Service.

Architecture Quiz - 3 Questions

Which component ensures that order creation and payment processing are handled separately to follow the Single Responsibility Principle?

A API Gateway and Load Balancer

B Order Service and Payment Service

C Cache and Database

D Notification Service and Email Service

Design Principle

This architecture demonstrates the SOLID principles by separating concerns into distinct services, improving maintainability and scalability. It uses caching to optimize performance and externalizes payment and notification responsibilities to specialized services. The design also includes fault tolerance strategies like database replication and load balancing.

Practice

1. Which SOLID principle is violated if a class has too many responsibilities, making it hard to maintain?

easy

A. Single Responsibility Principle

B. Open/Closed Principle

C. Liskov Substitution Principle

D. Interface Segregation Principle

Solution

1. Step 1: Understand the problem of multiple responsibilities

   A class with many responsibilities is hard to maintain and change because changes in one responsibility may affect others.

2. Step 2: Identify the violated SOLID principle

   The Single Responsibility Principle states that a class should have only one reason to change, meaning one responsibility.

3. Final Answer:

   Single Responsibility Principle -> Option A

4. Quick Check:

   One class, one responsibility = C [OK]

Hint: One class, one job means Single Responsibility Principle [OK]

Common Mistakes:

• Confusing Single Responsibility with Open/Closed Principle
• Thinking Liskov Substitution relates to responsibilities
• Mixing Interface Segregation with class responsibilities

2. Which of the following code snippets correctly applies the Open/Closed Principle by allowing extension without modification?
class Shape {
draw() { /* draw shape */ }
}
class Circle extends Shape {
draw() { /* draw circle */ }
}

easy

A. Adding new shape classes by extending Shape without changing existing code

B. Modifying the Shape class draw method to handle all shapes

C. Using a single class for all shapes with if-else inside draw

D. Changing Circle class to override Shape's draw method with new logic

Solution

1. Step 1: Understand Open/Closed Principle

   This principle says software entities should be open for extension but closed for modification.

2. Step 2: Analyze the code snippet

   Extending Shape with new classes like Circle adds new behavior without changing existing Shape code.

3. Final Answer:

   Adding new shape classes by extending Shape without changing existing code -> Option A

4. Quick Check:

   Extend without modify = A [OK]

Hint: Extend classes, don't change existing ones [OK]

Common Mistakes:

• Modifying base class instead of extending
• Using if-else inside methods to handle new cases
• Overriding methods incorrectly causing side effects

3. Given the following code violating Interface Segregation Principle, what is the output when calling robot.work()?

interface Worker {
  void work();
  void eat();
}
class Robot implements Worker {
  public void work() { System.out.println("Robot working"); }
  public void eat() { throw new UnsupportedOperationException(); }
}
Robot robot = new Robot();
robot.work();

medium

A. No output

B. UnsupportedOperationException thrown

C. Compilation error

D. Robot working

Solution

1. Step 1: Understand the code behavior

   The robot class implements work() by printing "Robot working" and eat() throws an exception.

2. Step 2: Analyze the method called

   Only robot.work() is called, which prints the message without error.

3. Final Answer:

   Robot working -> Option D

4. Quick Check:

   Calling work() prints message = A [OK]

Hint: Calling only implemented methods avoids exceptions [OK]

Common Mistakes:

• Assuming eat() is called causing exception
• Thinking interface violation causes compile error
• Ignoring method actually called in code

4. Identify the main problem in this code violating Liskov Substitution Principle:

class Bird {
  void fly() { System.out.println("Flying"); }
}
class Ostrich extends Bird {
  void fly() { throw new UnsupportedOperationException(); }
}

medium

A. Bird class should not have fly method

B. Ostrich should override fly with different signature

C. Ostrich cannot replace Bird without breaking behavior

D. No violation, code is correct

Solution

1. Step 1: Understand Liskov Substitution Principle

   Subtypes must be replaceable for their base types without altering correctness.

2. Step 2: Analyze Ostrich behavior

   Ostrich throws exception on fly(), breaking expected behavior of Bird.

3. Final Answer:

   Ostrich cannot replace Bird without breaking behavior -> Option C

4. Quick Check:

   Subtype must behave like base = B [OK]

Hint: Subtype must not break base class behavior [OK]

Common Mistakes:

• Thinking method signature change fixes violation
• Ignoring exception breaking substitution
• Assuming base class design is wrong here

5. You have a payment system where the PaymentProcessor interface has methods payWithCreditCard(), payWithPayPal(), and payWithCrypto(). A new payment method is added, but many classes implementing this interface do not support all methods, causing empty or error implementations. How should you fix this design following SOLID principles?

hard

A. Remove unsupported methods from implementations silently

B. Split the interface into smaller ones for each payment method

C. Keep one interface and add flags to check supported methods

D. Add default empty implementations to the interface methods

Solution

1. Step 1: Identify the violated principle

   Having one interface with many methods causes classes to implement unsupported methods, violating Interface Segregation Principle.

2. Step 2: Apply the fix

   Splitting the interface into smaller, specific interfaces lets classes implement only what they support, improving design.

3. Final Answer:

   Split the interface into smaller ones for each payment method -> Option B

4. Quick Check:

   Small interfaces, no unused methods = D [OK]

Hint: Use many small interfaces, not one big one [OK]

Common Mistakes:

• Adding empty default methods hides design flaws
• Using flags complicates code and violates design
• Removing methods silently breaks interface contract