The Decorator Design pattern, also known as the Wrapper pattern, is a structural design pattern that allows you to add new functionality to an existing object dynamically. It provides a flexible alternative to subclassing for extending the behavior of individual objects.

The pattern follows the principle of composition over inheritance by wrapping the original object with one or more decorator objects. These decorators have the same interface as the original object and enhance its functionality by adding new behaviors or modifying existing ones.

The key idea behind the Decorator pattern is to provide a way to attach additional responsibilities to an object transparently. This means that clients can interact with the decorated object just like they would with the original object, unaware of the added functionality provided by the decorators.

Real World Analogy

Let’s consider a real-world analogy of the Decorator pattern in the context of a coffee shop.

Imagine you have a base coffee, such as a simple black coffee. This black coffee represents the core functionality or base behavior. Now, customers come to the coffee shop and have the option to customize their coffee by adding various extras or enhancements. These extras can include milk, sugar, caramel syrup, whipped cream, or even flavor shots like vanilla or hazelnut.

In this analogy, the black coffee is the component, and the extras represent the decorators. Each decorator adds a specific enhancement or modification to the base coffee while maintaining its fundamental behavior.

For example:

• A MilkDecorator wraps the black coffee and adds milk to it, creating a coffee with milk.
• A SugarDecorator wraps the black coffee and adds sugar, creating a sweetened coffee.
• A CaramelDecorator wraps the black coffee and adds caramel syrup, creating a caramel-flavored coffee.
• A WhippedCreamDecorator wraps the black coffee and adds whipped cream on top, creating a coffee with whipped cream.

Customers can choose different combinations of decorators to customize their coffee according to their preferences. They can have a coffee with milk and sugar, a coffee with caramel and whipped cream, or any other combination they desire.

By using the Decorator pattern in this coffee shop scenario, you can dynamically add and remove enhancements to the base coffee without modifying its core implementation. It provides flexibility and allows for the creation of personalized coffee options while keeping the ordering process consistent.

Benefits of Decorator Design Pattern

1. Flexibility: You can add or remove decorators at runtime, allowing for dynamic behavior modification. This gives you the flexibility to mix and match decorators to achieve different combinations of functionality.
2. Single Responsibility: Each decorator focuses on a specific responsibility, making the code more modular and promoting the Single Responsibility Principle. It allows for the separation of concerns and easy addition or removal of responsibilities without affecting other parts of the code.
3. Code Reusability: Decorators can be reused across different objects, promoting code reuse and minimizing duplication. You can create a library of decorators and apply them to various objects as needed.
4. Open-Closed Principle: The Decorator pattern follows the Open-Closed Principle, as it allows you to extend the functionality of objects without modifying their existing code. You can introduce new decorators without altering the original object’s structure, promoting code maintainability and reducing the risk of introducing bugs.

Applications of Decorator Pattern

The Decorator pattern has several real-life use cases where dynamic functionality extension and flexible composition are required. Here are a few examples:

1. User Interface Customization: GUI frameworks often use the Decorator pattern to customize the appearance and behavior of UI components. Decorators can add features like borders, shadows, tooltips, or animations to existing components without modifying their core implementation. This allows for personalized user interfaces and promotes code reusability.
2. Logging and Monitoring: Decorators are commonly used to enhance logging and monitoring capabilities in software systems. By wrapping existing logging components with decorators, you can add functionality such as timestamping, log level filtering, encryption, or remote logging. Decorators enable incremental addition of logging features without impacting the original logging infrastructure.
3. Input/Output Stream Modification: The Decorator pattern is frequently used to modify input/output streams. Decorators can provide functionalities like compression, encryption, buffering, or adding additional data to the stream. This approach allows for flexible and reusable stream processing while preserving the stream’s original interface.
4. Dynamic Caching: Decorators can be applied to caching systems to add dynamic caching capabilities. By wrapping existing cache components with decorators, you can introduce features such as time-based expiration, eviction policies, or tiered caching. Decorators enable the modification of caching behavior without affecting the underlying data access logic.
5. Authentication and Authorization: In security systems, decorators can be employed to extend the authentication and authorization mechanisms. Decorators can add additional layers of security checks, logging, or auditing to existing authentication/authorization components. This allows for flexible customization of security features without modifying the core security infrastructure.
6. Text Processing and Formatting: Decorators are useful in text processing applications where dynamic formatting or transformation is required. Decorators can modify the output of text components by adding features like line numbering, spell-checking, HTML formatting, or language translation. This approach enables modular and customizable text processing pipelines.

Example

// Component interface
interface Logger {
    void log(String message);
}

// Concrete component
class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("Logging message to console: " + message);
    }
}

// Decorator
abstract class LoggerDecorator implements Logger {
    protected Logger logger;

    public LoggerDecorator(Logger logger) {
        this.logger = logger;
    }

    public void log(String message) {
        logger.log(message);
    }
}

// Concrete decorator
class TimestampLogger extends LoggerDecorator {
    public TimestampLogger(Logger logger) {
        super(logger);
    }

    public void log(String message) {
        super.log(message);
        System.out.println("Timestamp: " + System.currentTimeMillis());
    }
}

// Concrete decorator
class ErrorLogger extends LoggerDecorator {
    public ErrorLogger(Logger logger) {
        super(logger);
    }

    public void log(String message) {
        super.log(message);
        System.err.println("Error occurred!");
    }
}

// Usage example
public class Main {
    public static void main(String[] args) {
        Logger logger = new ConsoleLogger();
        Logger timestampLogger = new TimestampLogger(logger);
        Logger errorLogger = new ErrorLogger(timestampLogger);

        errorLogger.log("An important message!");
    }
}

In this example, we have a Logger interface representing the component. The ConsoleLogger class is a concrete implementation of the Logger interface, which logs messages to the console.

The LoggerDecorator is the abstract decorator class that implements the Logger interface as well. It has a reference to a Logger object and delegates the log() method call to it.

The TimestampLogger and ErrorLogger classes are concrete decorators. They extend the LoggerDecorator and add additional functionality to the log() method. Each decorator calls the log() method of the wrapped object and then adds its own specific functionality.

The output of the program will be:

Logging message to console: An important message!
Timestamp: 1620248529153
Error occurred!

Read More here:

https://www.scaler.com/topics/design-patterns/decorator-design-pattern/