[Design Pattern] Decorator Pattern - 데코레이터 패턴

Decorator Pattern

데코레이터 패턴(Decorator Pattern)은 객체의 기능을 동적으로 추가하고 확장할 수 있는 패턴입니다.

• 이 패턴은 상속을 사용하지 않고도 객체에 새로운 행동을 추가할 수 있게 해줍니다.
• 데코레이터 패턴은 여러 개의 데코레이터 객체를 조합하여 다양한 기능을 동적으로 조합할 수 있는 유연성을 제공합니다.

• Decorator Pattern은 Object(객체)를 꾸며주는 역할을 합니다.
  • 원하는 기능으로 감싸서 사용할 수 있게 만들어주는 패턴 입니다.

class Animal:
    def speak(self):
        pass

class Cat(Animal):
    def speak(self):
        print("Meow", end='')

class Dog(Animal):
    def speak(self):
        print("Bark", end='')

• Animal, Cat, Dog Class가 있습니다.
• Cat, Dog는 모두 Animal을 상속 받습니다.
• 세 Class 모두 Speak 함수가 있습니다.

class makeSpace(animal:Animal):
    animal.speak()
    print(" ")

• makeSpeak 함수는 argument로 animal을 받고 함수 안에서 Animal의 speak를 호출 합니다.

• 여기서 Cat Object인 Kitty를 makeSpeak 함수로 호출하면 meow 라는 결과가 나옵니다.

class Deco(Animal):
    def __init__(self, animal:Animal):
        self.animals = animal
    def speak(self):
        self.animals.speak()

• Deco class는 Animal을 꾸미는 역할로 Animal과 동일한 interface를 가지고 있습니다.
• Animal에서 상속받고 constructor에서 Animal을 property로 가지고 있고 speak는 Animal의 speak 함수를 호출합니다.

class WthSmile(Deco):
    def speak(self):
        self.animal.speak()
        print(":)", end='')

class WthHeartEyes(Deco):
    def speak(self):
        self.animal.speak()
        print("<3", end='')

• WithSmile과 WithHeartEyes는 Deco를 상속받고 부모인 Deco 내부에 있는 Animal에서 speak를 호출하고 각각 :), <3을 print합니다.

Decorator Pattern은 기존의 Object에 더 많은 기능을 추가하기 위해 꾸미는 패턴이 필요할때 사용됩니다.

---

Example (Decorator Pattern)

                +----------------+
                |    Display     |
                +----------------+
                | + getColumns() |
                | + getRows()    |
                | + getRowText() |
                +----------------+
                       ^
                       |
      +----------------+----------------+
      |                                 |
+---------------+                   +-----------------+
| StringDisplay |                   | Deco (Decorator)|
+---------------+                   +-----------------+
| - string      |                   | - display       |
| + methods     |                   | + methods       |
+---------------+                   +-----------------+
                                              ^
                                              |
                 +----------------+-----------------+
                 |                                  |
         +-------------+                      +-------------+
         |  SideBorder |                      |  FullBorder |
         +-------------+                      +-------------+
         | - deco      |                      | + methods   |
         | + methods   |                      +-------------+
         +-------------+

class Display:
    def getColumns(self):
        pass

    def getRows(self):
        pass

    def getRowText(self, row):
        pass

    def show(self):
        n = self.getRows()
        for i in range(self.getRows()):
            print(self.getRowText(i))

class StringDisplay(Display):
    def __init__(self, letters):
        self.letters = letters

    def getColumns(self):
        return len(self.letters)

    def getRows(self):
        return 1

    def getRowText(self, row):
        if row == 0:
            return self.letters
        else:
            return -1

class Deco(Display):
    def __init__(self, display: Display):
        self.display = display

class SideBorder(Deco):
    def __init__(self, display, deco):
        super().__init__(display)
        self.borderDeco = deco

    def getColumns(self):
        return 1 + self.display.getColumns() + 1

    def getRows(self):
        return self.display.getRows()

    def getRowText(self, row):
        return self.borderDeco + self.display.getRowText(row) + self.borderDeco

class FullBorder(Deco):
    def __init__(self, display):
        super().__init__(display)

    def getColumns(self):
        return 1 + self.display.getColumns() + 1

    def getRows(self):
        return 1 + self.display.getRows() + 1

    def makeLine(self, deco, count):
        buffer = ""
        for i in range(count):
            buffer += deco
        return buffer

    def getRowText(self, row):
        if row == 0:
            return "+" + self.makeLine("-", self.display.getColumns()) + "+"
        elif row == (self.display.getRows() + 1):
            return "+" + self.makeLine("-", self.display.getColumns()) + "+"
        else:
            return "|" + self.display.getRowText(row - 1) + "|"

• Client Example 1

# Example usage
b1 = StringDisplay("hello")
b2 = SideBorder(b1, "#")
b3 = FullBorder(b2)
b1.show()
b2.show()
b3.show()

• Client Example Output 1

hello
#hello#
+-------+
|#hello#|
+-------+

• Client Example 2

b1 = StringDisplay("hello, world")
b1 = FullBorder(b1)
b1.show()

• Client Example Output 2

+------------+
|hello, world|
+------------+

• Client Example 3

a = StringDisplay("hello")
a = FullBorder(a)
a = SideBorder(a, "*")
a = FullBorder(a)
a = FullBorder(a)
a = SideBorder(a, "/")
a.show()

• Client Example Output 3

/+-----------+/
/|+---------+|/
/||*+-----+*||/
/||*|hello|*||/
/||*+-----+*||/
/|+---------+|/
/+-----------+/

• Client Example 4

b4 = SideBorder(
    FullBorder(
        FullBorder(
            SideBorder(
                FullBorder(
                    StringDisplay("hello")
                ), "*"
            ), 
        ), 
    "/"
    )
)
b4.show()

• Client Example Output 4

/+-----------+/
/|+---------+|/
/||*+-----+*||/
/||*|hello|*||/
/||*+-----+*||/
/|+---------+|/
/+-----------+/

---

투과적 API

Decorator 패턴에서는 Decorator와 Component를 동시에 하고 있습니다.

• Decorator 클래스 (및 그 하위 클래스들)는 Component 클래스와 동일한 API를 가집니다.
• 장식을 사용하여 내용을 감싸도 API들이 감추어지지 않고 다른 클래스에서 볼 수 있는데, 이것을 API가 투과적이라고 합니다.
  • 장식을 많이 사용해서 포함시켜도 API가 전혀 바뀌지 않음을 의미합니다.
• API가 투과적인 이유로 재귀적 구조가 등장했습니다.
  • Decorator가 둘러싸고 있는 component들이 실제로는 다른 decorator가 되는 구조 입니다.
• 양파껍질을 벗겨서 알맹이 인줄 알았으나, 그것 또한 껍질인 것과 같은 말입니다.

---

동적인 기능 추가

• Decorator 패턴에서 사용하는 "위임"은 Loose Coupling (느슨한 결합)이 됩니다.
  • Tight Coupling (강한 결합)은 클래스와 객체가 서로 의존하고 있는 상태입니다.
  • 이 상태에서는 일반적으로 유연성과 코드의 재사용성이 줄어들어 좋지 않습니다.
• 따라서, 프레임워크의 소스를 변경하지 않고, 오브젝트의 관계를 변경한 새로운 오브젝트를 만들 수 있습니다.