[디자인패턴] 데코레이터 패턴

 

데코레이터 패턴 (Decorator Pattern)

데코레이터 패턴은 객체 지향 디자인 패턴 중 하나로, 객체에 동적으로 새로운 기능을 추가할 수 있는 구조를 제공합니다. 이 패턴은 기존의 클래스를 수정하지 않고도 객체에 추가적인 책임을 부여할 수 있게 해줍니다. 데코레이터 패턴은 상속 대신 조합(composition)을 통해 기능을 확장하는 방법을 제시하며, 이는 객체 지향 설계의 개방-폐쇄 원칙(Open-Closed Principle)을 준수하는 대표적인 예입니다.

1. 데코레이터 패턴의 기본 개념

• 구성 요소:
  1. 컴포넌트(Component): 기본 인터페이스나 추상 클래스이며, 구체적인 객체들이 이를 구현합니다.
  2. 콘크리트 컴포넌트(Concrete Component): 실제 기능을 구현한 클래스입니다. 데코레이터에 의해 장식될 객체입니다.
  3. 데코레이터(Decorator): Component 인터페이스를 구현하며, Concrete Component 객체를 감싸서 새로운 기능을 추가합니다.
  4. 콘크리트 데코레이터(Concrete Decorator): 데코레이터의 구체적인 구현체로, 추가적인 기능을 구현하고 이를 원래 객체에 위임합니다.
• 장점:
  • 런타임에 객체에 새로운 기능을 동적으로 추가할 수 있습니다.
  • 상속을 남발하지 않으면서도 객체의 기능을 확장할 수 있습니다.
  • 클래스 계층의 복잡성을 줄여줍니다.
• 단점:
  • 데코레이터가 여러 개 중첩되면 복잡도가 증가할 수 있습니다.
  • 객체의 구성(decorator chain)이 복잡해지면, 디버깅이 어려워질 수 있습니다.

 

2. 데코레이터 패턴 예제

아래 예제에서는 커피를 만드는 시스템에서 데코레이터 패턴을 적용해 보겠습니다. 기본적인 커피(ConcreteComponent)에 추가적인 재료(예: 우유, 설탕 등)를 동적으로 추가하는 기능을 데코레이터를 통해 구현합니다.(C++)

#include <iostream>
#include <memory>
#include <string>

// Component
class Coffee {
public:
    virtual std::string getDescription() const = 0;
    virtual double cost() const = 0;
    virtual ~Coffee() = default;
};

// ConcreteComponent
class SimpleCoffee : public Coffee {
public:
    std::string getDescription() const override {
        return "Simple Coffee";
    }

    double cost() const override {
        return 2.0;
    }
};

// Decorator
class CoffeeDecorator : public Coffee {
protected:
    std::unique_ptr<Coffee> decoratedCoffee;

public:
    CoffeeDecorator(std::unique_ptr<Coffee> coffee) : decoratedCoffee(std::move(coffee)) {}

    std::string getDescription() const override {
        return decoratedCoffee->getDescription();
    }

    double cost() const override {
        return decoratedCoffee->cost();
    }
};

// ConcreteDecorator
class MilkDecorator : public CoffeeDecorator {
public:
    MilkDecorator(std::unique_ptr<Coffee> coffee) : CoffeeDecorator(std::move(coffee)) {}

    std::string getDescription() const override {
        return decoratedCoffee->getDescription() + ", Milk";
    }

    double cost() const override {
        return decoratedCoffee->cost() + 0.5;
    }
};

// ConcreteDecorator
class SugarDecorator : public CoffeeDecorator {
public:
    SugarDecorator(std::unique_ptr<Coffee> coffee) : CoffeeDecorator(std::move(coffee)) {}

    std::string getDescription() const override {
        return decoratedCoffee->getDescription() + ", Sugar";
    }

    double cost() const override {
        return decoratedCoffee->cost() + 0.3;
    }
};

int main() {
    // 기본 커피 생성
    std::unique_ptr<Coffee> myCoffee = std::make_unique<SimpleCoffee>();
    std::cout << myCoffee->getDescription() << " $" << myCoffee->cost() << std::endl;

    // 우유 추가
    myCoffee = std::make_unique<MilkDecorator>(std::move(myCoffee));
    std::cout << myCoffee->getDescription() << " $" << myCoffee->cost() << std::endl;

    // 설탕 추가
    myCoffee = std::make_unique<SugarDecorator>(std::move(myCoffee));
    std::cout << myCoffee->getDescription() << " $" << myCoffee->cost() << std::endl;
    
    // 한번에 모두 생성
		std::unique_ptr<Coffee> myCoffee2 = 
				std::make_unique<SugarDecorator>(
						std::make_unique<MilkDecorator>(
								std::make_unique<SimpleCoffee>()));
		std::cout << myCoffee2->getDescription() << " $" << myCoffee2->cost() << std::endl;
		
		return 0;
}

Simple Coffee $2
Simple Coffee, Milk $2.5
Simple Coffee, Milk, Sugar $2.8
Simple Coffee, Milk, Sugar $2.8

3. 코드 설명

1. Component: Coffee 인터페이스는 커피의 getDescription과 cost 메서드를 정의합니다.
2. ConcreteComponent: SimpleCoffee 클래스는 기본 커피의 설명과 가격을 제공합니다.
3. Decorator: CoffeeDecorator 클래스는 Coffee를 상속받아 커피를 장식하는 역할을 합니다. 이 클래스는 구성된 커피 객체를 가지고 있으며, 데코레이터 클래스는 이 객체에 추가적인 기능을 덧붙입니다.
4. ConcreteDecorator: MilkDecorator와 SugarDecorator는 CoffeeDecorator를 상속받아 우유와 설탕을 추가하는 기능을 구현합니다.

이 예제에서 커피에 우유와 설탕을 추가하면서도, 원래의 SimpleCoffee 클래스는 수정하지 않고 새로운 기능을 추가할 수 있었습니다. 이처럼 데코레이터 패턴은 객체에 기능을 동적으로 추가하는 데 매우 유용한 패턴입니다.