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 combined to form larger structures. The most well-known structural design patterns include adapter and synthetic model.

In this article, we’ll take a deep dive into both design patterns and learn about their use cases, implementation, and benefits.

1. Adapter design pattern

Overview:

this adapter Design patterns can be used when you want to integrate an existing class with a new system but the interface of the existing class does not match the interface required by the new system. Adapters act as a bridge between two incompatible interfaces, allowing them to work together.

Use cases:

Consider a scenario where you have a third-party library or legacy system that cannot be modified, but you need to integrate it with your current code. Third-party code may have different method signatures or interfaces than your system expects. Adapter mode enables you to “tweak” existing code to meet the requirements of a new system without changing the original code.

Key components:

• client: A system or application that requires the required functionality but requires a specific interface.
• Adapter: An existing class or system provides functionality but does not match the required interface.
• adapter: Convert Adaptee’s interface to the type of interface expected by Client.

example:

Let’s say we have an existing class that handles payments through PayPal, but we now need to integrate it into a system that requires the Stripe payment interface. The Adapter design pattern can help with:

// 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 the adapter pattern:

• flexibility: You can reuse an existing class without modifying its code, which is helpful when using third-party equation libraries.
• single responsibility principle: The Adapter pattern allows a clear separation of concerns. Adapter is mainly responsible for interface conversion, while Client and Adaptee perform their respective duties.
• loose coupling: Client and Adaptee are loosely coupled, allowing you to easily replace or upgrade components.

When to use:

• When you need to integrate legacy code into a new system.
• When your system requires a specific interface but it is not provided by the available components.

2. Combination design pattern

Overview:

this synthetic Design patterns can be used when you need to work uniformly on single objects and combinations of objects. This mode allows you to build a tree structure that represents a part-whole hierarchy, where both leaf objects and composite objects are processed in the same way by the client.

Use cases:

Imagine that you are designing a graphics editor where users can draw basic shapes (such as circles and rectangles) and combine them into more complex shapes. Complex shapes are composed of a single shape, but you want to treat single and composite shapes the same way.

Key components:

• Element: An interface for declaring common operations on single objects and combinations.
• leaf: Implement each object of the Component interface. These are basic building blocks (for example, a single shape).
• synthetic: Object that saves multiple Leaf objects. Composite also implements the Component interface, allowing clients to treat it as a Leaf object.

example:

Let’s take the graphics editor as an example, where we want to process single 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 mode:

• Uniformity: Composite mode allows customers to work uniformly on single objects and combinations. You can handle Leaf and Composite objects in the same way without writing conditional code.
• Simplify client code: Since single and composite objects share the same interface, client-side code becomes simpler and easier to manage.
• Scalability: The system can be easily expanded 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 file system or shapes in a graphics editor.
• When you want customers to treat single objects and combinations uniformly.

in conclusion

both adapter and synthetic Design patterns are an indispensable tool in software development, especially in scenarios where flexibility and uniformity are required.

• adapter It’s ideal when you need to integrate incompatible interfaces without modifying existing code, making it useful in systems using legacy code or third-party libraries.

• synthetic Useful when you need to work with tree structures or part-whole hierarchies, allowing you to work with single objects and combinations in a unified manner.

These patterns can significantly improve the maintainability, flexibility, and scalability of applications, making them essential for building powerful software systems. Understanding and implementing these patterns can improve your design skills and allow you to more effectively solve structural problems in your code.