🎨 데코레이터 패턴 완전 정복: 실무에서 활용하는 구조적 디자인 패턴

🤔 데코레이터 패턴이란?

데코레이터 패턴(Decorator Pattern)은 객체의 구조를 변경하지 않고 새로운 기능을 동적으로 추가할 수 있는 구조적 디자인 패턴입니다. 기존 객체를 감싸는 래퍼(wrapper) 객체를 통해 기능을 확장하는 방식으로 동작합니다.

🏗️ 데코레이터 패턴의 핵심 개념

📋 주요 구성 요소

• Component: 기본 인터페이스 또는 추상 클래스
• ConcreteComponent: 기본 구현체
• Decorator: 데코레이터 기본 클래스
• ConcreteDecorator: 구체적인 데코레이터 구현체

✅ 장점

• 런타임에 객체의 기능을 동적으로 확장 가능
• 상속보다 유연한 기능 확장
• 단일 책임 원칙 준수
• 기능의 조합이 자유로움

⚠️ 단점

• 작은 객체들이 많이 생성될 수 있음
• 디버깅이 복잡해질 수 있음
• 객체 식별이 어려울 수 있음

💻 실무 예제 코드

1. ☕ Java 예제 - 회사 시스템

// Component 인터페이스
interface Company {
    String getDescription();
    double getRevenue();
}

// ConcreteComponent
class BasicCompany implements Company {
    private String name;
    private double baseRevenue;
    
    public BasicCompany(String name, double baseRevenue) {
        this.name = name;
        this.baseRevenue = baseRevenue;
    }
    
    @Override
    public String getDescription() {
        return name;
    }
    
    @Override
    public double getRevenue() {
        return baseRevenue;
    }
}

// Decorator 추상 클래스
abstract class CompanyDecorator implements Company {
    protected Company company;
    
    public CompanyDecorator(Company company) {
        this.company = company;
    }
    
    @Override
    public String getDescription() {
        return company.getDescription();
    }
    
    @Override
    public double getRevenue() {
        return company.getRevenue();
    }
}

// ConcreteDecorator들
class TechDivision extends CompanyDecorator {
    public TechDivision(Company company) {
        super(company);
    }
    
    @Override
    public String getDescription() {
        return company.getDescription() + " + 기술 사업부";
    }
    
    @Override
    public double getRevenue() {
        return company.getRevenue() + 5000000;
    }
}

class MarketingDivision extends CompanyDecorator {
    public MarketingDivision(Company company) {
        super(company);
    }
    
    @Override
    public String getDescription() {
        return company.getDescription() + " + 마케팅 사업부";
    }
    
    @Override
    public double getRevenue() {
        return company.getRevenue() + 3000000;
    }
}

class GlobalExpansion extends CompanyDecorator {
    public GlobalExpansion(Company company) {
        super(company);
    }
    
    @Override
    public String getDescription() {
        return company.getDescription() + " + 글로벌 사업";
    }
    
    @Override
    public double getRevenue() {
        return company.getRevenue() * 1.5;
    }
}

// 사용 예제
public class CompanyExample {
    public static void main(String[] args) {
        // 기본 회사
        Company basicCompany = new BasicCompany("테크스타트", 10000000);
        System.out.println(basicCompany.getDescription() + " - 매출: " + basicCompany.getRevenue());
        
        // 기술 사업부 추가
        Company techCompany = new TechDivision(basicCompany);
        System.out.println(techCompany.getDescription() + " - 매출: " + techCompany.getRevenue());
        
        // 마케팅 사업부도 추가
        Company fullCompany = new MarketingDivision(techCompany);
        System.out.println(fullCompany.getDescription() + " - 매출: " + fullCompany.getRevenue());
        
        // 글로벌 사업 확장
        Company globalCompany = new GlobalExpansion(fullCompany);
        System.out.println(globalCompany.getDescription() + " - 매출: " + globalCompany.getRevenue());
    }
}

2. 🟦 TypeScript 예제 - 직원 시스템

// Component 인터페이스
interface Employee {
    getName(): string;
    getSalary(): number;
    getRole(): string;
}

// ConcreteComponent
class BasicEmployee implements Employee {
    private name: string;
    private baseSalary: number;
    
    constructor(name: string, baseSalary: number) {
        this.name = name;
        this.baseSalary = baseSalary;
    }
    
    getName(): string {
        return this.name;
    }
    
    getSalary(): number {
        return this.baseSalary;
    }
    
    getRole(): string {
        return "일반 직원";
    }
}

// Decorator 추상 클래스
abstract class EmployeeDecorator implements Employee {
    protected employee: Employee;
    
    constructor(employee: Employee) {
        this.employee = employee;
    }
    
    getName(): string {
        return this.employee.getName();
    }
    
    getSalary(): number {
        return this.employee.getSalary();
    }
    
    getRole(): string {
        return this.employee.getRole();
    }
}

// ConcreteDecorator들
class TeamLeader extends EmployeeDecorator {
    constructor(employee: Employee) {
        super(employee);
    }
    
    getRole(): string {
        return this.employee.getRole() + " + 팀 리더";
    }
    
    getSalary(): number {
        return this.employee.getSalary() + 500000;
    }
}

class ProjectManager extends EmployeeDecorator {
    constructor(employee: Employee) {
        super(employee);
    }
    
    getRole(): string {
        return this.employee.getRole() + " + 프로젝트 매니저";
    }
    
    getSalary(): number {
        return this.employee.getSalary() + 800000;
    }
}

class SeniorDeveloper extends EmployeeDecorator {
    constructor(employee: Employee) {
        super(employee);
    }
    
    getRole(): string {
        return this.employee.getRole() + " + 시니어 개발자";
    }
    
    getSalary(): number {
        return this.employee.getSalary() + 1000000;
    }
}

class Certification extends EmployeeDecorator {
    private certName: string;
    
    constructor(employee: Employee, certName: string) {
        super(employee);
        this.certName = certName;
    }
    
    getRole(): string {
        return this.employee.getRole() + ` + ${this.certName} 자격증`;
    }
    
    getSalary(): number {
        return this.employee.getSalary() + 200000;
    }
}

// 사용 예제
const basicEmployee = new BasicEmployee("김개발", 4000000);
console.log(`${basicEmployee.getName()} - ${basicEmployee.getRole()} - 급여: ${basicEmployee.getSalary()}`);

const teamLeader = new TeamLeader(basicEmployee);
console.log(`${teamLeader.getName()} - ${teamLeader.getRole()} - 급여: ${teamLeader.getSalary()}`);

const seniorTeamLeader = new SeniorDeveloper(teamLeader);
console.log(`${seniorTeamLeader.getName()} - ${seniorTeamLeader.getRole()} - 급여: ${seniorTeamLeader.getSalary()}`);

const certifiedSeniorTeamLeader = new Certification(seniorTeamLeader, "AWS");
console.log(`${certifiedSeniorTeamLeader.getName()} - ${certifiedSeniorTeamLeader.getRole()} - 급여: ${certifiedSeniorTeamLeader.getSalary()}`);

const projectManagerRole = new ProjectManager(certifiedSeniorTeamLeader);
console.log(`${projectManagerRole.getName()} - ${projectManagerRole.getRole()} - 급여: ${projectManagerRole.getSalary()}`);

3. 🐍 Python 예제 - 동물 시스템

from abc import ABC, abstractmethod

# Component 인터페이스
class Animal(ABC):
    @abstractmethod
    def get_description(self) -> str:
        pass
    
    @abstractmethod
    def get_abilities(self) -> list:
        pass
    
    @abstractmethod
    def get_power_level(self) -> int:
        pass

# ConcreteComponent
class BasicAnimal(Animal):
    def __init__(self, name: str, species: str, base_power: int):
        self.name = name
        self.species = species
        self.base_power = base_power
    
    def get_description(self) -> str:
        return f"{self.name} ({self.species})"
    
    def get_abilities(self) -> list:
        return ["기본 생존 능력"]
    
    def get_power_level(self) -> int:
        return self.base_power

# Decorator 추상 클래스
class AnimalDecorator(Animal):
    def __init__(self, animal: Animal):
        self._animal = animal
    
    def get_description(self) -> str:
        return self._animal.get_description()
    
    def get_abilities(self) -> list:
        return self._animal.get_abilities()
    
    def get_power_level(self) -> int:
        return self._animal.get_power_level()

# ConcreteDecorator들
class FlyingAbility(AnimalDecorator):
    def get_description(self) -> str:
        return self._animal.get_description() + " + 비행 능력"
    
    def get_abilities(self) -> list:
        abilities = self._animal.get_abilities().copy()
        abilities.append("비행")
        return abilities
    
    def get_power_level(self) -> int:
        return self._animal.get_power_level() + 30

class SwimmingAbility(AnimalDecorator):
    def get_description(self) -> str:
        return self._animal.get_description() + " + 수영 능력"
    
    def get_abilities(self) -> list:
        abilities = self._animal.get_abilities().copy()
        abilities.append("수영")
        return abilities
    
    def get_power_level(self) -> int:
        return self._animal.get_power_level() + 20

class PoisonousAbility(AnimalDecorator):
    def get_description(self) -> str:
        return self._animal.get_description() + " + 독성 능력"
    
    def get_abilities(self) -> list:
        abilities = self._animal.get_abilities().copy()
        abilities.append("독성 공격")
        return abilities
    
    def get_power_level(self) -> int:
        return self._animal.get_power_level() + 50

class CamouflageAbility(AnimalDecorator):
    def get_description(self) -> str:
        return self._animal.get_description() + " + 위장 능력"
    
    def get_abilities(self) -> list:
        abilities = self._animal.get_abilities().copy()
        abilities.append("위장")
        return abilities
    
    def get_power_level(self) -> int:
        return self._animal.get_power_level() + 25

class SuperStrength(AnimalDecorator):
    def get_description(self) -> str:
        return self._animal.get_description() + " + 초강력"
    
    def get_abilities(self) -> list:
        abilities = self._animal.get_abilities().copy()
        abilities.append("초강력 힘")
        return abilities
    
    def get_power_level(self) -> int:
        return self._animal.get_power_level() * 2

# 사용 예제
def print_animal_info(animal: Animal):
    print(f"🦁 {animal.get_description()}")
    print(f"💪 능력: {', '.join(animal.get_abilities())}")
    print(f"⚡ 파워 레벨: {animal.get_power_level()}")
    print("-" * 50)

# 기본 동물들
tiger = BasicAnimal("호랑이", "맹수", 80)
print_animal_info(tiger)

eagle = BasicAnimal("독수리", "맹금류", 60)
print_animal_info(eagle)

snake = BasicAnimal("뱀", "파충류", 40)
print_animal_info(snake)

# 능력 강화
flying_tiger = FlyingAbility(tiger)
print_animal_info(flying_tiger)

swimming_flying_tiger = SwimmingAbility(flying_tiger)
print_animal_info(swimming_flying_tiger)

super_swimming_flying_tiger = SuperStrength(swimming_flying_tiger)
print_animal_info(super_swimming_flying_tiger)

# 독수리 강화
camouflage_eagle = CamouflageAbility(eagle)
super_camouflage_eagle = SuperStrength(camouflage_eagle)
print_animal_info(super_camouflage_eagle)

# 뱀 강화
poisonous_snake = PoisonousAbility(snake)
camouflage_poisonous_snake = CamouflageAbility(poisonous_snake)
swimming_camouflage_poisonous_snake = SwimmingAbility(camouflage_poisonous_snake)
print_animal_info(swimming_camouflage_poisonous_snake)

🔄 실제 사용 사례

📱 UI 컴포넌트 시스템

• 기본 버튼에 아이콘, 로딩 스피너, 툴팁 등을 동적으로 추가
• 각 기능을 독립적으로 조합 가능

🌐 미들웨어 시스템

• HTTP 요청에 인증, 로깅, 캐싱, 압축 등의 기능을 계층적으로 추가
• Express.js, Spring Boot의 미들웨어 체인

💾 데이터 스트림 처리

• 기본 데이터 스트림에 암호화, 압축, 버퍼링 등을 추가
• Java의 InputStream/OutputStream 클래스들

🎮 게임 개발

• 캐릭터에 무기, 방어구, 스킬, 버프 등을 동적으로 장착
• 아이템 조합 시스템

🤝 다른 패턴과의 비교

📊 데코레이터 vs 상속

• 상속: 컴파일 타임에 고정, 단일 확장만 가능
• 데코레이터: 런타임에 동적, 다중 기능 조합 가능

🔧 데코레이터 vs 어댑터

• 어댑터: 호환되지 않는 인터페이스를 연결
• 데코레이터: 동일한 인터페이스에 기능 추가

🏗️ 데코레이터 vs 컴포지트

• 컴포지트: 트리 구조의 객체 관계 표현
• 데코레이터: 선형적인 기능 확장

📝 베스트 프랙티스

✨ 효과적인 사용법

1. 단일 책임 원칙: 각 데코레이터는 하나의 기능만 담당
2. 인터페이스 일관성: 모든 데코레이터는 같은 인터페이스 구현
3. 순서 독립성: 데코레이터의 적용 순서가 결과에 영향을 주지 않도록 설계
4. 성능 고려: 너무 많은 데코레이터 체인은 성능 저하 가능

🚫 피해야 할 것들

• 복잡한 데코레이터 체인으로 인한 디버깅 어려움
• 데코레이터 간의 강한 의존성
• 인터페이스 일관성 깨뜨리기

🎯 마무리

데코레이터 패턴은 객체의 기능을 유연하게 확장할 수 있는 강력한 디자인 패턴입니다. 상속의 한계를 극복하고 런타임에 동적으로 기능을 조합할 수 있어 현대 소프트웨어 개발에서 매우 유용합니다. 특히 마이크로서비스 아키텍처, 미들웨어 시스템, UI 컴포넌트 라이브러리 등에서 광범위하게 활용되고 있습니다.

핵심은 **"기능의 조합을 통한 확장"**이라는 개념을 이해하고, 각 언어의 특성에 맞게 적절히 구현하는 것입니다. 위의 예제들을 참고하여 여러분의 프로젝트에 데코레이터 패턴을 적용해보세요! 🚀

---