现在我们开始实现第二个限界上下文——ATM。它要比SnackMachine要简单，只有取款和手续费等的功能。在这里，我们选择第一种代码隔离类型。

    1. package com.lugew.springbootddd.atm;
    4. import com.lugew.springbootddd.common.AggregateRoot;
    5. import com.lugew.springbootddd.sharedkernel.Money;
    6. import lombok.Getter;
    7. import lombok.Setter;
    9. import static com.lugew.springbootddd.sharedkernel.Money.None;
    11. @Getter
    12. @Setter
    13. public class Atm extends AggregateRoot {
    14.     private static float commissionRate = 0.01f;
    15.     private Money moneyInside = None;
    16.     private float moneyCharged;
    18.     public void takeMoney(float amount) {
    19.         Money output = moneyInside.allocate(amount);
    20.         moneyInside = moneyInside.substract(output);
    21.         float amountWithCommission = amount + amount * commissionRate;
    22.         moneyCharged += amountWithCommission;
    23.     }
    25.     public void loadMoney(Money money) {
    26.         moneyInside = moneyInside.add(money);
    27.     }
    28. }

    显然ATM是聚合根，它包含三个字段moneyInside和moneyCharged，和takeMoney取款和loadMoney存款方法。接下来为其添加测试

    1. package com.lugew.springbootddd.atm;
    3. import org.junit.Test;
    5. import static com.lugew.springbootddd.sharedkernel.Money.Dollar;
    6. import static org.junit.jupiter.api.Assertions.assertEquals;
    8. public class AtmTest {
    9.     @Test
    10.     public void take_money_exchanges_money_with_commission() {
    11.         Atm atm = new Atm();
    12.         atm.loadMoney(Dollar);
    13.         atm.takeMoney(1);
    14.         assertEquals(atm.getMoneyInside().getAmount(), 0, 0);
    15.         assertEquals(atm.getMoneyCharged(), 1.01, 0.001);
    16.     }
    17. }

    测试验证取款功能，且取款手续费为0.01。除此之外，还有其它需求，如取款0.01如何处理，取款1.10手续费是0.01还是0.02，这些需求可以咨询领域专家。假设手续费最低0.01且四舍五入计算。

    1.     @Test
    2.     public void commission_is_at_least_one_cent() {
    3.         Atm atm = new Atm();
    4.         atm.loadMoney(Cent);
    5.         atm.takeMoney(0.01f);
    6.         assertEquals(atm.getMoneyCharged(), 0.02, 0.001);
    7.     }
    9.     @Test
    10.     public void commission_is_rounded_up_to_the_next_cent() {
    11.         Atm atm = new Atm();
    12.         atm.loadMoney(Dollar.add(TenCent));
    13.         atm.takeMoney(1.1f);
    14.         assertEquals(atm.getMoneyCharged(), 1.12, 0.01);
    15.     }
    1. public void takeMoney(float amount) {
    2.         Money output = moneyInside.allocate(amount);
    3.         moneyInside = moneyInside.substract(output);
    4.         float amountWithCommission = calculateAmountWithCommission(amount);
    5.         moneyCharged += amountWithCommission;
    6.     }
    8.     public void loadMoney(Money money) {
    9.         moneyInside = moneyInside.add(money);
    10.     }
    12.     public float calculateAmountWithCommission(float amount) {
    13.         float commission = amount * commissionRate;
    14.         float lessThanCent = commission % 0.01f;
    15.         if (lessThanCent > 0) {
    16.             commission = commission - lessThanCent + 0.01f;
    17.         }
    18.         return amount + commission;
    19.     }

    还需添加一些验证：

    1.     public void takeMoney(float amount) {
    2.         if (!canTakeMoney(amount).equals("")) {
    3.             throw new IllegalStateException();
    4.         }
    5.         Money output = moneyInside.allocate(amount);
    6.         moneyInside = moneyInside.substract(output);
    7.         float amountWithCommission = calculateAmountWithCommission(amount);
    8.         moneyCharged += amountWithCommission;
    9.     }
    11.     public String canTakeMoney(float amount) {
    12.         if (amount <= 0f)
    13.             return "Invalid amount";
    14.         if (moneyInside.getAmount() < amount)
    15.             return "Not enough money";
    16.         if (!moneyInside.canAllocate(amount))
    17.             return "Not enough change";
    18.         return "";
    19.     }