Facade Pattern

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class PaymentGateway:
    def process(self, amount):
        print(f"[PG] 결제 처리: {amount}원")

class PaymentFacade:
    def __init__(self):
        self.gateway = PaymentGateway()

    def pay(self, amount):
        self.gateway.process(amount)

# 클라이언트
facade = PaymentFacade()
facade.pay(10000)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Inventory:
    def reserve(self, item): print(f"[Inventory] {item} 예약 완료")

class Payment:
    def charge(self, amount): print(f"[Payment] {amount}원 결제 성공")

class Shipping:
    def deliver(self, address): print(f"[Shipping] {address}로 배송 시작")

class OrderFacade:
    def __init__(self):
        self.inventory = Inventory()
        self.payment = Payment()
        self.shipping = Shipping()

    def process_order(self, item, amount, address):
        self.inventory.reserve(item)
        self.payment.charge(amount)
        self.shipping.deliver(address)

# 클라이언트
facade = OrderFacade()
facade.process_order("노트북", 2000000, "서울시 강남구")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class PayPal:
    def pay(self, dollars): print(f"[PayPal] ${dollars} 결제")

class CreditCard:
    def charge_krw(self, amount): print(f"[CreditCard] {amount}원 결제")

# 어댑터
class PayPalAdapter:
    def process(self, amount): PayPal().pay(amount / 1300)

class CreditCardAdapter:
    def process(self, amount): CreditCard().charge_krw(amount)

class PaymentFacade:
    def __init__(self, adapter):
        self.adapter = adapter

    def pay(self, amount):
        self.adapter.process(amount)

# 클라이언트
facade = PaymentFacade(PayPalAdapter())
facade.pay(130000)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class UserService:
    def get_profile(self, user_id):
        print(f"[UserService] 사용자 정보 조회: {user_id}")
        return {"name": "현윤", "id": user_id}

class UserFacade:
    def __init__(self):
        self.service = UserService()
        self.cache = {}

    def get_user(self, user_id):
        if user_id in self.cache:
            print("[Cache] 캐시에서 사용자 정보 반환")
            return self.cache[user_id]
        print("[Log] 사용자 정보 요청 로그 기록")
        result = self.service.get_profile(user_id)
        self.cache[user_id] = result
        return result

# 클라이언트
facade = UserFacade()
facade.get_user("user-123")
facade.get_user("user-123")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class CodecFactory:
    @staticmethod
    def create(filetype):
        if filetype == 'mp4': return "H"
        if filetype == 'avi': return "MPEG-4"
        return "Unknown"

class VideoProcessor:
    def __init__(self, codec): self.codec = codec
    def process(self, file): print(f"[VideoProcessor] {self.codec}로 {file} 처리")

class MediaFacade:
    def process_video(self, filename):
        filetype = filename.split('.')[-1]
        codec = CodecFactory.create(filetype)
        processor = VideoProcessor(codec)
        processor.process(filename)

# 클라이언트
facade = MediaFacade()
facade.process_video("movie.mp4")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class DataAccessLayer:
    def fetch_user(self): return {"id": "A1", "name": "현윤"}

class BusinessLogicLayer:
    def __init__(self): self.data = DataAccessLayer()
    def get_user_display(self):
        user = self.data.fetch_user()
        return f"사용자 이름: {user['name']}"

class PresentationLayer:
    def __init__(self): self.logic = BusinessLogicLayer()
    def render(self): print(self.logic.get_user_display())

# 클라이언트
facade = PresentationLayer()
facade.render()

 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

# 서브시스템 클래스들
class PayPal:
    def pay(self, amount):
        print(f"PayPal 결제 처리: {amount}원")

class KakaoPay:
    def charge(self, amount):
        print(f"KakaoPay 결제 처리: {amount}원")

class Stripe:
    def process(self, amount):
        print(f"Stripe 결제 처리: {amount}원")

# Facade 클래스
class PaymentFacade:
    def __init__(self):
        self.paypal = PayPal()
        self.kakao = KakaoPay()
        self.stripe = Stripe()

    def pay_all(self, amount):
        self.paypal.pay(amount)
        self.kakao.charge(amount)
        self.stripe.process(amount)

# 클라이언트
facade = PaymentFacade()
facade.pay_all(10000)

 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

# 타사 API 클래스들
class ExternalPayPal:
    def pay_with_paypal(self, amount):
        print(f"PayPal 처리: {amount}원")

class ExternalKakaoPay:
    def kakao_charge(self, amount):
        print(f"KakaoPay 처리: {amount}원")

# 공통 인터페이스
class PaymentGateway:
    def pay(self, amount):
        pass

# 어댑터들
class PayPalAdapter(PaymentGateway):
    def __init__(self):
        self.service = ExternalPayPal()

    def pay(self, amount):
        self.service.pay_with_paypal(amount)

class KakaoPayAdapter(PaymentGateway):
    def __init__(self):
        self.service = ExternalKakaoPay()

    def pay(self, amount):
        self.service.kakao_charge(amount)

# 클라이언트 코드
def execute_payment(gateway: PaymentGateway, amount):
    gateway.pay(amount)

execute_payment(PayPalAdapter(), 5000)
execute_payment(KakaoPayAdapter(), 7000)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# 실제 결제 클래스
class RealPayment:
    def pay(self, amount):
        print(f"실제 결제 수행: {amount}원")

# 프록시 클래스
class PaymentProxy:
    def __init__(self):
        self.real_payment = RealPayment()

    def pay(self, amount):
        print("[로그] 결제 요청 발생")
        # 권한 검사 또는 캐싱 로직 삽입 가능
        self.real_payment.pay(amount)
        print("[로그] 결제 완료 기록 저장")

# 클라이언트 코드
proxy = PaymentProxy()
proxy.pay(10000)

1

[Client] --> [HomeAutomationFacade] --> [Light / AC / SecuritySystem]

 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

# 서브 시스템 클래스들
class Light:
    def on(self):
        print("💡 조명 켜기")

    def off(self):
        print("💡 조명 끄기")

class AirConditioner:
    def turn_on(self):
        print("❄️ 에어컨 켜기")

    def turn_off(self):
        print("❄️ 에어컨 끄기")

class SecuritySystem:
    def arm(self):
        print("🔒 보안 시스템 활성화")

    def disarm(self):
        print("🔓 보안 시스템 비활성화")

# Facade 클래스
class HomeAutomationFacade:
    def __init__(self):
        self.light = Light()
        self.ac = AirConditioner()
        self.security = SecuritySystem()

    def leave_home(self):
        print("\n🏠 집을 나갈 때:")
        self.light.off()
        self.ac.turn_off()
        self.security.arm()

    def come_home(self):
        print("\n🏠 집에 돌아올 때:")
        self.security.disarm()
        self.light.on()
        self.ac.turn_on()

# 클라이언트 사용
facade = HomeAutomationFacade()
facade.leave_home()
facade.come_home()

1
2
3

[Light]     \
[AC] ------> [SmartHomeMediator] <------ [SecuritySystem]
[Client]     /

 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

# Mediator 인터페이스
class SmartHomeMediator:
    def notify(self, sender, event):
        pass

# 구성 요소들 (Colleagues)
class Light:
    def __init__(self, mediator):
        self.mediator = mediator

    def on(self):
        print("💡 조명 켜기")

    def off(self):
        print("💡 조명 끄기")

class AirConditioner:
    def __init__(self, mediator):
        self.mediator = mediator

    def turn_on(self):
        print("❄️ 에어컨 켜기")

    def turn_off(self):
        print("❄️ 에어컨 끄기")

class SecuritySystem:
    def __init__(self, mediator):
        self.mediator = mediator

    def arm(self):
        print("🔒 보안 시스템 활성화")
        self.mediator.notify(self, "armed")

    def disarm(self):
        print("🔓 보안 시스템 비활성화")
        self.mediator.notify(self, "disarmed")

# Concrete Mediator
class ConcreteSmartHomeMediator(SmartHomeMediator):
    def __init__(self):
        self.light = Light(self)
        self.ac = AirConditioner(self)
        self.security = SecuritySystem(self)

    def notify(self, sender, event):
        if event == "armed":
            self.light.off()
            self.ac.turn_off()
        elif event == "disarmed":
            self.light.on()
            self.ac.turn_on()

# 사용 예시
mediator = ConcreteSmartHomeMediator()
mediator.security.arm()
mediator.security.disarm()

 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

# 서브시스템 클래스들
class HTMLHeader:
    def render(self):
        return "<header>Welcome</header>"

class HTMLBody:
    def render(self):
        return "<body><p>Content</p></body>"

class HTMLFooter:
    def render(self):
        return "<footer>Goodbye</footer>"

# Facade 클래스
class HTMLPageFacade:
    def __init__(self):
        self.header = HTMLHeader()
        self.body = HTMLBody()
        self.footer = HTMLFooter()

    def render_page(self):
        return self.header.render() + self.body.render() + self.footer.render()

# 클라이언트 사용
page = HTMLPageFacade()
print(page.render_page())

 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

# Product 클래스
class HTMLPage:
    def __init__(self):
        self.parts = []

    def add(self, part):
        self.parts.append(part)

    def render(self):
        return "".join(self.parts)

# Builder 클래스
class HTMLPageBuilder:
    def __init__(self):
        self.page = HTMLPage()

    def add_header(self):
        self.page.add("<header>Welcome</header>")
        return self

    def add_body(self):
        self.page.add("<body><p>Content</p></body>")
        return self

    def add_footer(self):
        self.page.add("<footer>Goodbye</footer>")
        return self

    def build(self):
        return self.page

# 클라이언트 사용
builder = HTMLPageBuilder()
page = builder.add_header().add_body().add_footer().build()
print(page.render())

 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

# 복잡한 서브시스템
class FileFetcher:
    def fetch(self, filename):
        print(f"📥 {filename} 파일 다운로드")

class Compressor:
    def compress(self, filename):
        print(f"🗜️ {filename} 압축")

class Encryptor:
    def encrypt(self, filename):
        print(f"🔐 {filename} 암호화")

# Facade
class Downloader:
    def __init__(self):
        self.fetcher = FileFetcher()
        self.compressor = Compressor()
        self.encryptor = Encryptor()

    def download(self, filename):
        self.fetcher.fetch(filename)
        self.compressor.compress(filename)
        self.encryptor.encrypt(filename)

# 클라이언트
downloader = Downloader()
downloader.download("report.pdf")

 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

# 기본 인터페이스
class Downloader:
    def download(self, filename):
        print(f"📥 {filename} 파일 다운로드")

# 추상 데코레이터
class DownloaderDecorator:
    def __init__(self, downloader):
        self.downloader = downloader

    def download(self, filename):
        self.downloader.download(filename)

# 구체 데코레이터
class CompressionDecorator(DownloaderDecorator):
    def download(self, filename):
        super().download(filename)
        print(f"🗜️ {filename} 압축")

class EncryptionDecorator(DownloaderDecorator):
    def download(self, filename):
        super().download(filename)
        print(f"🔐 {filename} 암호화")

# 데코레이터 조합
basic = Downloader()
secure_download = EncryptionDecorator(CompressionDecorator(basic))
secure_download.download("report.pdf")

 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

# 서브시스템 클래스들
class Window:
    def create(self):
        print("Create window")

class Button:
    def create(self):
        print("Create button")

class InputBox:
    def create(self):
        print("Create input box")

# Facade
class UIFacade:
    def __init__(self):
        self.window = Window()
        self.button = Button()
        self.input_box = InputBox()

    def initialize_ui(self):
        self.window.create()
        self.button.create()
        self.input_box.create()

# 사용
ui = UIFacade()
ui.initialize_ui()

 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

# 추상 제품 인터페이스들
class Button:
    def render(self): pass

class InputBox:
    def render(self): pass

# 구체적 제품들
class WinButton(Button):
    def render(self): print("Windows Button")

class MacButton(Button):
    def render(self): print("Mac Button")

class WinInputBox(InputBox):
    def render(self): print("Windows InputBox")

class MacInputBox(InputBox):
    def render(self): print("Mac InputBox")

# 추상 팩토리
class WidgetFactory:
    def create_button(self): pass
    def create_inputbox(self): pass

# 구체 팩토리들
class WindowsFactory(WidgetFactory):
    def create_button(self): return WinButton()
    def create_inputbox(self): return WinInputBox()

class MacFactory(WidgetFactory):
    def create_button(self): return MacButton()
    def create_inputbox(self): return MacInputBox()

# 클라이언트 코드
def render_ui(factory: WidgetFactory):
    btn = factory.create_button()
    box = factory.create_inputbox()
    btn.render()
    box.render()

render_ui(WindowsFactory())
render_ui(MacFactory())

1

[Client] → [HomeTheaterFacade] → [DVDPlayer, Projector, Amplifier, Lights]

  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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268

from abc import ABC, abstractmethod
from typing import Dict, List, Optional
from dataclasses import dataclass
from enum import Enum
import logging

# 주문 상태 열거형
class OrderStatus(Enum):
    PENDING = "pending"
    CONFIRMED = "confirmed"
    FAILED = "failed"
    CANCELLED = "cancelled"

# 주문 정보 데이터 클래스
@dataclass
class OrderInfo:
    """주문 정보를 담는 데이터 클래스"""
    order_id: str
    customer_id: str
    items: List[Dict]
    total_amount: float
    status: OrderStatus = OrderStatus.PENDING

# 서브시스템 인터페이스들
class InventoryService:
    """재고 관리 서비스 - 상품 재고 확인 및 예약 처리"""
    
    def check_availability(self, items: List[Dict]) -> bool:
        """재고 가용성 확인"""
        # 실제 구현에서는 데이터베이스 조회
        logging.info(f"재고 확인 중: {len(items)}개 상품")
        return True
    
    def reserve_items(self, items: List[Dict]) -> str:
        """상품 재고 예약"""
        reservation_id = f"RES_{hash(str(items)) % 10000}"
        logging.info(f"재고 예약 완료: {reservation_id}")
        return reservation_id
    
    def release_reservation(self, reservation_id: str) -> None:
        """재고 예약 해제 (실패 시 롤백용)"""
        logging.info(f"재고 예약 해제: {reservation_id}")

class PaymentService:
    """결제 서비스 - 다양한 결제 수단 처리"""
    
    def process_payment(self, amount: float, payment_method: str) -> Dict:
        """결제 처리"""
        # 실제 구현에서는 결제 게이트웨이 API 호출
        transaction_id = f"TXN_{hash(str(amount)) % 10000}"
        logging.info(f"결제 처리 완료: {transaction_id}, 금액: {amount}")
        return {
            "transaction_id": transaction_id,
            "status": "success",
            "amount": amount
        }
    
    def refund_payment(self, transaction_id: str) -> bool:
        """결제 환불 (실패 시 롤백용)"""
        logging.info(f"결제 환불 처리: {transaction_id}")
        return True

class ShippingService:
    """배송 서비스 - 배송 스케줄 관리"""
    
    def schedule_delivery(self, order_info: Dict) -> str:
        """배송 스케줄 등록"""
        delivery_id = f"DEL_{hash(str(order_info)) % 10000}"
        logging.info(f"배송 스케줄 등록: {delivery_id}")
        return delivery_id
    
    def cancel_delivery(self, delivery_id: str) -> None:
        """배송 취소 (실패 시 롤백용)"""
        logging.info(f"배송 취소: {delivery_id}")

class NotificationService:
    """알림 서비스 - 이메일, SMS 등 다중 채널 알림"""
    
    def send_order_confirmation(self, customer_id: str, order_info: Dict) -> None:
        """주문 확인 알림 발송"""
        logging.info(f"주문 확인 알림 발송 완료 - 고객: {customer_id}")
    
    def send_failure_notification(self, customer_id: str, reason: str) -> None:
        """주문 실패 알림 발송"""
        logging.info(f"주문 실패 알림 발송 - 고객: {customer_id}, 사유: {reason}")

class LoyaltyService:
    """적립금 서비스 - 포인트 적립 및 관리"""
    
    def calculate_points(self, amount: float) -> int:
        """적립금 계산 (구매액의 1%)"""
        return int(amount * 0.01)
    
    def add_points(self, customer_id: str, points: int) -> None:
        """적립금 적립"""
        logging.info(f"적립금 적립 완료 - 고객: {customer_id}, 포인트: {points}")

# 퍼사드 패턴 구현
class OrderProcessingFacade:
    """
    주문 처리 퍼사드 - 복잡한 주문 처리 과정을 단순화
    
    여러 서브시스템들의 복잡한 상호작용을 클라이언트로부터 숨기고,
    일관된 인터페이스를 통해 주문 처리 기능을 제공합니다.
    """
    
    def __init__(self):
        # 서브시스템 인스턴스 초기화
        self.inventory_service = InventoryService()
        self.payment_service = PaymentService()
        self.shipping_service = ShippingService()
        self.notification_service = NotificationService()
        self.loyalty_service = LoyaltyService()
        
        # 로깅 설정
        logging.basicConfig(level=logging.INFO)
        self.logger = logging.getLogger(__name__)
    
    def process_order(self, order_info: OrderInfo, payment_method: str = "card") -> Dict:
        """
        통합 주문 처리 메서드
        
        복잡한 주문 처리 과정을 하나의 메서드로 통합:
        1. 재고 확인 및 예약
        2. 결제 처리
        3. 배송 스케줄링
        4. 적립금 적립
        5. 알림 발송
        """
        self.logger.info(f"주문 처리 시작: {order_info.order_id}")
        
        # 실행 상태 추적을 위한 변수들
        reservation_id = None
        transaction_result = None
        delivery_id = None
        
        try:
            # 1단계: 재고 확인 및 예약
            if not self.inventory_service.check_availability(order_info.items):
                raise Exception("재고 부족")
            
            reservation_id = self.inventory_service.reserve_items(order_info.items)
            
            # 2단계: 결제 처리
            transaction_result = self.payment_service.process_payment(
                order_info.total_amount, payment_method
            )
            
            if transaction_result["status"] != "success":
                raise Exception("결제 실패")
            
            # 3단계: 배송 스케줄링
            delivery_id = self.shipping_service.schedule_delivery({
                "order_id": order_info.order_id,
                "customer_id": order_info.customer_id,
                "items": order_info.items
            })
            
            # 4단계: 적립금 적립
            points = self.loyalty_service.calculate_points(order_info.total_amount)
            self.loyalty_service.add_points(order_info.customer_id, points)
            
            # 5단계: 성공 알림 발송
            self.notification_service.send_order_confirmation(
                order_info.customer_id, 
                order_info.__dict__
            )
            
            # 주문 상태 업데이트
            order_info.status = OrderStatus.CONFIRMED
            
            self.logger.info(f"주문 처리 완료: {order_info.order_id}")
            
            return {
                "status": "success",
                "order_id": order_info.order_id,
                "transaction_id": transaction_result["transaction_id"],
                "delivery_id": delivery_id,
                "points_earned": points
            }
            
        except Exception as e:
            # 실패 시 롤백 처리
            self.logger.error(f"주문 처리 실패: {str(e)}")
            self._rollback_order(reservation_id, transaction_result, delivery_id)
            
            # 실패 알림 발송
            self.notification_service.send_failure_notification(
                order_info.customer_id, str(e)
            )
            
            order_info.status = OrderStatus.FAILED
            
            return {
                "status": "failed",
                "order_id": order_info.order_id,
                "error": str(e)
            }
    
    def _rollback_order(self, reservation_id: Optional[str], 
                       transaction_result: Optional[Dict], 
                       delivery_id: Optional[str]) -> None:
        """
        주문 실패 시 롤백 처리
        
        부분적으로 처리된 작업들을 안전하게 되돌립니다.
        """
        self.logger.info("주문 롤백 처리 시작")
        
        # 배송 취소
        if delivery_id:
            self.shipping_service.cancel_delivery(delivery_id)
        
        # 결제 환불
        if transaction_result and transaction_result.get("transaction_id"):
            self.payment_service.refund_payment(transaction_result["transaction_id"])
        
        # 재고 예약 해제
        if reservation_id:
            self.inventory_service.release_reservation(reservation_id)
        
        self.logger.info("주문 롤백 처리 완료")
    
    def get_order_status(self, order_id: str) -> Dict:
        """주문 상태 조회 (추가 기능)"""
        # 실제 구현에서는 데이터베이스 조회
        return {
            "order_id": order_id,
            "status": "confirmed",
            "last_updated": "2024-01-15T10:30:00Z"
        }

# 사용 예시
def main():
    """퍼사드 패턴 사용 예시"""
    
    # 주문 처리 퍼사드 생성
    order_facade = OrderProcessingFacade()
    
    # 주문 정보 생성
    order = OrderInfo(
        order_id="ORD_001",
        customer_id="CUST_123",
        items=[
            {"product_id": "PROD_001", "quantity": 2, "price": 29.99},
            {"product_id": "PROD_002", "quantity": 1, "price": 15.50}
        ],
        total_amount=75.48
    )
    
    # 클라이언트는 복잡한 서브시스템 상호작용을 알 필요 없이
    # 간단한 메서드 호출로 전체 주문 처리 과정을 수행
    result = order_facade.process_order(order, "credit_card")
    
    print("=" * 50)
    print("주문 처리 결과:")
    print(f"상태: {result['status']}")
    print(f"주문 ID: {result['order_id']}")
    
    if result["status"] == "success":
        print(f"거래 ID: {result['transaction_id']}")
        print(f"배송 ID: {result['delivery_id']}")
        print(f"적립 포인트: {result['points_earned']}")
    else:
        print(f"오류: {result['error']}")

if __name__ == "__main__":
    main()