Adapter and Composite Design Patterns

Design patterns are a fundamental aspect of software engineering, providing reusable solutions to common problems in software design. Structural design patterns focus on how classes and objects are composed to form larger structures. Among the most well-known structural design patterns are Adapter and Composite patterns.

In this article, we will explore these two design patterns in depth, understanding their use cases, implementations, and advantages.

1. Adapter Design Pattern

Overview:

The Adapter design pattern is used when you want to integrate an existing class with a new system but the interface of the existing class doesn't match what the new system requires. The Adapter acts as a bridge between two incompatible interfaces, allowing them to work together.

Use Case:

Consider a scenario where you have a third-party library or a legacy system that you cannot modify, but you need to integrate it with your current code. The third-party code may have a different method signature or interface than what your system expects. The Adapter pattern enables you to "adapt" the existing code to meet the new system's requirements without altering the original code.

Key Components:

• Client: The system or application that requires the desired functionality but expects a specific interface.
• Adaptee: The existing class or system that provides the functionality but does not match the required interface.
• Adapter: The class that converts the interface of the Adaptee into one that the Client expects.

Example:

Let's say we have an existing class that handles payments via PayPal, but we now need to integrate it into a system that expects a Stripe payment interface. Here's how the Adapter design pattern can help:

// Adaptee: The existing PayPal payment system
class PayPalPayment {
    pay(amount) {
        console.log(`Paying $${amount} using PayPal.`);
    }
}

// Target Interface: The system expects a Stripe-like payment interface
class StripePayment {
    processPayment(amount) {
        console.log(`Paying $${amount} using Stripe.`);
    }
}

// Adapter: Adapts PayPal to Stripe's interface
class PayPalAdapter extends StripePayment {
    constructor(paypal) {
        super();
        this.paypal = paypal;
    }

    processPayment(amount) {
        this.paypal.pay(amount);
    }
}

// Client: Works with the StripePayment interface
const paymentSystem = new PayPalAdapter(new PayPalPayment());
paymentSystem.processPayment(100);

Advantages of Adapter Pattern:

• Flexibility: You can reuse existing classes without modifying their code, which is helpful when working with third-party libraries.
• Single Responsibility Principle: The Adapter pattern allows for a clear separation of concerns. The Adapter focuses on converting interfaces, while the Client and Adaptee perform their respective roles.
• Loose Coupling: The Client and Adaptee are loosely coupled, allowing you to replace or upgrade components easily.

When to Use:

• When you need to integrate legacy code into a new system.
• When your system expects a specific interface but the available component does not provide it.

---

2. Composite Design Pattern

Overview:

The Composite design pattern is used when you need to treat individual objects and compositions of objects uniformly. This pattern allows you to build tree-like structures that represent part-whole hierarchies, where both leaf objects and composite objects are treated the same way by the client.

Use Case:

Imagine you are designing a graphic editor where users can draw basic shapes (such as circles and rectangles) and combine them into more complex shapes. A complex shape is made up of individual shapes, but you want to treat both individual and composite shapes in the same way.

Key Components:

• Component: The interface that declares common operations for both individual objects and composites.
• Leaf: The individual objects that implement the Component interface. These are the basic building blocks (e.g., a single shape).
• Composite: The object that holds multiple Leaf objects. The Composite also implements the Component interface, allowing it to be treated as a Leaf object by the client.

Example:

Let’s take the graphic editor example where we want to treat both individual shapes and groups of shapes uniformly:

// Component: The common interface for individual and composite objects
class Graphic {
    draw() {}
}

// Leaf: Represents individual shapes
class Circle extends Graphic {
    draw() {
        console.log("Drawing a Circle");
    }
}

class Rectangle extends Graphic {
    draw() {
        console.log("Drawing a Rectangle");
    }
}

// Composite: Represents groups of shapes
class CompositeGraphic extends Graphic {
    constructor() {
        super();
        this.graphics = [];
    }

    add(graphic) {
        this.graphics.push(graphic);
    }

    remove(graphic) {
        this.graphics = this.graphics.filter(g => g !== graphic);
    }

    draw() {
        for (const graphic of this.graphics) {
            graphic.draw();
        }
    }
}

// Client: Works with both individual and composite objects
const circle = new Circle();
const rectangle = new Rectangle();

const composite = new CompositeGraphic();
composite.add(circle);
composite.add(rectangle);

composite.draw(); // Output: Drawing a Circle, Drawing a Rectangle

Advantages of Composite Pattern:

• Uniformity: The Composite pattern allows clients to treat individual objects and compositions uniformly. You can handle both Leaf and Composite objects the same way without writing conditional code.
• Simplifies Client Code: Since individual objects and composite objects share the same interface, the client code becomes simpler and easier to manage.
• Extensibility: It’s easy to extend the system by adding new Leaf or Composite components without affecting the client code.

When to Use:

• When you need to represent part-whole hierarchies, such as files and folders in a filesystem or shapes in a graphic editor.
• When you want clients to treat individual objects and compositions uniformly.

---

Conclusion

Both the Adapter and Composite design patterns are essential tools in software development, especially in scenarios where flexibility and uniformity are needed.

• Adapter is ideal when you need to integrate incompatible interfaces without modifying the existing code, making it useful in systems where you work with legacy code or third-party libraries.

• Composite is useful when you need to work with tree-like structures or part-whole hierarchies, allowing you to treat individual objects and compositions in a unified way.

These patterns can significantly improve the maintainability, flexibility, and scalability of your applications, making them crucial for building robust software systems. Understanding and implementing these patterns can elevate your design skills, making you more effective in solving structural problems in your code.