Design Pattern: Decorator Pattern

Summary

Definition

In Decorator design pattern, our target is to add some new functionality without affecting the existing object.

Say, there is an existing class that is responsible for printing a UI element (like a Button or a Table). Later we need the ability to add a border or text color to that element.

We can add new properties and functions to that existing class and introduce those properties. But that will violate the Open-Close principle of the SOLID principle.

So we can use the Decorator pattern and introduce those new properties and functions. The decorator pattern will add one or more new Classes which will contain the existing functionality of the existing object and will also contain new functionalities. That way these new properties will not be added to every object. Only the new decorator class(es) objects will have these new functionalities.

You can think of the decorator as a new skin/layer over the existing object. The actual object exists as it is, by using Decorator pattern we are just adding classes that will wrap the existing class and add new functionalities on top of that.

Implementation

A simple implementation of Decorator pattern will look like the diagram below.

Here are the steps you need to follow while implementing the Decorator design pattern.

Create an Abstract class that implements the same interface as the actual object.
This main Abstract class should set the actual object in the constructor.
Introduce the decorator classes which extend the Main decorator abstract class.
In the new decorator class call the constructor abstract class constructor so that the main class object can be set here.
In the new decorator class call the functions from the actual class, and include additional functionality with that existing functionality.

Examples

The following examples demonstrate how can we implement Decorator pattern in different use cases.

Example #1: Data Export

We are considering a data export operation for this example of Decorator pattern.

We have an existing class that can handle simple data export (fetching data and exporting in simple text format). Later we need to implement export as CSV, Excel, and JSON.

We can implement Decorator pattern to implement these new functionalities. Check the following implementation.

DataExport Interface

interface DataExport

   fuction processData()

end interface

SimpleExport Class

class SimpleDataExport implements DataExport

   function processData() 
       // some operation to fetch data and handling
   end function

end class

Main Decorator Class

abstract class DataExportDecorator implements DataExport

   dataExporter: DataExport

    constructor(dataExporterParam: DataExport)
        dataExporter = dataExporterParam
    end constructor

    function processData()
        dataExporter.processData()
    end function

end class

CSV Decorator Class

class CsvDataExportDecorator extends DataExportDecorator
    
    constructor(dataExporterParam: DataExport)
        // call parent constructor
        super(dataExporterParam)
    end constructor

    
    function processData() 
        dataExporter.processData()
        processCsv()
    end function

    function processCsv()
        // process data to CSV
    end function

end class

Excel Decorator Class

class ExcelDataExportDecorator extends DataExportDecorator
    
    constructor(dataExporterParam: DataExport)
        // call parent constructor
        super(dataExporterParam)
    end constructor

    
    function processData() 
        dataExporter.processData()
        processExcel()
    end function

    function processExcel()
        // process data to Excel
    end function

end class

JSON Decorator Class

class JsonDataExportDecorator extends DataExportDecorator
    
    constructor(dataExporterParam: DataExport)
        // call parent constructor
        super(dataExporterParam)
    end constructor

    
    function processData() 
        dataExporter.processData()
        processJson()
    end function

    function processJson()
        // process data to JSON
    end function

end class

Usage

csvDataExport = new CsvDataExportDecorator(new SimpleDataExport())
csvDataExport.processData()

excelDataExport = new ExcelDataExportDecorator(new SimpleDataExport())
excelDataExport.processData()

jsonDataExport = new JsonDataExportDecorator(new SimpleDataExport())
jsonDataExport.processData()

Code Implementations

Use the following links to check Decorator pattern implementation in specific programming languages.

Pattern Name	Decorator Pattern
Pattern Type	Structural Pattern
Scope	Object
Tagline	Additional responsibility to individual objects without affecting other objects
Use cases	When we want to attach additional responsibility/functionality to individual objects and not to the class
Related Patterns	Adapter Proxy Strategy
Difficulty Level	Easy
Implementations