데코레이터(Decorator) 패턴The Decorator Pattern

Decorator

decorate : to adorn, to embellish

As the word suggests, the decorator pattern is a pattern that decorates objects. You’ll often hear it described as “attaching new responsibilities to an object dynamically.” Hmm… it’s not exactly clear what that means.

Coffee with Lots of Ingredients

Let’s learn about the decorator pattern by implementing various coffees as classes!

The Situation

You can make all kinds of coffee depending on what goes into it. Add milk to coffee and you get a ‘latte’; add chocolate powder and you get a ‘caffè mocha’, and so on… There are countless combinations.

The Code

At first, it seems like we could implement this simply with inheritance. We inherit from a base Coffee class and create a class for each added ingredient to implement each coffee.

class Coffee:
    def __init__(self):
        self._cost = 4000
        self._recipe = ["Coffee"]

    def cost(self) -> int:
        return self._cost

    def recipe(self) -> list[str]:
        return self._recipe

class LatteCoffee(Coffee):
    def __init__(self):
        super().__init__()
        self._cost += 500
        self._recipe += ["Milk"]

class MochaCoffee(Coffee):
    def __init__(self):
        super().__init__()
        self._cost += 1000
        self._recipe += ["Mocha"]

So far, making each coffee through inheritance isn’t hard. But what happens when the ways to make coffee multiply?

if __name__ == "__main__":
    coffee = Coffee()
    latte_coffee = LatteCoffee()
    mocha_coffee = MochaCoffee()

    print(f"coffee / {coffee.recipe()} / {coffee.cost()}")
    print(f"Latte coffee / {latte_coffee.recipe()} / {latte_coffee.cost()}")
    print(f"Mocha coffee / {mocha_coffee.recipe()} / {mocha_coffee.cost()}")

coffee / ['Coffee'] / 4000
Latte coffee / ['Coffee', 'Milk'] / 4500
Mocha coffee / ['Coffee', 'Mocha'] / 5000

Too Many Coffee Combinations

The Situation

As we kept making coffee, the list of ingredients kept growing. And as the ingredients grew, the number of coffee combinations grew beyond what we could handle.

The Code

Until now, we implemented each coffee class through inheritance. But covering every possible combination with inheritance gets harder and harder. You start to seriously doubt whether stacking inheritance on top of inheritance is the right call.

class MilkMochaCoffee(LatteCoffee):
    def __init__(self):
        super().__init__()
        self._cost += 1000
        self._recipe += ["Mocha"]

class MilkMochaVanillaCoffee(MilkMochaCoffee):
    def __init__(self):
        super().__init__()
        self._cost += 500
        self._recipe += ["Vanilla"]

Characteristics of the Decorator Pattern

Let’s recall the two characteristics of the decorator pattern.

1. Dynamically
2. Adding new responsibilities

Think back to the inheritance approach. Its drawback was that every coffee had to be defined in advance as a class before the code ever ran.

The decorator pattern solves this problem. There’s no need to create classes ahead of time; it lets you attach the features an object needs dynamically, one by one.

Coffee Combinations with Decorators

The Code

Beverage is an abstract class that defines the base component. It declares cost() and recipe() as abstract methods, forcing every beverage to implement them.

from abc import ABC, abstractmethod

class Beverage(ABC):
    @abstractmethod
    def cost(self) -> int:
        pass

    @abstractmethod
    def recipe(self) -> list[str]:
        pass

The Coffee class is a concrete implementation of Beverage. It overrides the cost() and recipe() methods.

from typing import override

class Coffee(Beverage):
    @override
    def cost(self) -> int:
        return 5000

    @override
    def recipe(self) -> list[str]:
        return ["Coffee"]

The Decorator class is the most important class in the decorator pattern.

This class inherits from Beverage (inheritance) while also holding a Beverage object internally (composition).

class Decorator(Beverage):
    def __init__(self, beverage: Beverage):
        self.beverage = beverage

    def cost(self) -> int:
        return self.beverage.cost()

    def recipe(self) -> list[str]:
        return self.beverage.recipe()

These classes inherit from Decorator, keeping its basic behavior while adding more. They override cost() and recipe() to add mocha or milk to an existing beverage.

class Mocha(Decorator):
    def cost(self) -> int:
        return super().cost() + 1000

    def recipe(self)-> list[str]:
        return super().recipe() + ["Mocha"]

class Milk(Decorator):
    def cost(self) -> int:
        return super().cost() + 500

    def recipe(self) -> list[str]:
        return super().recipe() + ["Milk"]

Remember how we tried to make various coffees with inheritance? One class for coffee with one shot of mocha, another for two shots, then yet another inherited class with milk added…

With the decorator pattern, we can solve this by adding new responsibilities to an object dynamically.

if __name__ == '__main__':
    beverage: Beverage = Coffee()

    a = Mocha(beverage)
    b = Mocha(a)
    c = Milk(b)

    print(f"Decorator Coffee / {c.recipe()} / {c.cost()}")

Coffee / ['Coffee', 'Mocha', 'Mocha', 'Milk'] / 7500

Class Diagram

Keep in mind the shape here: the Decorator class inherits from the abstract Beverage class while also holding a Beverage object inside.

%%{
  init: {
    'theme': 'base',
    'themeVariables': {
      'primaryColor': '#2a3844',
      'lineColor': '#fff',
      'primaryTextColor': '#fff',
      'tertiaryColor': '#fff'
    }
  }
}%%

classDiagram
    direction LR

    class Beverage {
        <<interface>>
        cost()* int
        recipe()* list[str]
    }

    class Coffee {
        cost() int
        recipe() list[str]

    }

    Decorator *-- Beverage
    Decorator ..|> Beverage

    Beverage <|.. Coffee

    class Decorator {
        Beverage beverage
        cost()* int
        recipe()* list[str]
    }

    class Mocha {
        cost() int
        recipe() list[str]
    }

    class Milk {
        cost() int
        recipe() list[str]
    }

    Mocha --|> Decorator
    Milk --|> Decorator

Wrapping Up

When extending classes through inheritance becomes inefficient, the decorator pattern lets you add features dynamically. The part of the implementation worth noting is how the Decorator class both inherits and composes an object at the same time. You can put the decorator pattern to use for things like I/O handling or combining notification messages. 😊

# Basic notification
notifier = BaseNotifier()
notifier.send("message!")

# Notify via SMS and Slack
notifier = SlackNotifier(SMSNotifier(BaseNotifier()))
notifier.send("Important message!")

# Notify via SMS, Slack, and Jira
notifier = JiraNotifier(SlackNotifier(SMSNotifier(BaseNotifier())))
notifier.send("Critical issue detected!")