추상화 (Abstraction)

  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

# 추상화 구현 예시 - 결제 시스템 (Payment System)
from abc import ABC, abstractmethod
from typing import Dict, Any
import logging

# 1. 추상 클래스 (Abstract Class) - 결제 처리기
class PaymentProcessor(ABC):
    """
    결제 처리를 위한 추상 클래스
    공통 기능은 구현하고, 특화된 기능은 서브클래스에서 구현 강제
    """
    
    def __init__(self, provider_name: str):
        self.provider_name = provider_name
        self.logger = logging.getLogger(self.__class__.__name__)
    
    # 공통 기능 - 구체적 구현 제공
    def validate_amount(self, amount: float) -> bool:
        """결제 금액 유효성 검사"""
        if amount <= 0:
            self.logger.error(f"Invalid amount: {amount}")
            return False
        if amount > 1000000:  # 최대 결제 한도
            self.logger.error(f"Amount exceeds limit: {amount}")
            return False
        return True
    
    def log_transaction(self, transaction_data: Dict[str, Any]) -> None:
        """거래 로그 기록"""
        self.logger.info(f"Transaction logged: {transaction_data}")
    
    # 추상 메서드 - 서브클래스에서 반드시 구현해야 함
    @abstractmethod
    def process_payment(self, amount: float, payment_info: Dict[str, Any]) -> Dict[str, Any]:
        """
        결제 처리 추상 메서드
        각 결제 수단별로 다른 구현이 필요
        """
        pass
    
    @abstractmethod
    def refund_payment(self, transaction_id: str, amount: float) -> Dict[str, Any]:
        """환불 처리 추상 메서드"""
        pass
    
    # 템플릿 메서드 패턴 - 전체 처리 흐름 정의
    def execute_payment(self, amount: float, payment_info: Dict[str, Any]) -> Dict[str, Any]:
        """
        결제 처리 템플릿 메서드
        공통 흐름을 정의하고 특화된 부분은 추상 메서드 호출
        """
        # 1. 유효성 검사 (공통 로직)
        if not self.validate_amount(amount):
            return {"status": "failed", "error": "Invalid amount"}
        
        # 2. 실제 결제 처리 (추상화된 로직)
        try:
            result = self.process_payment(amount, payment_info)
            
            # 3. 로그 기록 (공통 로직)
            self.log_transaction({
                "provider": self.provider_name,
                "amount": amount,
                "status": result.get("status"),
                "transaction_id": result.get("transaction_id")
            })
            
            return result
            
        except Exception as e:
            self.logger.error(f"Payment processing failed: {e}")
            return {"status": "failed", "error": str(e)}

# 2. 인터페이스 (Interface) - 알림 서비스
class NotificationService(ABC):
    """
    알림 서비스 인터페이스
    다양한 알림 채널에 대한 공통 계약 정의
    """
    
    @abstractmethod
    def send_notification(self, message: str, recipient: str) -> bool:
        """알림 전송"""
        pass
    
    @abstractmethod
    def get_delivery_status(self, notification_id: str) -> str:
        """전송 상태 조회"""
        pass

# 3. 구체적 구현 클래스들
class CreditCardProcessor(PaymentProcessor):
    """신용카드 결제 처리기"""
    
    def __init__(self):
        super().__init__("CreditCard")
    
    def process_payment(self, amount: float, payment_info: Dict[str, Any]) -> Dict[str, Any]:
        """신용카드 결제 처리 구현"""
        card_number = payment_info.get("card_number")
        cvv = payment_info.get("cvv")
        
        # 신용카드 특화 로직
        if not self._validate_card(card_number, cvv):
            return {"status": "failed", "error": "Invalid card"}
        
        # 실제 결제 처리 시뮬레이션
        transaction_id = f"CC_{hash(card_number)}_{amount}"
        
        return {
            "status": "success",
            "transaction_id": transaction_id,
            "provider": self.provider_name,
            "amount": amount
        }
    
    def refund_payment(self, transaction_id: str, amount: float) -> Dict[str, Any]:
        """신용카드 환불 처리"""
        return {
            "status": "success",
            "refund_id": f"REF_{transaction_id}",
            "amount": amount
        }
    
    def _validate_card(self, card_number: str, cvv: str) -> bool:
        """신용카드 유효성 검사 (내부 메서드)"""
        return len(card_number) == 16 and len(cvv) == 3

class PayPalProcessor(PaymentProcessor):
    """PayPal 결제 처리기"""
    
    def __init__(self):
        super().__init__("PayPal")
    
    def process_payment(self, amount: float, payment_info: Dict[str, Any]) -> Dict[str, Any]:
        """PayPal 결제 처리 구현"""
        email = payment_info.get("email")
        password = payment_info.get("password")
        
        # PayPal 특화 로직
        if not self._authenticate_user(email, password):
            return {"status": "failed", "error": "Authentication failed"}
        
        transaction_id = f"PP_{hash(email)}_{amount}"
        
        return {
            "status": "success",
            "transaction_id": transaction_id,
            "provider": self.provider_name,
            "amount": amount
        }
    
    def refund_payment(self, transaction_id: str, amount: float) -> Dict[str, Any]:
        """PayPal 환불 처리"""
        return {
            "status": "success",
            "refund_id": f"REF_{transaction_id}",
            "amount": amount
        }
    
    def _authenticate_user(self, email: str, password: str) -> bool:
        """사용자 인증 (내부 메서드)"""
        return "@" in email and len(password) >= 8

class EmailNotificationService(NotificationService):
    """이메일 알림 서비스"""
    
    def send_notification(self, message: str, recipient: str) -> bool:
        """이메일 전송"""
        print(f"Sending email to {recipient}: {message}")
        return True
    
    def get_delivery_status(self, notification_id: str) -> str:
        """이메일 전송 상태 조회"""
        return "delivered"

class SMSNotificationService(NotificationService):
    """SMS 알림 서비스"""
    
    def send_notification(self, message: str, recipient: str) -> bool:
        """SMS 전송"""
        print(f"Sending SMS to {recipient}: {message}")
        return True
    
    def get_delivery_status(self, notification_id: str) -> str:
        """SMS 전송 상태 조회"""
        return "delivered"

# 4. 추상화를 활용한 상위 레벨 서비스
class PaymentService:
    """
    결제 서비스 - 추상화를 활용한 고수준 서비스
    구체적인 결제 수단과 알림 채널에 의존하지 않음
    """
    
    def __init__(self, processor: PaymentProcessor, notifier: NotificationService):
        # 의존성 주입을 통한 느슨한 결합
        self.processor = processor
        self.notifier = notifier
    
    def process_order_payment(self, order_data: Dict[str, Any]) -> Dict[str, Any]:
        """주문 결제 처리"""
        amount = order_data["amount"]
        payment_info = order_data["payment_info"]
        customer_contact = order_data["customer_contact"]
        
        # 추상화된 결제 처리기 사용
        result = self.processor.execute_payment(amount, payment_info)
        
        # 결제 결과에 따른 알림 발송
        if result["status"] == "success":
            message = f"Payment successful. Transaction ID: {result['transaction_id']}"
            self.notifier.send_notification(message, customer_contact)
        else:
            message = f"Payment failed: {result.get('error', 'Unknown error')}"
            self.notifier.send_notification(message, customer_contact)
        
        return result

# 5. 사용 예시
def main():
    """추상화 활용 예시"""
    
    # 다양한 결제 수단과 알림 채널 조합 사용 가능
    
    # 신용카드 + 이메일 조합
    cc_processor = CreditCardProcessor()
    email_service = EmailNotificationService()
    payment_service1 = PaymentService(cc_processor, email_service)
    
    # PayPal + SMS 조합
    paypal_processor = PayPalProcessor()
    sms_service = SMSNotificationService()
    payment_service2 = PaymentService(paypal_processor, sms_service)
    
    # 주문 데이터
    order1 = {
        "amount": 100.0,
        "payment_info": {
            "card_number": "1234567890123456",
            "cvv": "123"
        },
        "customer_contact": "customer@example.com"
    }
    
    order2 = {
        "amount": 200.0,
        "payment_info": {
            "email": "user@paypal.com",
            "password": "password123"
        },
        "customer_contact": "+82-10-1234-5678"
    }
    
    # 동일한 인터페이스로 다른 구현체 사용
    print("=== 신용카드 결제 ===")
    result1 = payment_service1.process_order_payment(order1)
    print(f"Result: {result1}")
    
    print("\n=== PayPal 결제 ===")
    result2 = payment_service2.process_order_payment(order2)
    print(f"Result: {result2}")
    
    # 추상화의 장점: 새로운 결제 수단이나 알림 채널 추가 시
    # 기존 코드 변경 없이 확장 가능

if __name__ == "__main__":
    main()