[Design Patterns] 어댑터와 파사드: 인터페이스의 철학

 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

// 현실적인 문제 상황
public class PaymentService {
    // 문제: 여러 결제 시스템과 통합해야 함
    public void processPayment(PaymentRequest request) {
        if (request.getMethod().equals("CREDIT_CARD")) {
            // 기존 신용카드 시스템 - 복잡한 API
            CreditCardProcessor processor = new CreditCardProcessor();
            processor.initialize();
            processor.setMerchantId("12345");
            processor.setSecurityKey("secret");
            processor.validateCard(request.getCardNumber());
            processor.processTransaction(request.getAmount());
            processor.finalize();
            
        } else if (request.getMethod().equals("PAYPAL")) {
            // PayPal API - 전혀 다른 인터페이스
            PayPalAPI paypal = new PayPalAPI();
            paypal.authenticate("user", "password");
            PayPalRequest ppRequest = new PayPalRequest();
            ppRequest.setAmount(request.getAmount());
            ppRequest.setCurrency("USD");
            paypal.makePayment(ppRequest);
            
        } else if (request.getMethod().equals("BANK_TRANSFER")) {
            // 은행 전산망 - 또 다른 복잡한 프로토콜
            BankTransferSystem bank = new BankTransferSystem();
            bank.connectToBank();
            bank.verifyAccount(request.getAccountNumber());
            bank.transferFunds(request.getAmount(), request.getTargetAccount());
            bank.disconnect();
        }
        
        // 이런 식으로 계속 늘어나면... 😱
    }
}

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

// 실제 상황: 기존 로깅 시스템
public class LegacyLogger {
    public void writeLog(int level, String message, String timestamp) {
        System.out.println("[" + timestamp + "] Level-" + level + ": " + message);
    }
    
    public void writeErrorLog(String error, String stackTrace) {
        System.err.println("ERROR: " + error + "\n" + stackTrace);
    }
}

// 새로운 표준 인터페이스 도입
public interface ModernLogger {
    void info(String message);
    void warn(String message);
    void error(String message);
    void debug(String message);
}

// 문제: 기존 코드 수백 곳에서 LegacyLogger 사용 중
// 모든 코드를 바꾸기에는 위험 부담이 너무 큼

 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

public class LoggerAdapter implements ModernLogger {
    private final LegacyLogger legacyLogger;
    private final DateTimeFormatter formatter;
    
    public LoggerAdapter(LegacyLogger legacyLogger) {
        this.legacyLogger = legacyLogger;
        this.formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    }
    
    @Override
    public void info(String message) {
        String timestamp = LocalDateTime.now().format(formatter);
        legacyLogger.writeLog(1, message, timestamp);
    }
    
    @Override
    public void warn(String message) {
        String timestamp = LocalDateTime.now().format(formatter);
        legacyLogger.writeLog(2, message, timestamp);
    }
    
    @Override
    public void error(String message) {
        legacyLogger.writeErrorLog(message, Thread.currentThread().getStackTrace().toString());
    }
    
    @Override
    public void debug(String message) {
        String timestamp = LocalDateTime.now().format(formatter);
        legacyLogger.writeLog(0, message, timestamp);
    }
}

// 사용법: 점진적 마이그레이션 가능
public class OrderService {
    private final ModernLogger logger;
    
    public OrderService() {
        // 기존 시스템과 호환성 유지하면서 새 인터페이스 사용
        this.logger = new LoggerAdapter(new LegacyLogger());
    }
    
    public void processOrder(Order order) {
        logger.info("Processing order: " + order.getId());
        try {
            // 주문 처리 로직
            logger.info("Order processed successfully");
        } catch (Exception e) {
            logger.error("Order processing failed: " + e.getMessage());
        }
    }
}

 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

// 상속을 통한 Adapter (Java에서는 제한적)
public class LoggerClassAdapter extends LegacyLogger implements ModernLogger {
    private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    
    @Override
    public void info(String message) {
        writeLog(1, message, LocalDateTime.now().format(formatter));
    }
    
    @Override
    public void warn(String message) {
        writeLog(2, message, LocalDateTime.now().format(formatter));
    }
    
    @Override
    public void error(String message) {
        writeErrorLog(message, "");
    }
    
    @Override
    public void debug(String message) {
        writeLog(0, message, LocalDateTime.now().format(formatter));
    }
    
    // 기존 메서드도 그대로 사용 가능
    // writeLog(), writeErrorLog() 등
}

  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

// 외부 결제 API들 - 모두 다른 인터페이스
public class StripePaymentAPI {
    public StripeResult processPayment(String token, int amountInCents, String currency) {
        // Stripe API 호출
        return new StripeResult();
    }
}

public class PayPalAPI {
    public PayPalResponse executePayment(PayPalRequest request) {
        // PayPal API 호출
        return new PayPalResponse();
    }
}

// 통일된 결제 인터페이스
public interface PaymentProcessor {
    PaymentResult processPayment(PaymentRequest request);
}

// Stripe Adapter
public class StripeAdapter implements PaymentProcessor {
    private final StripePaymentAPI stripeAPI;
    
    public StripeAdapter(StripePaymentAPI stripeAPI) {
        this.stripeAPI = stripeAPI;
    }
    
    @Override
    public PaymentResult processPayment(PaymentRequest request) {
        try {
            // 데이터 변환
            String token = request.getToken();
            int amountInCents = (int) (request.getAmount() * 100);
            String currency = request.getCurrency();
            
            // API 호출
            StripeResult result = stripeAPI.processPayment(token, amountInCents, currency);
            
            // 결과 변환
            return new PaymentResult(
                result.isSuccessful(),
                result.getTransactionId(),
                result.getErrorMessage()
            );
            
        } catch (Exception e) {
            return new PaymentResult(false, null, "Stripe payment failed: " + e.getMessage());
        }
    }
}

// PayPal Adapter
public class PayPalAdapter implements PaymentProcessor {
    private final PayPalAPI paypalAPI;
    
    public PayPalAdapter(PayPalAPI paypalAPI) {
        this.paypalAPI = paypalAPI;
    }
    
    @Override
    public PaymentResult processPayment(PaymentRequest request) {
        try {
            // PayPal 전용 객체 생성
            PayPalRequest paypalRequest = new PayPalRequest();
            paypalRequest.setAmount(request.getAmount());
            paypalRequest.setCurrency(request.getCurrency());
            paypalRequest.setPayerEmail(request.getPayerEmail());
            
            // API 호출
            PayPalResponse response = paypalAPI.executePayment(paypalRequest);
            
            // 결과 변환
            return new PaymentResult(
                "SUCCESS".equals(response.getStatus()),
                response.getTransactionId(),
                response.getErrorCode()
            );
            
        } catch (Exception e) {
            return new PaymentResult(false, null, "PayPal payment failed: " + e.getMessage());
        }
    }
}

// 사용하는 곳에서는 구현체를 몰라도 됨
public class PaymentService {
    private final List<PaymentProcessor> processors;
    
    public PaymentService() {
        this.processors = Arrays.asList(
            new StripeAdapter(new StripePaymentAPI()),
            new PayPalAdapter(new PayPalAPI())
            // 새로운 결제 수단 추가 시 Adapter만 만들면 됨
        );
    }
    
    public PaymentResult processPayment(PaymentRequest request) {
        for (PaymentProcessor processor : processors) {
            if (processor.supports(request.getPaymentMethod())) {
                return processor.processPayment(request);
            }
        }
        throw new UnsupportedOperationException("Payment method not supported");
    }
}

 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

// 레거시 데이터베이스 DAO
public class LegacyUserDAO {
    public String getUserById(int id) {
        // 레거시 DB 쿼리
        return "user_data_string";
    }
    
    public void saveUser(String userData) {
        // 레거시 방식으로 저장
    }
}

// 새로운 표준 인터페이스
public interface UserRepository {
    Optional<User> findById(Long id);
    User save(User user);
    List<User> findAll();
}

// 마이그레이션을 위한 Adapter
public class LegacyUserRepositoryAdapter implements UserRepository {
    private final LegacyUserDAO legacyDAO;
    private final UserDataConverter converter;
    
    public LegacyUserRepositoryAdapter(LegacyUserDAO legacyDAO) {
        this.legacyDAO = legacyDAO;
        this.converter = new UserDataConverter();
    }
    
    @Override
    public Optional<User> findById(Long id) {
        try {
            String userData = legacyDAO.getUserById(id.intValue());
            if (userData != null && !userData.isEmpty()) {
                User user = converter.fromLegacyString(userData);
                return Optional.of(user);
            }
            return Optional.empty();
        } catch (Exception e) {
            logger.error("Failed to fetch user from legacy system", e);
            return Optional.empty();
        }
    }
    
    @Override
    public User save(User user) {
        String legacyData = converter.toLegacyString(user);
        legacyDAO.saveUser(legacyData);
        return user;
    }
    
    @Override
    public List<User> findAll() {
        // 레거시 시스템에서는 전체 조회가 비효율적이므로 제한
        throw new UnsupportedOperationException("Legacy system doesn't support findAll operation");
    }
}

// 점진적 마이그레이션 전략
public class UserService {
    private final UserRepository userRepository;
    
    public UserService(boolean useLegacySystem) {
        if (useLegacySystem) {
            this.userRepository = new LegacyUserRepositoryAdapter(new LegacyUserDAO());
        } else {
            this.userRepository = new ModernUserRepository();
        }
    }
    
    // 비즈니스 로직은 동일하게 유지
    public User getUser(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new UserNotFoundException("User not found: " + id));
    }
}

 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

// 현실적인 문제 상황: 이커머스 주문 처리
public class OrderController {
    
    public ResponseEntity<String> createOrder(OrderRequest request) {
        // 현재 코드: 컨트롤러에 너무 많은 책임
        
        // 1. 재고 확인
        InventoryService inventoryService = new InventoryService();
        DatabaseConnection inventoryDB = new DatabaseConnection("inventory_db");
        inventoryDB.connect();
        for (OrderItem item : request.getItems()) {
            if (!inventoryService.checkStock(inventoryDB, item.getProductId(), item.getQuantity())) {
                inventoryDB.close();
                return ResponseEntity.badRequest().body("Insufficient stock for " + item.getProductId());
            }
        }
        
        // 2. 가격 계산
        PricingEngine pricingEngine = new PricingEngine();
        DiscountService discountService = new DiscountService();
        TaxCalculator taxCalculator = new TaxCalculator();
        
        double subtotal = 0;
        for (OrderItem item : request.getItems()) {
            double price = pricingEngine.getPrice(item.getProductId());
            double discount = discountService.calculateDiscount(request.getCustomerId(), item);
            subtotal += (price - discount) * item.getQuantity();
        }
        double tax = taxCalculator.calculateTax(subtotal, request.getShippingAddress());
        double total = subtotal + tax;
        
        // 3. 결제 처리
        PaymentGateway paymentGateway = new PaymentGateway();
        PaymentRequest paymentRequest = new PaymentRequest();
        paymentRequest.setAmount(total);
        paymentRequest.setCustomerId(request.getCustomerId());
        paymentRequest.setPaymentMethod(request.getPaymentMethod());
        
        PaymentResult paymentResult = paymentGateway.processPayment(paymentRequest);
        if (!paymentResult.isSuccessful()) {
            inventoryDB.close();
            return ResponseEntity.badRequest().body("Payment failed");
        }
        
        // 4. 주문 저장
        OrderRepository orderRepository = new OrderRepository();
        DatabaseConnection orderDB = new DatabaseConnection("order_db");
        orderDB.connect();
        Order order = new Order();
        order.setCustomerId(request.getCustomerId());
        order.setItems(request.getItems());
        order.setTotal(total);
        order.setPaymentId(paymentResult.getPaymentId());
        orderRepository.save(orderDB, order);
        
        // 5. 재고 차감
        for (OrderItem item : request.getItems()) {
            inventoryService.decreaseStock(inventoryDB, item.getProductId(), item.getQuantity());
        }
        
        // 6. 알림 발송
        NotificationService notificationService = new NotificationService();
        EmailService emailService = new EmailService();
        SMSService smsService = new SMSService();
        
        Customer customer = customerService.getCustomer(request.getCustomerId());
        emailService.sendOrderConfirmation(customer.getEmail(), order);
        if (customer.isSmsEnabled()) {
            smsService.sendOrderSMS(customer.getPhone(), order);
        }
        
        // 7. 로깅 및 감사
        AuditService auditService = new AuditService();
        auditService.logOrderCreation(order, customer);
        
        // 연결 정리
        inventoryDB.close();
        orderDB.close();
        
        return ResponseEntity.ok("Order created successfully: " + order.getId());
    }
}

// 문제점:
// 1. 컨트롤러가 너무 복잡함 (100줄 넘는 메서드)
// 2. 여러 서브시스템의 복잡한 상호작용
// 3. 에러 처리가 어려움
// 4. 테스트하기 어려움
// 5. 재사용이 불가능함

  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

// 주문 처리를 위한 Facade
public class OrderProcessingFacade {
    private final InventoryService inventoryService;
    private final PricingService pricingService;
    private final PaymentService paymentService;
    private final OrderService orderService;
    private final NotificationService notificationService;
    private final AuditService auditService;
    
    public OrderProcessingFacade() {
        // 의존성 주입으로 각 서비스 초기화
        this.inventoryService = new InventoryService();
        this.pricingService = new PricingService();
        this.paymentService = new PaymentService();
        this.orderService = new OrderService();
        this.notificationService = new NotificationService();
        this.auditService = new AuditService();
    }
    
    // 복잡한 주문 처리를 하나의 간단한 메서드로 제공
    public OrderResult processOrder(OrderRequest request) {
        try {
            // 1단계: 재고 검증
            validateInventory(request);
            
            // 2단계: 가격 계산
            PricingResult pricing = pricingService.calculatePricing(request);
            
            // 3단계: 결제 처리
            PaymentResult payment = paymentService.processPayment(
                request.getCustomerId(), 
                pricing.getTotal(), 
                request.getPaymentMethod()
            );
            
            // 4단계: 주문 생성 (트랜잭션 처리)
            Order order = orderService.createOrder(request, pricing, payment);
            
            // 5단계: 재고 차감
            inventoryService.reserveItems(request.getItems());
            
            // 6단계: 후처리 (비동기)
            processPostOrderActions(order, request.getCustomerId());
            
            return OrderResult.success(order);
            
        } catch (InsufficientStockException e) {
            return OrderResult.failure("재고 부족: " + e.getMessage());
        } catch (PaymentException e) {
            return OrderResult.failure("결제 실패: " + e.getMessage());
        } catch (Exception e) {
            // 실패 시 보상 트랜잭션
            rollbackOrder(request);
            return OrderResult.failure("주문 처리 실패: " + e.getMessage());
        }
    }
    
    // 복잡한 비즈니스 로직을 내부 메서드로 숨김
    private void validateInventory(OrderRequest request) throws InsufficientStockException {
        for (OrderItem item : request.getItems()) {
            if (!inventoryService.hasStock(item.getProductId(), item.getQuantity())) {
                throw new InsufficientStockException(
                    "상품 " + item.getProductId() + "의 재고가 부족합니다");
            }
        }
    }
    
    private void processPostOrderActions(Order order, String customerId) {
        // 비동기 처리로 성능 최적화
        CompletableFuture.runAsync(() -> {
            try {
                // 알림 발송
                notificationService.sendOrderConfirmation(order, customerId);
                
                // 감사 로그 기록
                auditService.logOrderCreation(order);
                
                // 추천 시스템 업데이트
                recommendationService.updatePurchaseHistory(customerId, order);
                
            } catch (Exception e) {
                logger.error("주문 후처리 실패", e);
                // 후처리 실패는 주문 성공에 영향 주지 않음
            }
        });
    }
    
    private void rollbackOrder(OrderRequest request) {
        // 보상 트랜잭션 로직
        try {
            inventoryService.releaseReservation(request.getItems());
            paymentService.refundIfProcessed(request.getCustomerId());
        } catch (Exception e) {
            logger.error("주문 롤백 실패", e);
        }
    }
}

// 컨트롤러는 이제 매우 단순해짐
@RestController
public class OrderController {
    private final OrderProcessingFacade orderFacade;
    
    public OrderController(OrderProcessingFacade orderFacade) {
        this.orderFacade = orderFacade;
    }
    
    @PostMapping("/orders")
    public ResponseEntity<OrderResponse> createOrder(@RequestBody OrderRequest request) {
        // 복잡한 로직은 Facade에 위임
        OrderResult result = orderFacade.processOrder(request);
        
        if (result.isSuccess()) {
            return ResponseEntity.ok(
                new OrderResponse(result.getOrder().getId(), "주문이 성공적으로 생성되었습니다")
            );
        } else {
            return ResponseEntity.badRequest().body(
                new OrderResponse(null, result.getErrorMessage())
            );
        }
    }
}

 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

// 데이터베이스 작업을 위한 Micro Facade
public class DatabaseFacade {
    private final DataSource dataSource;
    private final QueryBuilder queryBuilder;
    private final ResultMapper resultMapper;
    private final ConnectionManager connectionManager;
    
    public <T> List<T> findAll(Class<T> entityClass) {
        return connectionManager.executeWithConnection(connection -> {
            String query = queryBuilder.buildSelectAll(entityClass);
            PreparedStatement stmt = connection.prepareStatement(query);
            ResultSet rs = stmt.executeQuery();
            return resultMapper.mapToList(rs, entityClass);
        });
    }
    
    public <T> Optional<T> findById(Class<T> entityClass, Object id) {
        return connectionManager.executeWithConnection(connection -> {
            String query = queryBuilder.buildSelectById(entityClass);
            PreparedStatement stmt = connection.prepareStatement(query);
            stmt.setObject(1, id);
            ResultSet rs = stmt.executeQuery();
            return resultMapper.mapToOptional(rs, entityClass);
        });
    }
    
    public <T> T save(T entity) {
        return connectionManager.executeWithTransaction(connection -> {
            if (entityHasId(entity)) {
                return updateEntity(connection, entity);
            } else {
                return insertEntity(connection, entity);
            }
        });
    }
    
    // 복잡한 내부 구현은 숨겨짐
    private <T> T updateEntity(Connection connection, T entity) {
        // 복잡한 업데이트 로직
        return entity;
    }
    
    private <T> T insertEntity(Connection connection, T entity) {
        // 복잡한 삽입 로직  
        return entity;
    }
}

 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

// 사용자 관리를 위한 Service Facade
public class UserManagementFacade {
    private final UserRepository userRepository;
    private final ProfileRepository profileRepository;
    private final AuthenticationService authService;
    private final AuthorizationService authzService;
    private final NotificationService notificationService;
    private final AuditService auditService;
    
    // 복잡한 사용자 등록 프로세스를 단순화
    public UserRegistrationResult registerUser(UserRegistrationRequest request) {
        return executeWithTransaction(() -> {
            // 1. 입력 검증
            validateRegistrationRequest(request);
            
            // 2. 중복 사용자 확인
            if (userRepository.existsByEmail(request.getEmail())) {
                throw new UserAlreadyExistsException("이미 등록된 이메일입니다");
            }
            
            // 3. 사용자 생성
            User user = createUser(request);
            User savedUser = userRepository.save(user);
            
            // 4. 프로필 생성
            UserProfile profile = createUserProfile(savedUser, request);
            profileRepository.save(profile);
            
            // 5. 초기 권한 설정
            authzService.assignDefaultRoles(savedUser);
            
            // 6. 환영 이메일 발송 (비동기)
            notificationService.sendWelcomeEmailAsync(savedUser);
            
            // 7. 감사 로그
            auditService.logUserRegistration(savedUser);
            
            return UserRegistrationResult.success(savedUser);
        });
    }
    
    // 복잡한 인증 프로세스 단순화
    public AuthenticationResult authenticateUser(String email, String password) {
        try {
            // 1. 사용자 존재 확인
            User user = userRepository.findByEmail(email)
                .orElseThrow(() -> new UserNotFoundException("사용자를 찾을 수 없습니다"));
            
            // 2. 계정 상태 확인
            validateAccountStatus(user);
            
            // 3. 비밀번호 검증
            if (!authService.verifyPassword(password, user.getPasswordHash())) {
                recordFailedAttempt(user);
                throw new InvalidCredentialsException("잘못된 비밀번호입니다");
            }
            
            // 4. 로그인 성공 처리
            recordSuccessfulLogin(user);
            String token = authService.generateToken(user);
            
            // 5. 세션 생성
            authService.createSession(user, token);
            
            return AuthenticationResult.success(user, token);
            
        } catch (Exception e) {
            auditService.logAuthenticationFailure(email, e.getMessage());
            throw e;
        }
    }
    
    // 내부 복잡성은 private 메서드로 숨김
    private void validateRegistrationRequest(UserRegistrationRequest request) {
        // 복잡한 검증 로직
    }
    
    private User createUser(UserRegistrationRequest request) {
        // 복잡한 사용자 생성 로직
        return new User();
    }
    
    private void validateAccountStatus(User user) {
        // 계정 상태 검증 로직
    }
}

 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

// 잘못된 Service (실제로는 Facade가 아님)
public class BadUserService {
    // 문제: 단순히 Repository 메서드를 위임하기만 함
    public User findById(Long id) {
        return userRepository.findById(id);  // 단순 위임
    }
    
    public User save(User user) {
        return userRepository.save(user);    // 단순 위임
    }
}

// 올바른 Facade (복잡한 비즈니스 로직 조합)
public class UserManagementFacade {
    // 여러 서비스를 조합한 복잡한 비즈니스 로직
    public UserProfileResult getUserProfile(Long userId) {
        // 1. 사용자 기본 정보
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException("사용자 없음"));
        
        // 2. 사용자 프로필
        UserProfile profile = profileRepository.findByUserId(userId);
        
        // 3. 권한 정보
        List<Role> roles = authzService.getUserRoles(userId);
        
        // 4. 활동 통계
        UserActivityStats stats = activityService.getUserStats(userId);
        
        // 5. 추천 정보
        List<Recommendation> recommendations = recommendationService.getRecommendations(userId);
        
        // 6. 결합된 결과 반환
        return UserProfileResult.builder()
            .user(user)
            .profile(profile)
            .roles(roles)
            .activityStats(stats)
            .recommendations(recommendations)
            .build();
    }
}

 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

// Adapter를 선택해야 하는 경우
class PaymentAdapterExample {
    /*
    시나리오:
    - 기존 결제 시스템 (Legacy) 존재
    - 새로운 표준 인터페이스 도입
    - 기존 시스템 변경 불가
    - 점진적 마이그레이션 필요
    */
    
    // 기존 시스템 (변경 불가)
    class LegacyPaymentSystem {
        public void processPayment(String cardNumber, double amount, String merchantId) {
            // 레거시 로직
        }
    }
    
    // 새로운 표준
    interface PaymentProcessor {
        PaymentResult process(PaymentRequest request);
    }
    
    // Adapter로 호환성 해결
    class LegacyPaymentAdapter implements PaymentProcessor {
        private final LegacyPaymentSystem legacy;
        
        @Override
        public PaymentResult process(PaymentRequest request) {
            // 인터페이스 변환
            legacy.processPayment(
                request.getCardNumber(), 
                request.getAmount(), 
                request.getMerchantId()
            );
            return new PaymentResult(true);
        }
    }
}

// Facade를 선택해야 하는 경우
class OrderFacadeExample {
    /*
    시나리오:
    - 여러 독립적인 서비스들 존재
    - 복잡한 비즈니스 플로우
    - 클라이언트에게 단순한 인터페이스 제공 필요
    - 서비스들 간의 조정 필요
    */
    
    // 복잡한 서브시스템들 (각각 독립적)
    class InventoryService { /* ... */ }
    class PaymentService { /* ... */ }
    class ShippingService { /* ... */ }
    class NotificationService { /* ... */ }
    
    // Facade로 복잡성 숨김
    class OrderProcessingFacade {
        // 여러 서비스를 조합하여 단순한 인터페이스 제공
        public OrderResult createOrder(OrderRequest request) {
            // 복잡한 조정 로직
            inventoryService.reserve(request.getItems());
            PaymentResult payment = paymentService.charge(request);
            shippingService.schedule(request.getAddress());
            notificationService.confirm(request.getCustomer());
            
            return OrderResult.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
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