2.3 아키텍처 패턴 비교

// 프레젠테이션 계층: 사용자 인터페이스를 담당합니다
@RestController
public class BookController {
    private final BookService bookService;
    
    @PostMapping("/books/{bookId}/checkout")
    public ResponseEntity<CheckoutDTO> checkoutBook(
            @PathVariable String bookId, 
            @RequestBody CheckoutRequest request) {
        CheckoutDTO result = bookService.checkout(bookId, request);
        return ResponseEntity.ok(result);
    }
}

// 비즈니스 계층: 업무 규칙과 로직을 처리합니다
@Service
public class BookService {
    private final BookRepository bookRepository;
    private final MemberRepository memberRepository;
    
    @Transactional
    public CheckoutDTO checkout(String bookId, CheckoutRequest request) {
        // 엔티티 조회
        Book book = bookRepository.findById(bookId)
                    .orElseThrow(() -> new BookNotFoundException(bookId));
        Member member = memberRepository.findById(request.getMemberId())
                    .orElseThrow(() -> new MemberNotFoundException(request.getMemberId()));
        
        // 비즈니스 로직 처리
        if (!book.isAvailable()) {
            throw new BookNotAvailableException(bookId);
        }
        
        if (member.hasOverdueBooks()) {
            throw new OverdueBooksException(member.getId());
        }
        
        // 상태 변경
        book.setStatus(BookStatus.CHECKED_OUT);
        book.setBorrower(member);
        book.setDueDate(LocalDate.now().plusDays(14));
        
        // 저장
        bookRepository.save(book);
        
        return new CheckoutDTO(book);
    }
}

// 데이터 접근 계층: 데이터의 영속성을 관리합니다
@Repository
public interface BookRepository extends JpaRepository<Book, String> {
    Optional<Book> findById(String id);
    List<Book> findByStatus(BookStatus status);
}

// 엔티티 계층: 핵심 비즈니스 규칙을 포함합니다
public class Book {
    private final BookId id;
    private BookStatus status;
    private Member borrower;
    private LocalDate dueDate;

    public CheckoutResult checkout(Member member, CheckoutRule rule) {
        // 순수한 도메인 로직
        if (!rule.canCheckout(member)) {
            return CheckoutResult.failure("대출 자격이 없습니다");
        }
        
        if (status != BookStatus.AVAILABLE) {
            return CheckoutResult.failure("현재 대출 불가능한 상태입니다");
        }
        
        this.status = BookStatus.CHECKED_OUT;
        this.borrower = member;
        this.dueDate = LocalDate.now().plusDays(rule.getLoanDuration());
        
        return CheckoutResult.success();
    }
}

// 유스케이스 계층: 애플리케이션 특화 비즈니스 규칙을 구현합니다
public class CheckoutBookUseCase {
    private final BookRepository bookRepository;
    private final MemberRepository memberRepository;
    
    public CheckoutResult execute(CheckoutCommand command) {
        Book book = bookRepository.findById(command.getBookId())
            .orElseThrow(() -> new BookNotFoundException(command.getBookId()));
            
        Member member = memberRepository.findById(command.getMemberId())
            .orElseThrow(() -> new MemberNotFoundException(command.getMemberId()));
        
        CheckoutResult result = book.checkout(member, new CheckoutRule());
        
        if (result.isSuccess()) {
            bookRepository.save(book);
        }
        
        return result;
    }
}

// 인터페이스 어댑터 계층: 외부 인터페이스를 내부 로직에 맞게 변환합니다
@RestController
public class BookController {
    private final CheckoutBookUseCase checkoutBookUseCase;
    
    @PostMapping("/books/{bookId}/checkout")
    public ResponseEntity<CheckoutResponse> checkout(
            @PathVariable String bookId, 
            @RequestBody CheckoutRequest request) {
        CheckoutCommand command = new CheckoutCommand(bookId, request.getMemberId());
        CheckoutResult result = checkoutBookUseCase.execute(command);
        return ResponseEntity.ok(new CheckoutResponse(result));
    }
}

// 포트: 외부와의 상호작용을 정의하는 인터페이스입니다
public interface BookRepository {
    Optional<Book> findById(BookId id);
    void save(Book book);
}

// 어댑터: 포트의 실제 구현을 제공합니다
@Repository
public class JpaBookRepository implements BookRepository {
    private final JpaBookEntityRepository jpaRepository;
    private final BookMapper mapper;
    
    @Override
    public Optional<Book> findById(BookId id) {
        return jpaRepository.findById(id.getValue())
                .map(mapper::toDomain);
    }
    
    @Override
    public void save(Book book) {
        BookEntity entity = mapper.toEntity(book);
        jpaRepository.save(entity);
    }
}

// 도메인 모델 (가장 안쪽 계층)
public class Book {
    // 순수한 도메인 로직
    public CheckoutResult checkout(Member member) {
        // 도메인 규칙 검증 및 상태 변경
    }
}

// 도메인 서비스 계층
public class CheckoutService {
    private final BookRepository repository;
    
    public CheckoutResult checkout(BookId bookId, MemberId memberId) {
        // 도메인 객체 조율
    }
}

// 애플리케이션 서비스 계층
public class CheckoutApplicationService {
    private final CheckoutService checkoutService;
    private final NotificationService notificationService;
    
    @Transactional
    public CheckoutResult checkout(CheckoutRequest request) {
        CheckoutResult result = checkoutService.checkout(
            request.getBookId(), 
            request.getMemberId()
        );
        
        if (result.isSuccess()) {
            notificationService.notifyCheckout(result.getCheckout());
        }
        
        return result;
    }
}