2.2 도메인 모델 설계

// 빈약한 도메인 모델의 예시
public class Book {
    private String isbn;
    private String title;
    private String author;
    private BookStatus status;
    
    // 단순 getter/setter만 존재
    public String getIsbn() { return isbn; }
    public void setIsbn(String isbn) { this.isbn = isbn; }
    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }
    public BookStatus getStatus() { return status; }
    public void setStatus(BookStatus status) { this.status = status; }
}

// 도메인 로직이 서비스 계층에 존재
public class BookService {
    public void checkoutBook(Book book, Member member) {
        // 도메인 로직이 서비스 계층에 구현됨
        if (book.getStatus() != BookStatus.AVAILABLE) {
            throw new IllegalStateException("대출 불가능한 도서입니다.");
        }
        if (member.getCurrentCheckouts() >= member.getCheckoutLimit()) {
            throw new IllegalStateException("대출 한도를 초과했습니다.");
        }
        book.setStatus(BookStatus.CHECKED_OUT);
        // 추가 처리...
    }
}

public class Book {
    private final BookId id;
    private final ISBN isbn;
    private BookStatus status;
    private Member currentBorrower;
    private LocalDate dueDate;
    private final List<CheckoutRecord> checkoutHistory;

    // 생성자를 통한 유효성 검증
    public Book(BookId id, ISBN isbn) {
        this.id = Objects.requireNonNull(id, "도서 ID는 필수입니다");
        this.isbn = Objects.requireNonNull(isbn, "ISBN은 필수입니다");
        this.status = BookStatus.AVAILABLE;
        this.checkoutHistory = new ArrayList<>();
    }

    // 도메인 행위를 메서드로 표현
    public CheckoutResult checkoutTo(Member member, CheckoutPolicy policy) {
        // 도메인 규칙 검증
        if (status != BookStatus.AVAILABLE) {
            return CheckoutResult.failure("대출 가능한 상태가 아닙니다");
        }

        if (!policy.canCheckout(member)) {
            return CheckoutResult.failure("대출 자격이 없습니다");
        }

        // 상태 변경
        this.status = BookStatus.CHECKED_OUT;
        this.currentBorrower = member;
        this.dueDate = LocalDate.now().plusDays(policy.getLoanDuration());
        
        // 이력 기록
        CheckoutRecord record = new CheckoutRecord(member, LocalDateTime.now(), this.dueDate);
        this.checkoutHistory.add(record);

        // 도메인 이벤트 생성
        return CheckoutResult.success(new BookCheckedOutEvent(this.id, member.getId(), this.dueDate));
    }

    public ReturnResult returnBook() {
        if (status != BookStatus.CHECKED_OUT) {
            return ReturnResult.failure("대출 중인 도서가 아닙니다");
        }

        LocalDate returnDate = LocalDate.now();
        boolean isOverdue = returnDate.isAfter(dueDate);

        this.status = BookStatus.AVAILABLE;
        this.currentBorrower = null;
        this.dueDate = null;

        return ReturnResult.success(new BookReturnedEvent(this.id, returnDate, isOverdue));
    }

    // 불변식(invariant) 보장
    private void validateState() {
        if (status == BookStatus.CHECKED_OUT) {
            if (currentBorrower == null || dueDate == null) {
                throw new IllegalStateException("대출 중인 도서는 대출자와 반납일이 필수입니다");
            }
        }
    }
}

// 대출 정책을 별도의 클래스로 분리
public class CheckoutPolicy {
    public boolean canCheckout(Member member) {
        return !member.hasOverdueBooks() &&
                member.getCurrentCheckouts() < member.getCheckoutLimit();
    }

    public int getLoanDuration() {
        return 14; // 기본 대출 기간 14일
    }
}

// 팩토리를 통한 객체 생성
public class BookFactory {
    public Book createNewBook(ISBN isbn, String title, Author author) {
        // 식별자 생성
        BookId id = BookId.generate();
        
        // 도메인 객체 생성
        Book book = new Book(id, isbn);
        
        // 초기 메타데이터 설정
        book.updateMetadata(new BookMetadata(title, author));
        
        return book;
    }
}

// 리포지토리를 통한 영속성 관리
public interface BookRepository {
    Optional<Book> findById(BookId id);
    List<Book> findByStatus(BookStatus status);
    Book save(Book book);
    void delete(Book book);
}

public class OverdueManagementService {
    private final BookRepository bookRepository;
    private final NotificationService notificationService;

    public void handleOverdueBooks() {
        // 연체 도서 조회
        List<Book> overdueBooks = bookRepository.findOverdueBooks(LocalDate.now());
        
        for (Book book : overdueBooks) {
            // 연체 처리
            Member borrower = book.getCurrentBorrower();
            if (needsSuspension(borrower)) {
                borrower.suspend("장기 연체로 인한 자격 정지");
                notificationService.sendSuspensionNotice(borrower.getId());
            } else {
                notificationService.sendOverdueReminder(borrower.getId());
            }
        }
    }

    private boolean needsSuspension(Member borrower) {
        return borrower.getOverdueCount() >= 3 ||
               borrower.hasLongTermOverdue();
    }
}