구조 패턴(Structural Patterns): 객체 합성과 인터페이스 설계

// 기존 시스템의 레거시 결제 인터페이스
public class LegacyPaymentSystem {
    public boolean processPayment(String cardNumber, double amount, String currency) {
        // 레거시 로직...
        return true;
    }
}
 
// 새로운 표준 인터페이스
public interface PaymentProcessor {
    PaymentResult charge(PaymentRequest request);
}
 
// Adapter: 레거시 시스템을 새 인터페이스에 맞춤
public class LegacyPaymentAdapter implements PaymentProcessor {
    private final LegacyPaymentSystem legacySystem;
 
    public LegacyPaymentAdapter(LegacyPaymentSystem legacySystem) {
        this.legacySystem = legacySystem;
    }
 
    @Override
    public PaymentResult charge(PaymentRequest request) {
        boolean success = legacySystem.processPayment(
            request.getCardNumber(),
            request.getAmount().doubleValue(),
            request.getCurrency().getCode()
        );
        return new PaymentResult(success, success ? "OK" : "FAILED");
    }
}

┌─────────────────────────────────────────┐
│              Application Core           │
│  ┌─────────────────────────────────┐    │
│  │      Domain Logic (Ports)       │    │
│  └─────────┬───────────┬──────────┘    │
│            │           │                │
│  ┌─────────▼──┐  ┌─────▼──────────┐    │
│  │  Driving    │  │  Driven        │    │
│  │  Adapter    │  │  Adapter       │    │
│  │  (REST API) │  │  (PostgreSQL)  │    │
│  └────────────┘  └────────────────┘    │
└─────────────────────────────────────────┘

// 복잡한 하위 시스템들
public class InventoryService { /* 재고 관리 */ }
public class PaymentService { /* 결제 처리 */ }
public class ShippingService { /* 배송 관리 */ }
public class NotificationService { /* 알림 발송 */ }
public class FraudDetectionService { /* 사기 탐지 */ }
 
// Facade: 복잡한 주문 프로세스를 단순한 인터페이스로 제공
public class OrderFacade {
    private final InventoryService inventory;
    private final PaymentService payment;
    private final ShippingService shipping;
    private final NotificationService notification;
    private final FraudDetectionService fraud;
 
    public OrderFacade(InventoryService inventory, PaymentService payment,
                       ShippingService shipping, NotificationService notification,
                       FraudDetectionService fraud) {
        this.inventory = inventory;
        this.payment = payment;
        this.shipping = shipping;
        this.notification = notification;
        this.fraud = fraud;
    }
 
    // 클라이언트는 이 메서드만 호출하면 됨
    public OrderResult placeOrder(OrderRequest request) {
        // 1. 사기 탐지
        fraud.validate(request);
        // 2. 재고 확인 및 예약
        inventory.reserve(request.getItems());
        // 3. 결제 처리
        PaymentResult paymentResult = payment.charge(request.getPayment());
        // 4. 배송 요청
        ShippingLabel label = shipping.createLabel(request.getAddress());
        // 5. 알림 발송
        notification.sendOrderConfirmation(request.getCustomer());
 
        return new OrderResult(paymentResult, label);
    }
}

클라이언트 ──→ [API Gateway (Facade)] ──→ User Service
                                      ──→ Order Service
                                      ──→ Payment Service
                                      ──→ Inventory Service

// 기본 인터페이스
public interface DataService {
    Data fetch(String key);
}
 
// 기본 구현
public class RemoteDataService implements DataService {
    public Data fetch(String key) {
        return callRemoteApi(key);
    }
}
 
// Decorator: 로깅 추가
public class LoggingDecorator implements DataService {
    private final DataService delegate;
    private final Logger logger;
 
    public LoggingDecorator(DataService delegate, Logger logger) {
        this.delegate = delegate;
        this.logger = logger;
    }
 
    public Data fetch(String key) {
        logger.info("Fetching data for key: {}", key);
        long start = System.nanoTime();
        Data result = delegate.fetch(key);
        long elapsed = System.nanoTime() - start;
        logger.info("Fetched in {}ms", elapsed / 1_000_000);
        return result;
    }
}
 
// Decorator: 캐싱 추가
public class CachingDecorator implements DataService {
    private final DataService delegate;
    private final Cache cache;
 
    public CachingDecorator(DataService delegate, Cache cache) {
        this.delegate = delegate;
        this.cache = cache;
    }
 
    public Data fetch(String key) {
        Data cached = cache.get(key);
        if (cached != null) return cached;
        Data result = delegate.fetch(key);
        cache.put(key, result);
        return result;
    }
}
 
// Decorator: 재시도 추가
public class RetryDecorator implements DataService {
    private final DataService delegate;
    private final int maxRetries;
 
    public RetryDecorator(DataService delegate, int maxRetries) {
        this.delegate = delegate;
        this.maxRetries = maxRetries;
    }
 
    public Data fetch(String key) {
        for (int i = 0; i < maxRetries; i++) {
            try {
                return delegate.fetch(key);
            } catch (Exception e) {
                if (i == maxRetries - 1) throw e;
            }
        }
        throw new RuntimeException("Unreachable");
    }
}
 
// 조합: 로깅 → 캐싱 → 재시도 → 실제 호출
DataService service = new LoggingDecorator(
    new CachingDecorator(
        new RetryDecorator(
            new RemoteDataService(), 3
        ), redisCache
    ), logger
);

public interface UserRepository {
    User findById(String id);
    void delete(String id);
}
 
// 접근 제어 프록시
public class SecuredUserRepository implements UserRepository {
    private final UserRepository delegate;
    private final SecurityContext securityContext;
 
    public SecuredUserRepository(UserRepository delegate,
                                  SecurityContext securityContext) {
        this.delegate = delegate;
        this.securityContext = securityContext;
    }
 
    @Override
    public User findById(String id) {
        // 읽기는 인증만 확인
        securityContext.requireAuthentication();
        return delegate.findById(id);
    }
 
    @Override
    public void delete(String id) {
        // 삭제는 ADMIN 권한 필요
        securityContext.requireRole("ADMIN");
        delegate.delete(id);
    }
}

// Spring AOP: @Transactional은 Proxy로 구현됨
@Service
public class OrderService {
    @Transactional  // 이 메서드 호출 시 Proxy가 트랜잭션 시작/종료
    public void createOrder(OrderRequest request) {
        // 비즈니스 로직만 집중
    }
}

public interface FileSystemNode {
    String getName();
    long getSize();
    void print(String indent);
}
 
public class File implements FileSystemNode {
    private final String name;
    private final long size;
 
    public String getName() { return name; }
    public long getSize() { return size; }
    public void print(String indent) {
        System.out.println(indent + name + " (" + size + "B)");
    }
}
 
public class Directory implements FileSystemNode {
    private final String name;
    private final List<FileSystemNode> children = new ArrayList<>();
 
    public void add(FileSystemNode node) { children.add(node); }
    public String getName() { return name; }
 
    public long getSize() {
        return children.stream()
            .mapToLong(FileSystemNode::getSize)
            .sum(); // 재귀적으로 전체 크기 계산
    }
 
    public void print(String indent) {
        System.out.println(indent + name + "/");
        children.forEach(child -> child.print(indent + "  "));
    }
}

// 구현 (Implementation) 계층: 발송 채널
public interface NotificationChannel {
    void send(String recipient, String content);
}
public class EmailChannel implements NotificationChannel { /* ... */ }
public class SlackChannel implements NotificationChannel { /* ... */ }
public class SmsChannel implements NotificationChannel { /* ... */ }
 
// 추상화 (Abstraction) 계층: 알림 유형
public abstract class Notification {
    protected final NotificationChannel channel;
 
    public Notification(NotificationChannel channel) {
        this.channel = channel;
    }
 
    public abstract void notify(String recipient, Map<String, Object> data);
}
 
public class UrgentNotification extends Notification {
    public UrgentNotification(NotificationChannel channel) {
        super(channel);
    }
 
    public void notify(String recipient, Map<String, Object> data) {
        String content = "[URGENT] " + formatMessage(data);
        channel.send(recipient, content);
    }
}
 
public class ScheduledNotification extends Notification {
    // 예약 발송 로직...
}

┌─────────────────────────────┐
│          Pod (K8s)          │
│  ┌──────────┐ ┌──────────┐ │
│  │ Main     │ │ Sidecar  │ │
│  │ Service  │↔│ Proxy    │ │
│  │ (비즈니스 │ │ (Envoy)  │ │
│  │  로직)    │ │          │ │
│  └──────────┘ └──────────┘ │
└─────────────────────────────┘

Mobile App ──→ [Mobile BFF] ──→ User Service
                              ──→ Order Service (경량 응답)
 
Web App ────→ [Web BFF]    ──→ User Service
                              ──→ Order Service (상세 응답)
                              ──→ Analytics Service
 
Admin ──────→ [Admin BFF]  ──→ User Service (관리 기능)
                              ──→ Audit Service