[Design Patterns] 07. 어댑터와 파사드: 인터페이스의 철학 — 실습

 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

// TODO 1: 통합 결제 인터페이스 정의
public interface PaymentGateway {
    PaymentResult processPayment(PaymentRequest request);
    boolean refundPayment(String transactionId, BigDecimal amount);
    PaymentStatus getPaymentStatus(String transactionId);
}

// TODO 2: 레거시 결제 시스템 (변경 불가)
public class LegacyPaymentSystem {
    public boolean makePayment(String cardNum, double amount, String currency) {
        // 기존 시스템 로직 (변경 불가)
        return true;
    }
    
    public String checkStatus(String paymentId) {
        return "SUCCESS";
    }
}

// TODO 3: 외부 Payment API (다른 인터페이스)
public class ExternalPaymentAPI {
    public PaymentResponse charge(ChargeRequest request) {
        // 외부 API 응답
        return new PaymentResponse();
    }
}

// TODO 4: Adapter 구현
public class LegacyPaymentAdapter implements PaymentGateway {
    private final LegacyPaymentSystem legacySystem;

    public LegacyPaymentAdapter(LegacyPaymentSystem legacySystem) {
        this.legacySystem = legacySystem;
    }

    @Override
    public PaymentResult processPayment(PaymentRequest request) {
        // PaymentRequest -> 레거시 makePayment(카드번호, double 금액, 통화) 형태로 변환
        boolean success = legacySystem.makePayment(
                request.getCardNumber(),
                request.getAmount().doubleValue(),
                request.getCurrency()
        );
        return success
                ? PaymentResult.success(request.getTransactionId())
                : PaymentResult.failure("LEGACY_PAYMENT_FAILED");
    }

    @Override
    public boolean refundPayment(String transactionId, BigDecimal amount) {
        // TODO: 레거시 시스템은 환불 API를 제공하지 않으므로 별도 배치/수동 프로세스 연동 필요
        return false;
    }

    @Override
    public PaymentStatus getPaymentStatus(String transactionId) {
        // 레거시 문자열 상태값("SUCCESS" 등)을 통합 enum PaymentStatus로 변환
        String legacyStatus = legacySystem.checkStatus(transactionId);
        return PaymentStatus.fromLegacyCode(legacyStatus);
    }
}

public class ExternalPaymentAdapter implements PaymentGateway {
    private final ExternalPaymentAPI externalAPI;
    
    // TODO: 외부 API 호출을 내부 인터페이스에 맞게 변환
}

// TODO 5: 통합 테스트
public class PaymentAdapterTest {
    @Test
    public void testLegacyAdapter() {
        // TODO: 레거시 시스템 어댑터 테스트
    }
    
    @Test
    public void testExternalAdapter() {
        // TODO: 외부 API 어댑터 테스트
    }
}

 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

public class PaymentRequest {
    private final String transactionId;
    private final String cardNumber;
    private final BigDecimal amount;
    private final String currency;

    public PaymentRequest(String transactionId, String cardNumber, BigDecimal amount, String currency) {
        this.transactionId = transactionId;
        this.cardNumber = cardNumber;
        this.amount = amount;
        this.currency = currency;
    }

    public String getTransactionId() { return transactionId; }
    public String getCardNumber() { return cardNumber; }
    public BigDecimal getAmount() { return amount; }
    public String getCurrency() { return currency; }
}

public class PaymentResult {
    private final boolean success;
    private final String transactionId;
    private final String errorCode;

    private PaymentResult(boolean success, String transactionId, String errorCode) {
        this.success = success;
        this.transactionId = transactionId;
        this.errorCode = errorCode;
    }

    public static PaymentResult success(String transactionId) {
        return new PaymentResult(true, transactionId, null);
    }

    public static PaymentResult failure(String errorCode) {
        return new PaymentResult(false, null, errorCode);
    }

    public boolean isSuccess() { return success; }
}

public enum PaymentStatus {
    SUCCESS, FAILED, PENDING, UNKNOWN;

    public static PaymentStatus fromLegacyCode(String legacyStatus) {
        if ("SUCCESS".equals(legacyStatus)) return SUCCESS;
        if ("FAILED".equals(legacyStatus)) return FAILED;
        return UNKNOWN;
    }
}

public class ChargeRequest {
    private final BigDecimal amount;
    private final String currency;

    public ChargeRequest(BigDecimal amount, String currency) {
        this.amount = amount;
        this.currency = currency;
    }

    public BigDecimal getAmount() { return amount; }
    public String getCurrency() { return currency; }
}

public class PaymentResponse {
    private boolean successful;
    private String transactionId;

    public boolean isSuccessful() { return successful; }
    public String getTransactionId() { return transactionId; }
}

 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

// TODO 1: 복잡한 서브시스템들
public class InventoryService {
    public boolean checkAvailability(String productId, int quantity) { return true; }
    public void reserveItems(String productId, int quantity) {}
}

public class PaymentService {
    public PaymentResult processPayment(PaymentInfo info) { return null; }
}

public class ShippingService {
    public String scheduleDelivery(Address address, List<String> items) { return "TRACK001"; }
}

public class NotificationService {
    public void sendOrderConfirmation(String email, String orderId) {}
}

// TODO 2: E-commerce Facade 구현
public class EcommerceFacade {
    private final InventoryService inventoryService;
    private final PaymentService paymentService;
    private final ShippingService shippingService;
    private final NotificationService notificationService;
    
    // TODO: 복잡한 주문 처리 과정을 하나의 메서드로 단순화
    public OrderResult placeOrder(OrderRequest request) {
        // TODO: 1. 재고 확인
        // TODO: 2. 결제 처리
        // TODO: 3. 배송 예약
        // TODO: 4. 알림 발송
        // TODO: 5. 결과 반환
        return null;
    }
    
    // TODO: 기타 편의 메서드들
    public boolean isProductAvailable(String productId, int quantity) {
        // TODO: 단순한 재고 확인
        return false;
    }
}

 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

public class Address {
    private final String street;
    private final String city;
    private final String zipCode;

    public Address(String street, String city, String zipCode) {
        this.street = street;
        this.city = city;
        this.zipCode = zipCode;
    }

    public String getStreet() { return street; }
    public String getCity() { return city; }
    public String getZipCode() { return zipCode; }
}

public class PaymentInfo {
    private final BigDecimal amount;
    private final String cardNumber;

    public PaymentInfo(BigDecimal amount, String cardNumber) {
        this.amount = amount;
        this.cardNumber = cardNumber;
    }

    public BigDecimal getAmount() { return amount; }
    public String getCardNumber() { return cardNumber; }
}

public class OrderRequest {
    private final String productId;
    private final int quantity;
    private final PaymentInfo paymentInfo;
    private final Address shippingAddress;
    private final String customerEmail;

    public OrderRequest(String productId, int quantity, PaymentInfo paymentInfo,
                         Address shippingAddress, String customerEmail) {
        this.productId = productId;
        this.quantity = quantity;
        this.paymentInfo = paymentInfo;
        this.shippingAddress = shippingAddress;
        this.customerEmail = customerEmail;
    }

    public String getProductId() { return productId; }
    public int getQuantity() { return quantity; }
    public PaymentInfo getPaymentInfo() { return paymentInfo; }
    public Address getShippingAddress() { return shippingAddress; }
    public String getCustomerEmail() { return customerEmail; }
}

public class OrderResult {
    private final boolean success;
    private final String orderId;
    private final String trackingNumber;
    private final String errorMessage;

    private OrderResult(boolean success, String orderId, String trackingNumber, String errorMessage) {
        this.success = success;
        this.orderId = orderId;
        this.trackingNumber = trackingNumber;
        this.errorMessage = errorMessage;
    }

    public static OrderResult success(String orderId, String trackingNumber) {
        return new OrderResult(true, orderId, trackingNumber, null);
    }

    public static OrderResult failure(String errorMessage) {
        return new OrderResult(false, null, null, errorMessage);
    }

    public boolean isSuccess() { return success; }
}

 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

// TODO 1: 통합 데이터 접근 인터페이스
public interface DataRepository<T> {
    T findById(String id);
    List<T> findAll();
    void save(T entity);
    void delete(String id);
}

// TODO 2: 다양한 데이터 소스 어댑터들
public class DatabaseAdapter<T> implements DataRepository<T> {
    // TODO: JPA/JDBC 어댑터 구현
}

public class RestApiAdapter<T> implements DataRepository<T> {
    // TODO: REST API 호출을 데이터 접근으로 변환
}

public class FileSystemAdapter<T> implements DataRepository<T> {
    // TODO: 파일 시스템 접근을 데이터 접근으로 변환
}

// TODO 3: 통합 데이터 서비스 Facade
public class UnifiedDataService {
    private final Map<String, DataRepository<?>> repositories;
    
    // TODO: 데이터 소스별 라우팅 로직
    public <T> T getData(String source, String id, Class<T> type) {
        // TODO: 적절한 어댑터 선택 후 데이터 조회
        return null;
    }
}