데코레이터 패턴

3. 동작 방식

클라이언트는 Component 인터페이스를 통해 객체를 사용한다. Decorator는 Component 객체를 감싸고, 클라이언트의 요청을 Component 객체에 전달한다.^[4] ConcreteDecorator는 요청을 전달하기 전후에 추가적인 작업을 수행하여 기능을 확장한다. 여러 개의 ConcreteDecorator를 중첩하여 기능을 조합할 수 있다.^[5]

위의 UML 클래스 다이어그램에서 추상 클래스 `Decorator`는 데코레이션된 객체(`Component`)에 대한 참조(`component`)를 유지하며 모든 요청을 해당 객체(`component.operation()`)로 전달한다. 이로 인해 `Decorator`는 `Component`의 클라이언트에게 투명하게(보이지 않게) 된다.^[7]

하위 클래스(`Decorator1`, `Decorator2`)는 `Component`에 추가되어야 하는 추가적인 동작(`addBehavior()`)을 구현한다(요청을 전달하기 전/후).

시퀀스 다이어그램은 실행 시간 상호 작용을 보여준다. `Client` 객체는 `Decorator1` 및 `Decorator2` 객체를 통해 작동하여 `Component1` 객체의 기능을 확장한다.

`Client`는 `Decorator1`에 `operation()`을 호출하고, `Decorator1`은 `Decorator2`에 요청을 전달한다. `Decorator2`는 `Component1`에 요청을 전달한 후 `addBehavior()`를 수행하고 `Decorator1`로 반환하며, `Decorator1`은 `addBehavior()`를 수행하고 `Client`로 반환한다. 데코레이터 패턴의 방침은 기존 객체를 새로운 `Decorator` 객체로 감싸는 것이다. 그 방법으로, `Decorator`의 생성자 인수로 감쌀 대상인 `Component` 객체를 읽어 들여, 생성자 내부에서 해당 객체를 멤버로 설정하는 것이 일반적이다.

데코레이터 패턴은 기존 클래스를 확장할 때 클래스 상속의 대체 수단으로 사용된다. 상속이 컴파일 시에 기능을 확장하는 데 반해, 데코레이터 패턴은 프로그램 실행 시에 기능 추가를 하는 점이 다르다.

4. 예제

다음은 C++98 이전의 구현을 기반으로 한 코드이다.^[7]

```cpp

#include

#include

// 음료 인터페이스

class Beverage {

public:

virtual void drink() = 0;

virtual ~Beverage() = default;

};

// 장식될 수 있는 음료

class Coffee : public Beverage {

public:

virtual void drink() override {

std::cout << "커피를 마시는 중";

}

};

class Soda : public Beverage {

public:

virtual void drink() override {

std::cout << "소다를 마시는 중";

}

};

// 음료 데코레이터

class BeverageDecorator : public Beverage {

public:

BeverageDecorator() = delete;

BeverageDecorator(std::unique_ptr component_)

: component(std::move(component_))

{

}

virtual void drink() = 0;

protected:

void callComponentDrink() {

if (component) {

component->drink();

}

}

private:

std::unique_ptr component;

};

// 우유 데코레이터

class Milk : public BeverageDecorator {

public:

Milk(std::unique_ptr component_, float percentage_)

: BeverageDecorator(std::move(component_))

, percentage(percentage_)

{

}

virtual void drink() override {

callComponentDrink();

std::cout << ", 우유는 " << percentage << "%";

}

private:

float percentage;

};

// 얼음 데코레이터

class IceCubes : public BeverageDecorator {

public:

IceCubes(std::unique_ptr component_, int count_)

: BeverageDecorator(std::move(component_))

, count(count_)

{

}

virtual void drink() override {

callComponentDrink();

std::cout << ", 얼음 " << count << " 개";

}

private:

int count;

};

// 설탕 데코레이터

class Sugar : public BeverageDecorator {

public:

Sugar(std::unique_ptr component_, int spoons_)

: BeverageDecorator(std::move(component_))

, spoons(spoons_)

{

}

virtual void drink() override {

callComponentDrink();

std::cout << ", 설탕 " << spoons << " 스푼";

}

private:

int spoons = 1;

};

int main() {

// 소다에 얼음 3개, 설탕 1스푼 추가

std::unique_ptr soda = std::make_unique();

soda = std::make_unique(std::move(soda), 3);

soda = std::make_unique(std::move(soda), 1);

soda->drink();

std::cout << std::endl;

// 커피에 얼음 16개, 우유 3%, 설탕 2스푼 추가

std::unique_ptr coffee = std::make_unique();

coffee = std::make_unique(std::move(coffee), 16);

coffee = std::make_unique(std::move(coffee), 3.);

coffee = std::make_unique(std::move(coffee), 2);

coffee->drink();

std::cout << std::endl;

return 0;

}

```

위 코드의 출력 결과는 다음과 같다.

```cpp

커피를 마시는 중, 얼음 3 개, 설탕 1 스푼

커피를 마시는 중, 얼음 16 개, 우유는 3%, 설탕 2 스푼

```

전체 예제는 [https://godbolt.org/z/s848nWozP godbolt page]에서 테스트할 수 있다.

다음은 파이썬 예제이며, https://wiki.python.org/moin/DecoratorPattern 파이썬 위키 - DecoratorPattern에서 가져왔다. 이 예제는 객체에 여러 동작을 동적으로 추가하기 위해 데코레이터를 파이프라인하는 방법을 보여준다.^[8]

```python

"""

0-255의 값을 갖는 10x10 그리드 세상에서 데코레이터를 시연합니다.

"""

import random

def s32_to_u16(x):

if x < 0:

sign = 0xF000

else:

sign = 0

bottom = x & 0x00007FFF

return bottom | sign

def seed_from_xy(x, y):

return s32_to_u16(x) | (s32_to_u16(y) << 16)

class RandomSquare:

def __init__(s, seed_modifier):

s.seed_modifier = seed_modifier

def get(s, x, y):

seed = seed_from_xy(x, y) ^ s.seed_modifier

random.seed(seed)

return random.randint(0, 255)

class DataSquare:

def __init__(s, initial_value=None):

s.data = [initial_value] * 10 * 10

def get(s, x, y):

return s.data[(y * 10) + x] # yes: these are all 10x10

def set(s, x, y, u):

s.data[(y * 10) + x] = u

class CacheDecorator:

def __init__(s, decorated):

s.decorated = decorated

s.cache = DataSquare()

def get(s, x, y):

if s.cache.get(x, y) == None:

s.cache.set(x, y, s.decorated.get(x, y))

return s.cache.get(x, y)

class MaxDecorator:

def __init__(s, decorated, max):

s.decorated = decorated

s.max = max

def get(s, x, y):

if s.decorated.get(x, y) > s.max:

return s.max

return s.decorated.get(x, y)

class MinDecorator:

def __init__(s, decorated, min):

s.decorated = decorated

s.min = min

def get(s, x, y):

if s.decorated.get(x, y) < s.min:

return s.min

return s.decorated.get(x, y)

class VisibilityDecorator:

def __init__(s, decorated):

s.decorated = decorated

def get(s, x, y):

return s.decorated.get(x, y)

def draw(s):

for y in range(10):

for x in range(10):

print "%3d" % s.get(x, y),

print

# 이제 데코레이터 파이프라인을 구축합니다:

random_square = RandomSquare(635)

random_cache = CacheDecorator(random_square)

max_filtered = MaxDecorator(random_cache, 200)

min_filtered = MinDecorator(max_filtered, 100)

final = VisibilityDecorator(min_filtered)

final.draw()

```

'''참고:''' 데코레이터 패턴 (또는 위 예제와 같은 파이썬에서의 이 디자인 패턴 구현)은 파이썬 데코레이터라는 파이썬 언어 기능과는 혼동해서는 안 된다.^[8]

다음은 Ruby 코드 예제이다.

```ruby

class AbstractCoffee

def print

puts "가격: #{cost}; 재료: #{ingredients}"

end

end

class SimpleCoffee < AbstractCoffee

def cost

1.0

end

def ingredients

"커피"

end

end

class WithMilk < SimpleDelegator

def cost

__getobj__.cost + 0.5

end

def ingredients

__getobj__.ingredients + ", 우유"

end

end

class WithSprinkles < SimpleDelegator

def cost

__getobj__.cost + 0.2

end

def ingredients

__getobj__.ingredients + ", 스프링클"

end

end

coffee = SimpleCoffee.new

coffee.print

coffee = WithMilk.new(coffee)

coffee.print

coffee = WithSprinkles.new(coffee)

coffee.print

```

위 코드의 출력 결과는 다음과 같다.

```

가격: 1.0; 재료: 커피

가격: 1.5; 재료: 커피, 우유

가격: 1.7; 재료: 커피, 우유, 스프링클

```

다음은 C# 코드 예제이다.

```csharp

namespace WikiDesignPatterns;

public interface IBike

{

string GetDetails();

double GetPrice();

}

public class AluminiumBike : IBike

{

public double GetPrice() =>

100.0;

public string GetDetails() =>

"Aluminium Bike";

}

public class CarbonBike : IBike

{

public double GetPrice() =>

1000.0;

public string GetDetails() =>

"Carbon";

}

public abstract class BikeAccessories : IBike

{

private readonly IBike _bike;

public BikeAccessories(IBike bike)

{

_bike = bike;

}

public virtual double GetPrice() =>

_bike.GetPrice();

public virtual string GetDetails() =>

_bike.GetDetails();

}

public class SecurityPackage : BikeAccessories

{

public SecurityPackage(IBike bike):base(bike)

{

}

public override string GetDetails() =>

base.GetDetails() + " + Security Package";

public override double GetPrice() =>

base.GetPrice() + 1;

}

public class SportPackage : BikeAccessories

{

public SportPackage(IBike bike) : base(bike)

{

}

public override string GetDetails() =>

base.GetDetails() + " + Sport Package";

public override double GetPrice() =>

base.GetPrice() + 10;

}

public class BikeShop

{

public static void UpgradeBike()

{

var basicBike = new AluminiumBike();

BikeAccessories upgraded = new SportPackage(basicBike);

upgraded = new SecurityPackage(upgraded);

Console.WriteLine($"Bike: '{upgraded.GetDetails()}' Cost: {upgraded.GetPrice()}");

}

}

```

위 코드의 출력 결과는 다음과 같다.

```

Bike: 'Aluminium Bike + Sport Package + Security Package' Cost: 111

```

다음은 PHP 코드 예제이다.

```php

abstract class Component

{

protected $data;

protected $value;

abstract public function getData();

abstract public function getValue();

}

class ConcreteComponent extends Component

{

public function __construct()

{

$this->value = 1000;

$this->data = "Concrete Component:\t{$this->value}\n";

}

public function getData()

{

return $this->data;

}

public function getValue()

{

return $this->value;

}

}

abstract class Decorator extends Component

{

}

class ConcreteDecorator1 extends Decorator

{

public function __construct(Component $data)

{

$this->value = 500;

$this->data = $data;

}

public function getData()

{

return $this->data->getData() . "Concrete Decorator 1:\t{$this->value}\n";

}

public function getValue()

{

return $this->value + $this->data->getValue();

}

}

class ConcreteDecorator2 extends Decorator

{

public function __construct(Component $data)

{

$this->value = 500;

$this->data = $data;

}

public function getData()

{

return $this->data->getData() . "Concrete Decorator 2:\t{$this->value}\n";

}

public function getValue()

{

return $this->value + $this->data->getValue();

}

}

class Client

{

private $component;

public function __construct()

{

$this->component = new ConcreteComponent();

$this->component = $this->wrapComponent($this->component);

echo $this->component->getData();

echo "Client:\t\t\t";

echo $this->component->getValue();

}

private function wrapComponent(Component $component)

{

$component1 = new ConcreteDecorator1($component);

$component2 = new ConcreteDecorator2($component1);

return $component2;

}

}

$client = new Client();

// 결과: #quanton81

//Concrete Component: 1000

//Concrete Decorator 1: 500

//Concrete Decorator 2: 500

//Client: 2000

4. 1. Java 예제

• Component: `Price`
• ConcreteComponent: `PrimePrice`
• Decorator: `MarginPrice`
• ConcreteDecorator: `WholesalePrice`, `DoublePrice`

4. 1. 1. Window 인터페이스

4. 1. 2. WindowDecorator

4. 1. 3. DecoratedWindowTest

4. 2. C++ 예제

5. 장점 및 단점

데코레이터 패턴은 실행 시간에 객체의 기능을 추가하거나 제거할 수 있어 유연하며, 기존 코드를 수정하지 않고도 기능을 확장할 수 있어 확장성이 뛰어나다. 각 데코레이터는 하나의 특정 기능에 집중하므로 단일 책임 원칙(SRP)을 따르며, 기존 코드를 변경하지 않고 기능을 확장할 수 있어 개방-폐쇄 원칙(OCP)을 만족한다.<sup>[5]</sup>

합성 방식을 지원하며, 실행 시간에 인터페이스의 동작을 추가하거나 변경할 수 있게 해준다. 객체를 다층적이고 임의의 조합으로 감싸는 것이 가능하며, 이는 서브클래스를 사용하는 것보다 메모리 효율적이다.<sup>[6]</sup>

그러나 데코레이터 패턴에는 다음과 같은 단점도 존재한다.

• 복잡성: 데코레이터 클래스가 많아질수록 코드가 복잡해질 수 있다.
• 객체 관리: 데코레이터로 감싸진 객체를 관리하기 어려울 수 있다.
• 초기 설정: 데코레이터를 조합하여 객체를 생성하는 초기 설정이 복잡할 수 있다.

5. 1. 장점

5. 2. 단점

• 복잡성: 데코레이터 클래스가 많아질수록 코드가 복잡해질 수 있다.
• 객체 관리: 데코레이터로 감싸진 객체를 관리하기 어려울 수 있다.
• 초기 설정: 데코레이터를 조합하여 객체를 생성하는 초기 설정이 복잡할 수 있다.

6. 활용 사례

데코레이터 패턴은 다양한 분야에서 활용된다.

• GUI 툴킷: 버튼, 텍스트 필드 등 UI 요소에 스크롤, 테두리, 그림자 등의 기능을 추가하는 데 사용될 수 있다. 예를 들어, 텍스트 편집 애플리케이션에서 텍스트를 강조 표시하는 버튼은 명령 패턴과 함께 데코레이터 패턴을 활용하여 구현될 수 있다.<sup>[4]</sup>
• I/O 스트림: Java와 .NET Framework의 I/O 스트림은 데코레이터 패턴을 사용하여 파일 입출력, 네트워크 통신 등에 버퍼링, 암호화 등의 기능을 추가한다.<sup>[5]</sup>
• 웹 개발: 웹 페이지에 인증, 권한 부여, 로깅 등의 기능을 추가하는 데 사용될 수 있다.
• 게임 개발: 게임 캐릭터에 아이템, 스킬 등의 기능을 추가하는 데 사용될 수 있다.
• API 개선: 퍼사드 패턴으로 단순화된 인터페이스에 기능을 추가할 수 있다. 예를 들어, 여러 언어 사전을 통합하는 다국어 사전 인터페이스에 언어 간 단어 번역 기능을 데코레이터 패턴으로 추가할 수 있다.

7. 다른 패턴과의 관계

데코레이터는 기능 확장에 대해 합성 방식을 지원하며, 하향식의 계층적 접근 방식은 아니다. 데코레이터를 사용하면 런타임에 인터페이스의 동작을 추가하거나 변경할 수 있다. 객체를 다층적이고 임의의 조합으로 래핑하는 데 사용할 수 있다. 서브클래스를 사용하여 동일한 작업을 수행하는 것은 복잡한 다중 상속 네트워크를 구현하는 것을 의미하며, 이는 메모리 비효율적이며 특정 시점에서는 확장할 수 없다. 마찬가지로 속성을 사용하여 동일한 기능을 구현하려는 시도는 객체의 각 인스턴스를 불필요한 속성으로 부풀린다.<sup>[5]</sup>

위와 같은 이유로 데코레이터는 서브클래싱의 메모리 효율적인 대안으로 간주되는 경우가 많다. 데코레이터는 서브클래스화할 수 없고, 런타임에 특성이 변경되어야 하거나 일반적으로 필요한 일부 기능이 부족한 객체를 특수화하는 데에도 사용할 수 있다.<sup>[5]</sup>

7. 1. 어댑터 패턴 (Adapter Pattern)

7. 2. 퍼사드 패턴 (Facade Pattern)

7. 3. 컴포지트 패턴 (Composite Pattern)

8. 한국적 상황과 데코레이터 패턴

빠르게 변화하는 한국 IT 산업 환경에서 데코레이터 패턴의 유연성과 확장성은 큰 장점이 된다. 특히 다양한 기능을 동적으로 추가해야 하는 전자정부 서비스 개발에 유용하게 활용될 수 있다. 한국은 온라인 게임 강국이며, 게임 캐릭터나 아이템에 다양한 기능을 추가해야 하는 경우가 많으므로 데코레이터 패턴이 적합하다. 또한 빠르게 변화하는 시장 요구에 맞춰 서비스를 개발하고 수정해야 하는 스타트업에게 데코레이터 패턴은 유용한 도구가 될 수 있다.<sup>[1]</sup>

9. 결론

데코레이터 패턴은 프로그램 실행 중에 기능을 추가하기 위해, 기존 객체를 새로운 `Decorator` 객체로 감싸는 방식이다. 이는 컴파일 시점에 기능을 확장하는 클래스 상속과는 다르다. `Decorator`의 생성자는 보통 감쌀 대상인 `Component` 객체를 인수로 받아, 생성자 내부에서 해당 객체를 멤버로 설정한다.

참조

<sub>[1]</sub> 서적 Design Patterns https://archive.org/[...] Addison-Wesley Publishing Co, Inc.
<sub>[2]</sub> 웹사이트 How to Implement a Decorator Pattern http://sam-burns.co.[...]
<sub>[3]</sub> 웹사이트 The Decorator Pattern, Why We Stopped Using It, and the Alternative https://betterprogra[...] 2022-03-08
<sub>[4]</sub> 서적 Design Patterns: Elements of Reusable Object-Oriented Software https://archive.org/[...] Addison Wesley
<sub>[5]</sub> 웹사이트 The Decorator design pattern - Problem, Solution, and Applicability http://w3sdesign.com[...] 2017-08-12
<sub>[6]</sub> 서적 Head First Design Patterns https://www.goodread[...] O'Reilly 2012-07-02
<sub>[7]</sub> 웹사이트 The Decorator design pattern - Structure and Collaboration http://w3sdesign.com[...] 2017-08-12
<sub>[8]</sub> 웹사이트 DecoratorPattern - Python Wiki https://wiki.python.[...]