[Clean Architecture] 00. 클린 아키텍처 개요

 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

import java.util.List;

// 보조 타입
class OrderId { OrderId(String id) {} }
class CustomerId { CustomerId(String id) {} }
enum OrderStatus { PENDING, CONFIRMED, CANCELLED }
class Money {
    static final Money ZERO = new Money();
    Money add(Money other) { return this; }
}
class OrderItem { Money getSubtotal() { return Money.ZERO; } }
class OrderCannotBeCancelledException extends RuntimeException {
    OrderCannotBeCancelledException(OrderId id) { super("cannot cancel: " + id); }
}

public class Order {
    private OrderId id;
    private CustomerId customerId;
    private List<OrderItem> items;
    private OrderStatus status;
    
    public Money calculateTotal() {
        return items.stream()
            .map(OrderItem::getSubtotal)
            .reduce(Money.ZERO, Money::add);
    }
    
    public boolean canBeCancelled() {
        return status == OrderStatus.PENDING 
            || status == OrderStatus.CONFIRMED;
    }
    
    public void cancel() {
        if (!canBeCancelled()) {
            throw new OrderCannotBeCancelledException(id);
        }
        this.status = OrderStatus.CANCELLED;
    }
}

 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

import java.util.List;
import java.util.Optional;

// 보조 타입(엔티티는 위 "엔티티" 절과 동일)
class CustomerId { CustomerId(String id) {} }
class PaymentMethod {}
class Customer {
    PaymentMethod getPaymentMethod() { return new PaymentMethod(); }
}
class Money { static final Money ZERO = new Money(); }
class OrderItem {}
class OrderId {}
class Order {
    static Order create(Customer customer, List<OrderItem> items) { return new Order(); }
    Money calculateTotal() { return Money.ZERO; }
    void confirm(String transactionId) {}
    OrderId getId() { return new OrderId(); }
}
class PlaceOrderRequest {
    CustomerId getCustomerId() { return new CustomerId("c1"); }
    List<OrderItem> getItems() { return List.of(); }
}
class PlaceOrderResponse { PlaceOrderResponse(OrderId id) {} }
class PaymentResult {
    boolean isSuccessful() { return true; }
    String getErrorMessage() { return ""; }
    String getTransactionId() { return "tx1"; }
}
class CustomerNotFoundException extends RuntimeException {
    CustomerNotFoundException(CustomerId id) { super("customer not found"); }
}
interface PlaceOrderInputBoundary { void execute(PlaceOrderRequest request); }
interface PlaceOrderOutputBoundary {
    void presentPaymentFailure(String message);
    void presentSuccess(PlaceOrderResponse response);
}
interface OrderRepository { void save(Order order); }
interface CustomerRepository { Optional<Customer> findById(CustomerId id); }
interface PaymentGateway { PaymentResult charge(PaymentMethod method, Money amount); }

public class PlaceOrderUseCase implements PlaceOrderInputBoundary {
    private final OrderRepository orderRepository;
    private final CustomerRepository customerRepository;
    private final PaymentGateway paymentGateway;
    private final PlaceOrderOutputBoundary presenter;
    
    public PlaceOrderUseCase(
        OrderRepository orderRepository,
        CustomerRepository customerRepository,
        PaymentGateway paymentGateway,
        PlaceOrderOutputBoundary presenter
    ) {
        this.orderRepository = orderRepository;
        this.customerRepository = customerRepository;
        this.paymentGateway = paymentGateway;
        this.presenter = presenter;
    }
    
    @Override
    public void execute(PlaceOrderRequest request) {
        Customer customer = customerRepository.findById(request.getCustomerId())
            .orElseThrow(() -> new CustomerNotFoundException(request.getCustomerId()));
        
        Order order = Order.create(customer, request.getItems());
        
        PaymentResult paymentResult = paymentGateway.charge(
            customer.getPaymentMethod(),
            order.calculateTotal()
        );
        
        if (!paymentResult.isSuccessful()) {
            presenter.presentPaymentFailure(paymentResult.getErrorMessage());
            return;
        }
        
        order.confirm(paymentResult.getTransactionId());
        orderRepository.save(order);
        presenter.presentSuccess(new PlaceOrderResponse(order.getId()));
    }
}

 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

import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Repository;

// 보조 타입
class OrderId {}
class Order {}
class OrderEntity {}
class PlaceOrderRequest {}
class OrderResponseDto {}
class PlaceOrderRequestDto {
    PlaceOrderRequest toUseCaseRequest() { return new PlaceOrderRequest(); }
}
interface PlaceOrderInputBoundary { void execute(PlaceOrderRequest request); }
interface OrderRepository { void save(Order order); }
interface OrderJpaRepository { void save(OrderEntity entity); }
class OrderMapper { OrderEntity toEntity(Order order) { return new OrderEntity(); } }

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    private final PlaceOrderInputBoundary placeOrderUseCase;
    
    public OrderController(PlaceOrderInputBoundary placeOrderUseCase) {
        this.placeOrderUseCase = placeOrderUseCase;
    }
    
    @PostMapping
    public ResponseEntity<OrderResponseDto> placeOrder(
        @RequestBody PlaceOrderRequestDto requestDto
    ) {
        PlaceOrderRequest request = requestDto.toUseCaseRequest();
        placeOrderUseCase.execute(request);
        return ResponseEntity.ok().build();
    }
}

@Repository
public class JpaOrderRepository implements OrderRepository {
    private final OrderJpaRepository jpaRepository;
    private final OrderMapper mapper;
    
    public JpaOrderRepository(OrderJpaRepository jpaRepository, OrderMapper mapper) {
        this.jpaRepository = jpaRepository;
        this.mapper = mapper;
    }
    
    @Override
    public void save(Order order) {
        OrderEntity entity = mapper.toEntity(order);
        jpaRepository.save(entity);
    }
}