[Clean Architecture] 34. 부분적 경계

 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

// 같은 패키지에 있지만 인터페이스로 분리
package com.example.order;

import jakarta.persistence.EntityManager;
import jakarta.persistence.Entity;
import java.util.Optional;

class Order {
    private final Long id;
    Order(Long id) { this.id = id; }
    Long getId() { return id; }
}

@Entity
class OrderEntity {
    static OrderEntity from(Order order) { return new OrderEntity(); }
    Order toDomain() { return new Order(1L); }
}

// 인터페이스
interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(Long id);
}

// 구현
class JpaOrderRepository implements OrderRepository {
    private final EntityManager em;

    public JpaOrderRepository(EntityManager em) { this.em = em; }

    @Override
    public void save(Order order) {
        em.persist(OrderEntity.from(order));
    }

    @Override
    public Optional<Order> findById(Long id) {
        return Optional.ofNullable(em.find(OrderEntity.class, id))
            .map(OrderEntity::toDomain);
    }
}

// 나중에 필요하면 별도 jar로 분리 가능!

 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

import java.math.BigDecimal;

class Order {
    private final BigDecimal total;
    Order(BigDecimal total) { this.total = total; }
    BigDecimal getTotal() { return total; }
}

class PaymentResult {
    private final boolean success;
    private final String transactionId;
    private PaymentResult(boolean success, String transactionId) {
        this.success = success; this.transactionId = transactionId;
    }
    static PaymentResult success(String transactionId) { return new PaymentResult(true, transactionId); }
    static PaymentResult failure() { return new PaymentResult(false, null); }
}

// 단방향 경계: 전략 패턴
public class PaymentService {
    private final PaymentStrategy strategy;  // 인터페이스

    public PaymentService(PaymentStrategy strategy) { this.strategy = strategy; }

    public PaymentResult process(Order order) {
        return strategy.charge(order.getTotal());
    }
}

// 전략 인터페이스
interface PaymentStrategy {
    PaymentResult charge(BigDecimal amount);
}

// 구체적인 전략들
class StripePaymentStrategy implements PaymentStrategy {
    public PaymentResult charge(BigDecimal amount) {
        // Stripe API 호출(실제로는 Stripe SDK를 사용한다)
        return PaymentResult.success("stripe-tx-" + System.nanoTime());
    }
}

class PayPalPaymentStrategy implements PaymentStrategy {
    public PaymentResult charge(BigDecimal amount) {
        // PayPal API 호출(실제로는 PayPal SDK를 사용한다)
        return PaymentResult.success("paypal-tx-" + System.nanoTime());
    }
}

 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

import java.util.List;
import java.math.BigDecimal;

class OrderItem { String productId; int quantity; }
class OrderRequest {
    private final List<OrderItem> items;
    private final BigDecimal payment;
    OrderRequest(List<OrderItem> items, BigDecimal payment) { this.items = items; this.payment = payment; }
    List<OrderItem> getItems() { return items; }
    BigDecimal getPayment() { return payment; }
}
class OrderResult {
    private final Long orderId;
    OrderResult(Long orderId) { this.orderId = orderId; }
}

interface OrderService {
    OrderResult create(OrderRequest request);
    void cancel(Long orderId);
}
interface PaymentService {
    void charge(BigDecimal payment);
    void refund(Long orderId);
}
interface InventoryService {
    void reserve(List<OrderItem> items);
    void release(Long orderId);
}

// 퍼사드: 내부 구현을 숨김
public class OrderFacade {
    private final OrderService orderService;
    private final PaymentService paymentService;
    private final InventoryService inventoryService;

    public OrderFacade(OrderService orderService, PaymentService paymentService, InventoryService inventoryService) {
        this.orderService = orderService;
        this.paymentService = paymentService;
        this.inventoryService = inventoryService;
    }

    // 클라이언트는 퍼사드만 사용
    public OrderResult placeOrder(OrderRequest request) {
        // 내부 서비스들 조합
        inventoryService.reserve(request.getItems());
        paymentService.charge(request.getPayment());
        return orderService.create(request);
    }

    public void cancelOrder(Long orderId) {
        orderService.cancel(orderId);
        paymentService.refund(orderId);
        inventoryService.release(orderId);
    }

    // 내부 서비스들은 외부에 노출되지 않음
}

1
2
3
4
5
6
7
8
9

class Notification { String message; }
class Customer {
    boolean hasMobile() { return true; }
}
class Order {
    private final Customer customer;
    Order(Customer customer) { this.customer = customer; }
    Customer getCustomer() { return customer; }
}

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

// 완전한 경계: 별도 컴포넌트
// notification-api.jar
interface NotificationGateway {
    void send(Notification notification);
}

// notification-email.jar (별도 배포)
public class EmailNotificationGateway implements NotificationGateway {
    public void send(Notification notification) {
        // 이메일 발송(실제로는 SMTP 클라이언트를 사용한다)
        System.out.println("email: " + notification.message);
    }
}

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

// 부분적 경계 1: 마지막 단계 건너뛰기
// 같은 jar에 있지만 인터페이스 분리(위 공유 타입과 같은 패키지에 둔다)
interface NotificationGateway {
    void send(Notification notification);
}

public class EmailNotificationGateway implements NotificationGateway {
    // 같은 패키지, 나중에 분리 가능
    public void send(Notification notification) {
        System.out.println("email: " + notification.message);
    }
}

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

// 부분적 경계 2: 단방향 경계
interface NotificationSender {
    void sendOrderConfirmation(Order order);
}

public class OrderService {
    private final NotificationSender sender;  // 단방향

    public OrderService(NotificationSender sender) { this.sender = sender; }

    public void placeOrder(Order order) {
        // 주문 처리
        sender.sendOrderConfirmation(order);
    }
}

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

// 부분적 경계 3: 퍼사드
interface EmailService { void sendOrderConfirmation(Order order); }
interface SmsService { void sendOrderConfirmation(Order order); }
interface PushService { void sendOrderConfirmation(Order order); }

public class NotificationFacade {
    private final EmailService email;
    private final SmsService sms;
    private final PushService push;

    public NotificationFacade(EmailService email, SmsService sms, PushService push) {
        this.email = email;
        this.sms = sms;
        this.push = push;
    }

    public void notifyOrderPlaced(Order order) {
        email.sendOrderConfirmation(order);
        if (order.getCustomer().hasMobile()) {
            sms.sendOrderConfirmation(order);
        }
    }
}