Structural

Flyweight Pattern Flyweight 패턴은 구조적 디자인 패턴 중 하나로, 객체를 공유하여 메모리 사용을 최소화하는 패턴이다. 플라이웨이트 패턴은 재사용 가능한 객체 인스턴스를 공유하여 메모리 사용량을 최소화하는 구조 패턴이다. 간단히 말하면 캐시 (Cache) 개념을 코드로 패턴화한 것으로, 자주 변화하는 속성 (extrinsic) 과 변하지 않는 속성 (intrinsic) 을 분리하고 변하지 않는 속성을 캐시하여 재사용함으로써 메모리 사용을 줄이는 방식이다. Flyweight 패턴의 주요 구성 요소 Flyweight: 경량 객체를 묶는 인터페이스. ConcreteFlyweight: 공유 가능하여 재사용되는 객체로, intrinsic state 를 포함한다. UnsahredConcreteFlyweight: 공유 불가능한 객체로, extrinsic state 를 포함한다. FlyweightFactory: 경량 객체를 만드는 공장 역할과 캐시 역할을 겸비하는 Flyweight 객체 관리 클래스. Client: FlyweightFactory 를 통해 Flyweight 타입의 객체를 얻어 사용한다. Flyweight 패턴의 동작 방식 FlyweightFactory 는 Flyweight 객체들을 생성하고 관리한다. GetFlyweight() 메서드는 팩토리 메서드 역할을 한다. 객체가 메모리에 존재하면 그대로 가져와 반환하고, 없다면 새로 생성해 반환한다. Flyweight 패턴의 장점 많은 객체를 만들 때 성능을 향상시킬 수 있다. 많은 객체를 만들 때 메모리를 줄일 수 있다. 메모리 절약: 대규모 객체 시스템에서 상당한 메모리 절감 효과를 얻을 수 있다. 중복 최소화: 공유를 통해 객체의 중복 생성을 방지한다. Flyweight 패턴의 단점 특정 인스턴스를 다르게 처리하는 것이 힘들어진다. 코드 복잡성 증가: 객체를 공유하는 방식은 구현을 복잡하게 만들 수 있다. 런타임 비용: 객체 상태를 관리하는 데 런타임 비용이 발생할 수 있다. Flyweight 패턴의 사용 시기 대량의 작은 객체를 생성해야 할 때 유용하다. 객체의 상태를 자주 변하는 속성 (Extrinsic) 과 변하지 않는 속성 (Intrinsic) 으로 분리할 수 있을 때 적합하다. 공통된 내재 상태를 공유함으로써 메모리 사용을 줄일 수 있을 때 사용한다. 구현 예시 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 from typing import Dict # Flyweight 클래스: 공유될 객체의 내부 상태를 정의 class CharacterStyle: def __init__(self, font_name: str, font_size: int, bold: bool): self.font_name = font_name self.font_size = font_size self.bold = bold def render(self, char: str, position: tuple) -> None: print(f"Rendering '{char}' at {position} with {self.font_name}, " f"size {self.font_size}, {'bold' if self.bold else 'normal'}") # Flyweight 팩토리: Flyweight 객체들을 관리하고 공유 class CharacterStyleFactory: def __init__(self): self._styles: Dict[str, CharacterStyle] = {} def get_style(self, font_name: str, font_size: int, bold: bool) -> CharacterStyle: # 스타일을 식별하기 위한 키 생성 key = f"{font_name}-{font_size}-{bold}" # 스타일이 존재하지 않으면 새로 생성 if key not in self._styles: self._styles[key] = CharacterStyle(font_name, font_size, bold) print(f"Creating new style: {key}") return self._styles[key] def get_style_count(self) -> int: return len(self._styles) # 문자 객체: Flyweight를 사용하는 클래스 class Character: def __init__(self, char: str, style: CharacterStyle, position: tuple): self.char = char # 외부 상태 (extrinsic state) self.style = style # 공유 상태 (intrinsic state) self.position = position # 외부 상태 def render(self) -> None: self.style.render(self.char, self.position) 실제 사용 예시 ...

Composite Pattern Composite Pattern 은 구조적 디자인 패턴 중 하나로, 객체들을 트리 구조로 구성하여 부분 - 전체 계층을 표현하는 패턴이다. Composite Pattern 은 객체들을 트리 구조로 구성하여 부분과 전체를 나타내는 계층 구조를 만든다. 이 패턴을 사용하면 클라이언트가 개별 객체와 복합 객체를 동일하게 다룰 수 있다. Composite Pattern 은 복잡한 트리 구조를 간단하게 다룰 수 있게 해주는 강력한 도구이다. 하지만 모든 상황에 적합한 것은 아니므로, 프로젝트의 요구사항과 구조를 고려하여 적절히 사용해야 한다. ...

Decorator Pattern 객체에 동적으로 새로운 책임을 추가할 수 있게 해주는 구조적 디자인 패턴 " 래퍼 (wrapper)" 개념으로 각 데코레이터는 원본 객체를 감싸면서 추가 기능을 제공한다. 여러 데코레이터를 겹겹이 쌓을 수 있으며, 각 계층은 이전 계층의 기능을 확장한다. 특징 기존 객체의 코드를 수정하지 않고 새로운 기능을 추가할 수 있습니다. 상속 대신 구성 (composition) 을 사용하여 객체의 기능을 확장합니다. 객체를 여러 데코레이터로 감싸 기능을 조합할 수 있습니다. 사용사례 파일 입출력 시스템에서 압축, 암호화, 버퍼링 등의 기능을 조합할 때 웹 서비스에서 로깅, 캐싱, 인증 등의 기능을 동적으로 추가할 때 GUI 컴포넌트에 테두리, 스크롤바, 색상 등의 시각적 요소를 조합할 때 게임 캐릭터에 아이템, 버프, 상태 효과 등을 적용할 때 장점 객체의 기능을 동적으로 확장할 수 있어 매우 유연합니다. 단일 책임 원칙을 지키면서 기능을 조합할 수 있습니다. 상속을 통한 확장보다 더 유연한 방식을 제공합니다. 런타임에 객체의 행동을 변경할 수 있습니다. 단점 데코레이터를 너무 많이 사용하면 코드가 복잡해질 수 있습니다. 데코레이터들의 순서가 결과에 영향을 미칠 수 있어 주의가 필요합니다. 작은 객체들이 많이 생성되어 코드를 이해하기 어려울 수 있습니다. 주의사항 및 고려사항 데코레이터의 순서를 신중하게 고려해야 합니다. 예를 들어, 텍스트 처리에서 HTML 이스케이프를 마크다운 변환 전에 하면 원하는 결과를 얻을 수 없습니다. 데코레이터 체인이 너무 길어지지 않도록 주의해야 합니다. 필요한 경우 자주 사용되는 조합을 별도의 클래스로 만드는 것을 고려하세요. 데코레이터들 간의 상호작용을 고려해야 합니다. 한 데코레이터의 출력이 다른 데코레이터의 입력으로 적절한지 확인해야 합니다. 성능에 민감한 상황에서는 데코레이터 체인으로 인한 오버헤드를 고려해야 합니다. 디버깅이 어려울 수 있으므로, 로깅이나 모니터링 기능을 추가하는 것이 좋습니다. 예시 Python 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 from abc import ABC, abstractmethod from typing import List # Component interface class Coffee(ABC): """Base Coffee interface""" @abstractmethod def get_cost(self) -> float: pass @abstractmethod def get_ingredients(self) -> List[str]: pass @abstractmethod def get_description(self) -> str: pass # Concrete component class SimpleCoffee(Coffee): """Basic coffee implementation""" def get_cost(self) -> float: return 2.0 def get_ingredients(self) -> List[str]: return ["Coffee"] def get_description(self) -> str: return "Simple coffee" # Base decorator class CoffeeDecorator(Coffee): """Base decorator class""" def __init__(self, coffee: Coffee): self._coffee = coffee def get_cost(self) -> float: return self._coffee.get_cost() def get_ingredients(self) -> List[str]: return self._coffee.get_ingredients() def get_description(self) -> str: return self._coffee.get_description() # Concrete decorators class MilkDecorator(CoffeeDecorator): """Adds milk to the coffee""" def get_cost(self) -> float: return super().get_cost() + 0.5 def get_ingredients(self) -> List[str]: return super().get_ingredients() + ["Milk"] def get_description(self) -> str: return f"{super().get_description()}, with steamed milk" class WhipDecorator(CoffeeDecorator): """Adds whipped cream to the coffee""" def get_cost(self) -> float: return super().get_cost() + 0.7 def get_ingredients(self) -> List[str]: return super().get_ingredients() + ["Whipped Cream"] def get_description(self) -> str: return f"{super().get_description()}, topped with whipped cream" class CaramelDecorator(CoffeeDecorator): """Adds caramel to the coffee""" def get_cost(self) -> float: return super().get_cost() + 0.6 def get_ingredients(self) -> List[str]: return super().get_ingredients() + ["Caramel"] def get_description(self) -> str: return f"{super().get_description()}, drizzled with caramel" class ExtraShotDecorator(CoffeeDecorator): """Adds an extra shot of espresso""" def get_cost(self) -> float: return super().get_cost() + 1.0 def get_ingredients(self) -> List[str]: return super().get_ingredients() + ["Extra Espresso Shot"] def get_description(self) -> str: return f"{super().get_description()}, with an extra shot" # Order management class CoffeeOrder: """Manages coffee orders and provides order summary""" def __init__(self): self.coffee = None def create_order(self) -> None: """Creates a new coffee order starting with simple coffee""" self.coffee = SimpleCoffee() def add_milk(self) -> None: self.coffee = MilkDecorator(self.coffee) def add_whip(self) -> None: self.coffee = WhipDecorator(self.coffee) def add_caramel(self) -> None: self.coffee = CaramelDecorator(self.coffee) def add_extra_shot(self) -> None: self.coffee = ExtraShotDecorator(self.coffee) def get_order_summary(self) -> str: """Generates a summary of the current order""" return f""" Order Summary: Description: {self.coffee.get_description()} Ingredients: {', '.join(self.coffee.get_ingredients())} Total Cost: ${self.coffee.get_cost():f} """ # Usage example if __name__ == "__main__": # Create a new order order = CoffeeOrder() order.create_order() # Customize the coffee with various additions order.add_milk() order.add_extra_shot() order.add_whip() order.add_caramel() # Print the order summary print(order.get_order_summary()) Javascript 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 // Component interface class TextProcessor { constructor() { if (this.constructor === TextProcessor) { throw new Error("Abstract class cannot be instantiated"); } } process(text) { throw new Error("Method 'process' must be implemented"); } } // Concrete component class SimpleTextProcessor extends TextProcessor { process(text) { return text; } } // Base decorator class TextProcessorDecorator extends TextProcessor { constructor(processor) { super(); this._processor = processor; } process(text) { return this._processor.process(text); } } // Concrete decorators class CapitalizeDecorator extends TextProcessorDecorator { process(text) { const processedText = this._processor.process(text); return processedText.toUpperCase(); } } class TrimDecorator extends TextProcessorDecorator { process(text) { const processedText = this._processor.process(text); return processedText.trim(); } } class HTMLEscapeDecorator extends TextProcessorDecorator { process(text) { const processedText = this._processor.process(text); return processedText .replace(/&/g, "&amp;") .replace(/</g, "&lt;") .replace(/>/g, "&gt;") .replace(/"/g, "&quot;") .replace(/'/g, "&#039;"); } } class MarkdownToHTMLDecorator extends TextProcessorDecorator { process(text) { const processedText = this._processor.process(text); return processedText .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>') .replace(/\*(.*?)\*/g, '<em>$1</em>') .replace(/\[(.*?)\]\((.*?)\)/g, '<a href="$2">$1</a>') .replace(/^# (.*$)/gm, '<h1>$1</h1>') .replace(/^## (.*$)/gm, '<h2>$1</h2>'); } } class ValidationDecorator extends TextProcessorDecorator { constructor(processor, maxLength = 1000) { super(processor); this.maxLength = maxLength; } process(text) { if (!text) { throw new Error("Text cannot be empty"); } if (text.length > this.maxLength) { throw new Error(`Text length exceeds maximum limit of ${this.maxLength} characters`); } return this._processor.process(text); } } // Text processing manager class TextProcessingManager { constructor() { this.processor = new SimpleTextProcessor(); this.history = []; } addCapitalization() { this.processor = new CapitalizeDecorator(this.processor); return this; } addTrimming() { this.processor = new TrimDecorator(this.processor); return this; } addHTMLEscaping() { this.processor = new HTMLEscapeDecorator(this.processor); return this; } addMarkdownProcessing() { this.processor = new MarkdownToHTMLDecorator(this.processor); return this; } addValidation(maxLength) { this.processor = new ValidationDecorator(this.processor, maxLength); return this; } process(text) { const result = this.processor.process(text); this.history.push({ input: text, output: result, timestamp: new Date() }); return result; } getProcessingHistory() { return this.history; } } // Usage example const manager = new TextProcessingManager(); // Configure text processing chain manager .addValidation(2000) .addTrimming() .addMarkdownProcessing() .addHTMLEscaping(); // Process some text try { const input = ` # Welcome to Text Processing This is a **bold** and *italic* text example. [Click here](https://example.com) to learn more. `; const result = manager.process(input); console.log("Processed text:"); console.log(result); console.log("\nProcessing history:"); console.log(manager.getProcessingHistory()); } catch (error) { console.error("Error processing text:", error.message); } 용어 정리 용어 설명 참고 및 출처 1. 주제의 분류가 적절한지에 대해 조사 Decorator Pattern(데코레이터 패턴) 은 “Computer Science and Engineering > Software Design and Architecture > Software Design Patterns > GoF > Structural Design Patterns” 분류에 정확히 해당합니다. GoF(Gang of Four) 에서 정의한 구조 (Structural) 패턴 중 하나로, 객체의 기능 확장에 특화된 패턴입니다 [1][2][20]. ...

Adapter Pattern 호환되지 않는 인터페이스를 가진 객체들이 협력할 수 있도록 하는 구조적 디자인 패턴 한국의 220V 전기 제품을 미국에서 사용하기 위해 변환 어댑터를 사용하듯이, 소프트웨어에서도 호환되지 않는 인터페이스들을 함께 작동하도록 만들어주는 것이 어댑터 패턴의 핵심 특징 기존 클래스의 인터페이스를 클라이언트가 기대하는 다른 인터페이스로 변환합니다. 호환성이 없는 인터페이스 때문에 함께 동작할 수 없는 클래스들이 협력할 수 있게 합니다. ‘Wrapper’라고도 불립니다. 사용사례 레거시 시스템과 새로운 시스템을 통합할 때 서드파티 라이브러리를 사용할 때 기존 코드의 수정을 최소화하고 싶은 경우 여러 데이터 포맷을 처리해야 하는 경우 외부 API를 내부 시스템에 통합할 때 장점 기존 코드를 변경하지 않고도 새로운 기능을 추가할 수 있습니다 단일 책임 원칙을 지키면서 코드의 재사용성을 높일 수 있습니다 클래스 간의 결합도를 낮출 수 있습니다 기존 코드와 새로운 코드를 깔끔하게 분리할 수 있습니다 단점 새로운 클래스와 인터페이스가 추가되어 복잡도가 증가할 수 있습니다 때로는 많은 어댑터 클래스를 작성해야 할 수 있습니다 모든 요청이 어댑터를 통과해야 하므로 약간의 오버헤드가 발생할 수 있습니다 주의사항 및 고려사항 어댑터의 책임 범위를 명확히 해야 합니다. 어댑터는 단순히 인터페이스를 변환하는 역할만 해야 하며, 비즈니스 로직을 포함해서는 안 됩니다. 어댑터 패턴을 적용하기 전에 정말로 필요한지 검토해야 합니다. 때로는 기존 코드를 리팩터링하는 것이 더 나은 해결책일 수 있습니다. 어댑터가 처리하는 데이터 변환 과정에서 발생할 수 있는 예외 상황들을 적절히 처리해야 합니다. 양방향 어댑터를 만들 때는 순환 참조가 발생하지 않도록 주의해야 합니다. 성능에 민감한 부분에서는 어댑터로 인한 추가적인 메서드 호출이 성능에 영향을 미칠 수 있음을 고려해야 합니다. 예시 Python 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 from abc import ABC, abstractmethod from typing import Dict # Target Interface class PaymentProcessor(ABC): @abstractmethod def process_payment(self, amount: float) -> bool: pass @abstractmethod def refund_payment(self, amount: float) -> bool: pass # Existing payment system (Adaptee) class StripePaymentSystem: def __init__(self, api_key: str): self.api_key = api_key def create_charge(self, amount: float, currency: str = "USD") -> Dict: # Simulate Stripe API call print(f"Stripe: Charging ${amount} using API key {self.api_key}") return {"success": True, "transaction_id": "str_123", "amount": amount} def create_refund(self, transaction_id: str) -> Dict: # Simulate Stripe API call print(f"Stripe: Refunding transaction {transaction_id}") return {"success": True, "refund_id": "ref_123"} # Another existing payment system (Adaptee) class PayPalAPI: def __init__(self, client_id: str): self.client_id = client_id def submit_payment(self, amount: float) -> Dict: # Simulate PayPal API call print(f"PayPal: Processing payment of ${amount} with client ID {self.client_id}") return {"status": "SUCCESS", "payment_id": "PAY123"} def reverse_payment(self, payment_id: str) -> Dict: # Simulate PayPal API call print(f"PayPal: Reversing payment {payment_id}") return {"status": "SUCCESS"} # Adapter for Stripe class StripeAdapter(PaymentProcessor): def __init__(self, stripe_processor: StripePaymentSystem): self.stripe = stripe_processor self.transaction_records = {} def process_payment(self, amount: float) -> bool: result = self.stripe.create_charge(amount) if result["success"]: self.transaction_records[amount] = result["transaction_id"] return True return False def refund_payment(self, amount: float) -> bool: transaction_id = self.transaction_records.get(amount) if not transaction_id: return False result = self.stripe.create_refund(transaction_id) return result["success"] # Adapter for PayPal class PayPalAdapter(PaymentProcessor): def __init__(self, paypal_processor: PayPalAPI): self.paypal = paypal_processor self.payment_records = {} def process_payment(self, amount: float) -> bool: result = self.paypal.submit_payment(amount) if result["status"] == "SUCCESS": self.payment_records[amount] = result["payment_id"] return True return False def refund_payment(self, amount: float) -> bool: payment_id = self.payment_records.get(amount) if not payment_id: return False result = self.paypal.reverse_payment(payment_id) return result["status"] == "SUCCESS" # Client code def process_order(processor: PaymentProcessor, amount: float): """Process an order using any payment processor""" if processor.process_payment(amount): print(f"Successfully processed payment of ${amount}") return True print(f"Failed to process payment of ${amount}") return False # Usage example if __name__ == "__main__": # Create payment processors stripe_processor = StripePaymentSystem(api_key="sk_test_123") paypal_processor = PayPalAPI(client_id="client_123") # Create adapters stripe_adapter = StripeAdapter(stripe_processor) paypal_adapter = PayPalAdapter(paypal_processor) # Process payments using different processors process_order(stripe_adapter, 100.00) process_order(paypal_adapter, 50.00) # Test refunds stripe_adapter.refund_payment(100.00) paypal_adapter.refund_payment(50.00) Javascript 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 // Target interface (what the client expects) class DataAnalyzer { analyze(data) { throw new Error('analyze method must be implemented'); } getReport() { throw new Error('getReport method must be implemented'); } } // Existing CSV data processor (Adaptee) class CSVProcessor { constructor() { this.data = null; } loadCSV(csvData) { // Simulate processing CSV data console.log('Processing CSV data…'); this.data = csvData.split('\n').map(row => row.split(',')); return true; } generateStats() { if (!this.data) return null; // Simulate generating statistics return { rowCount: this.data.length, columnCount: this.data[0].length, format: 'CSV' }; } } // Existing JSON data processor (Adaptee) class JSONProcessor { constructor() { this.jsonData = null; } parseJSON(jsonString) { // Simulate parsing JSON data console.log('Parsing JSON data…'); this.jsonData = JSON.parse(jsonString); return { success: true, timestamp: new Date() }; } calculateMetrics() { if (!this.jsonData) return null; // Simulate calculating metrics return { size: JSON.stringify(this.jsonData).length, type: 'JSON', keys: Object.keys(this.jsonData) }; } } // Adapter for CSV Processor class CSVAdapter extends DataAnalyzer { constructor(csvProcessor) { super(); this.processor = csvProcessor; this.analysis = null; } analyze(data) { const success = this.processor.loadCSV(data); if (success) { this.analysis = this.processor.generateStats(); return true; } return false; } getReport() { if (!this.analysis) return null; return { type: 'CSV Analysis', entries: this.analysis.rowCount, fields: this.analysis.columnCount, format: this.analysis.format, timestamp: new Date() }; } } // Adapter for JSON Processor class JSONAdapter extends DataAnalyzer { constructor(jsonProcessor) { super(); this.processor = jsonProcessor; this.analysis = null; } analyze(data) { const result = this.processor.parseJSON(data); if (result.success) { this.analysis = this.processor.calculateMetrics(); return true; } return false; } getReport() { if (!this.analysis) return null; return { type: 'JSON Analysis', dataSize: this.analysis.size, format: this.analysis.type, availableFields: this.analysis.keys, timestamp: new Date() }; } } // Client code class DataAnalysisService { constructor(analyzer) { this.analyzer = analyzer; } processData(data) { if (this.analyzer.analyze(data)) { const report = this.analyzer.getReport(); console.log('Analysis Report:', report); return report; } console.log('Analysis failed'); return null; } } // Usage example const csvData = 'name,age,city\nJohn,New York\nJane,Boston'; const jsonData = JSON.stringify({ users: [ { name: 'John', age: 30, city: 'New York' }, { name: 'Jane', age: 25, city: 'Boston' } ] }); // Create processors and adapters const csvProcessor = new CSVProcessor(); const jsonProcessor = new JSONProcessor(); const csvAdapter = new CSVAdapter(csvProcessor); const jsonAdapter = new JSONAdapter(jsonProcessor); // Analyze both types of data using the same interface const analysisService = new DataAnalysisService(csvAdapter); analysisService.processData(csvData); const jsonAnalysisService = new DataAnalysisService(jsonAdapter); jsonAnalysisService.processData(jsonData); 용어 정리 용어 설명 참고 및 출처 1. 주제의 분류가 적절한지에 대해 조사 Adapter Pattern(어댑터 패턴)은 “Computer Science and Engineering > Software Design and Architecture > Software Design Patterns > GoF > Structural Design Patterns” 분류에 정확하게 해당합니다. GoF(Gang of Four)에서 정의한 23가지 디자인 패턴 중 구조(Structural) 패턴에 속하며, 호환되지 않는 인터페이스를 연결하는 데 중점을 둡니다[1][2][6]. ...