도메인 주도 설계의 사실과 오해 2부 (2) 유연한 설계를 향한 리팩터링

public class Share extends ValueObject<Share> { private Company company; private Money amount; public Share prorate(Money amount, Money total) { return new Share(company, amount.times(this.amount).divide(total)); } public Share plus(Share other) { return new Share(company, this.amount.plus(other.amount)); } public Share minus(Share other) { return new Share(company, this.amount.minus(other.amount)); } }

┌──────────────────────────────┐ ┌──────────────────────────────┐ │ <<aggregate>> Facility │ │ <<entity>> Loan │ ├──────────────────────────────┤ ├──────────────────────────────┤ │ takeOutLoan(Money) │───────>│ increase(Map<Company,Share>)│ │ takeOutLoan(Share...) │ │ │ └──────────┬───────────────────┘ └──────────────┬───────────────┘ │ Company │ Company │ │ ▼ ▼ ┌──────────────────────────────────────────────────────────────────────┐ │ <<value>> Share │ ├──────────────────────────────────────────────────────────────────────┤ │ company : Company │ │ amount : Money │ ├──────────────────────────────────────────────────────────────────────┤ │ prorate(Money, Money) : Share │ │ plus(Share) : Share │ │ minus(Share) : Share │ └──────────────────────────────────────────────────────────────────────┘

public class Facility extends AggregateRoot<Facility, Long> { private Long id; private Map<Company, Share> shares = new HashMap<>(); public void takeOutLoan(Money amount) { if (loan.amount().plus(amount).isGreaterThan(limit())) { throw new IllegalStateException(); } Map<Company, Share> sharesToAdd = new HashMap<>(); for (var owner : shares.keySet()) { sharesToAdd.put(owner, shares.get(owner).prorate(amount, limit())); } loan.increase(sharesToAdd); } }

// 퍼실리티의 지분과 무관한 별도 지분으로 대출 public void takeOutLoan(Share... shares) { if (loan.amount().plus(sum(Arrays.stream(shares).toList())) .isGreaterThan(limit())) { throw new IllegalStateException(); } loan.increase( Arrays.stream(shares) .collect(toMap(Share::company, identity()))); }

facility.takeOutLoan(Money.won(100)); facility.takeOutLoan(Money.won(200)); // B의 현재 금액 60원에서 2/3에 해당하는 금액 40원을 C로 이동 facility.transfer(companyB, companyC, 2.0 / 3.0);

// 퍼실리티의 지분에 따라 배당 facility.takeOutLoan(Money.won(100)); // 퍼실리티의 지분을 무시하고 명시적으로 지분 지정 facility.takeOutLoan( new Share(companyA, Money.won(100)), new Share(companyC, Money.won(100)));

public class Paint { private double v; private int r; private int y; private int b; public void paint(Paint paint) { double totalV = v + paint.getV(); r = (int) Math.round((r * v + paint.getR() * paint.getV()) / totalV); y = (int) Math.round((y * v + paint.getY() * paint.getV()) / totalV); b = (int) Math.round((b * v + paint.getB() * paint.getV()) / totalV); v = totalV; } }

public class Paint { private double volume; private int red; private int yellow; private int blue; public void mixin(Paint paint) { double totalVolume = volume + paint.getVolume(); red = (int) Math.round( (red * volume + paint.getRed() * paint.getVolume()) / totalVolume); yellow = (int) Math.round( (yellow * volume + paint.getYellow() * paint.getVolume()) / totalVolume); blue = (int) Math.round( (blue * volume + paint.getBlue() * paint.getVolume()) / totalVolume); volume = totalVolume; } }

// Before: 무슨 뜻인지 모름 yellow.paint(blue); // After: "노란색 페인트에 파란색 페인트를 혼합한다" outPaint.mixin(blue);

boolean includes(LocalDate day); // ← 쿼리: 부수효과 없음, 몇 번 호출해도 결과 동일 void schedule(LocalDate day); // ← 명령: 부수효과 발생, 호출할 때마다 상태 변경

public class PigmentColor extends ValueObject<PigmentColor> { private int red; private int yellow; private int blue; public PigmentColor mixin(PigmentColor other, double volume, double otherVolume) { double totalVolume = volume + otherVolume; return new PigmentColor( (int) Math.round((red * volume + other.red * otherVolume) / totalVolume), (int) Math.round((yellow * volume + other.yellow * otherVolume) / totalVolume), (int) Math.round((blue * volume + other.blue * otherVolume) / totalVolume)); } }

public class Paint { private double volume; private PigmentColor pigmentColor; public Paint mixin(Paint paint) { return new Paint( volume + paint.getVolume(), pigmentColor.mixin(paint.getPigmentColor(), volume, paint.getVolume())); } }

@Test public void paint() { Paint outPaint = new Paint(100.0, new PigmentColor(0, 50, 0)); Paint blue = new Paint(100.0, new PigmentColor(0, 0, 50)); Paint mixed = outPaint.mixin(blue); // 혼합 후 용량은 두 페인트의 합이어야 한다 assertThat(mixed.getVolume()).isEqualTo(200.0); assertThat(mixed.getPigmentColor()).isEqualTo(new PigmentColor(0, 25, 25)); // 원본 페인트는 변하지 않아야 한다 assertThat(outPaint.getVolume()).isEqualTo(100.0); assertThat(blue.getVolume()).isEqualTo(100.0); }

// SharePie끼리 자유롭게 조합할 수 있다 SharePie result = pieA.plus(pieB).minus(pieC);

public class Loan extends DomainEntity<Loan, Long> { private Map<Company, Share> shares = new HashMap<>(); public Set<Share> distributePrincipalPayment(Money amount) { Set<Share> result = new HashSet<>(); for (var owner : shares.keySet()) { Share paymentShare = shares.get(owner).prorate(amount, amount()); result.add(paymentShare); shares.put(owner, shares.get(owner).minus(paymentShare)); } return result; } }

// 퍼실리티의 지분을 무시하고 명시적으로 지분 지정 facility.takeOutLoan( new Share(companyA, Money.won(60)), new Share(companyB, Money.won(30)), new Share(companyC, Money.won(10))); // 10원 상환 → 대출 지분(60:30:10)에 따라 배분 Set<Share> repays = facility.repay(Money.won(10)); assertThat(repays).contains(new Share(companyA, Money.won(6))); assertThat(repays).contains(new Share(companyB, Money.won(3))); assertThat(repays).contains(new Share(companyC, Money.won(1)));

public class Loan extends DomainEntity<Loan, Long> { private Map<Company, Share> shares = new HashMap<>(); // 쿼리: 상환금 분배 계산 (Side-Effect-Free) public Set<Share> calculateRepayments(Money amount) { Set<Share> result = new HashSet<>(); for (var owner : shares.keySet()) { result.add(shares.get(owner).prorate(amount, amount())); } return result; } // 명령: 대출 지분 변경 public void applyRepayments(Set<Share> paymentShares) { for (var paymentShare : paymentShares) { shares.put( paymentShare.company(), shares.get(paymentShare.company()).minus(paymentShare)); } } }

public class Facility extends AggregateRoot<Facility, Long> { // 쿼리: 상태 변경 없이 배분된 금액만 반환 public Set<Share> estimateRepayments(Money amount) { return loan.calculateRepayments(amount); } // 명령: 쿼리를 조합해서 실행 public void repay(Money amount) { loan.applyRepayments(loan.calculateRepayments(amount)); } }

public class SharePie extends ValueObject<SharePie> { private Map<Company, Share> shares = new HashMap<>(); public SharePie prorate(Money amount) { Map<Company, Share> result = new HashMap<>(); for (var owner : shares.keySet()) { result.put(owner, shares.get(owner).prorate(amount, sum())); } return new SharePie(result); } public SharePie plus(SharePie other) { Map<Company, Share> result = new HashMap<>(); for (Share share : this.shares.values()) { result.put(share.company(), share.plus(other.shareOf(share.company()))); } return new SharePie(result); } public SharePie minus(SharePie other) { Map<Company, Share> result = new HashMap<>(); for (Share share : this.shares.values()) { result.put(share.company(), share.minus(other.shareOf(share.company()))); } return new SharePie(result); } }

// Before public class Loan extends DomainEntity<Loan, Long> { private Map<Company, Share> shares = new HashMap<>(); public void increase(Map<Company, Share> sharesToAdd) { for (var owner : sharesToAdd.keySet()) { shares.put(owner, shares.get(owner).plus(sharesToAdd.get(owner))); } } public Set<Share> calculateRepayments(Money amount) { Set<Share> result = new HashSet<>(); for (var owner : shares.keySet()) { result.add(shares.get(owner).prorate(amount, amount())); } return result; } public void applyRepayments(Set<Share> paymentShares) { for (var paymentShare : paymentShares) { shares.put(paymentShare.company(), shares.get(paymentShare.company()).minus(paymentShare)); } } } // After public class Loan extends DomainEntity<Loan, Long> { private SharePie sharePie; public void increase(SharePie other) { this.sharePie = this.sharePie.plus(other); } public SharePie calculateRepayments(Money amount) { return sharePie.prorate(amount); } public void applyRepayments(SharePie repayments) { this.sharePie = this.sharePie.minus(repayments); } }

public class Facility extends AggregateRoot<Facility, Long> { private Loan loan; private SharePie sharePie; public void takeOutLoan(Money amount) { if (loan.amount().plus(amount).isGreaterThan(sharePie.sum())) { throw new IllegalStateException(); } loan.increase(this.sharePie.prorate(amount)); } public void takeOutLoan(SharePie sharePie) { if (loan.amount().plus(sharePie.sum()).isGreaterThan(this.sharePie.sum())) { throw new IllegalStateException(); } loan.increase(sharePie); } }

public class Facility { private Loan loan; private SharePie sharePie; public SharePie distributeCharge(Money charge) { return sharePie.prorate(charge); } }

// 수수료 10원 납부 → 퍼실리티 지분(500:200:300)에 따라 배분 SharePie charge = facility.distributeCharge(Money.won(10)); assertThat(charge.amountOf(companyA)).isEqualTo(Money.won(5)); assertThat(charge.amountOf(companyB)).isEqualTo(Money.won(2)); assertThat(charge.amountOf(companyC)).isEqualTo(Money.won(3));

┌──────────────────────────────┐ ┌──────────────────────────────┐ │ <<aggregate>> Facility │ │ <<entity>> Loan │ ├──────────────────────────────┤ ├──────────────────────────────┤ │ takeOutLoan(Money) │───────>│ increase(SharePie) │ │ takeOutLoan(SharePie) │ │ calculateRepayments(Money) │ │ distributeCharge(Money) │ │ : SharePie │ └──────────┬───────────────────┘ │ applyRepayments(SharePie) │ │ └──────────────┬───────────────┘ │ │ ▼ ▼ ┌──────────────────────────────────────────────────────────────────────┐ │ <<value>> SharePie │ ├──────────────────────────────────────────────────────────────────────┤ │ prorate(Money) : SharePie │ │ plus(SharePie) : SharePie │ │ minus(SharePie) : SharePie │ ├──────────────────────────────────────────────────────────────────────┤ │ Company │ │ │ │ │ ▼ │ │ <<value>> Share │ │ company : Company │ │ amount : Money │ └──────────────────────────────────────────────────────────────────────┘