Monolit mi, mikroservis mi?

1
// The only door into the account module. Other modules see this and nothing else.
2
public interface AccountFacade {
3

4
    Optional<AccountView> find(String iban);
5

6
    // Debit and credit in one local transaction: easy here, a saga once split.
7
    void move(String fromIban, String toIban, BigDecimal amount, String reference);
8
}
9

10
public record AccountView(String iban, String ownerName, BigDecimal available, boolean frozen) {
11
}

1
@Service
2
class AccountFacadeImpl implements AccountFacade {      // package-private: invisible outside
3

4
    private final AccountRepository accounts;           // internal too
5
    private final ApplicationEventPublisher events;
6

7
    AccountFacadeImpl(AccountRepository accounts, ApplicationEventPublisher events) {
8
        this.accounts = accounts;
9
        this.events = events;
10
    }
11

12
    @Override
13
    @Transactional(readOnly = true)
14
    public Optional<AccountView> find(String iban) {
15
        return accounts.findByIban(iban).map(Account::view);
16
    }
17

18
    @Override
19
    @Transactional
20
    public void move(String fromIban, String toIban, BigDecimal amount, String reference) {
21
        accounts.lockByIban(fromIban).debit(amount, reference);
22
        accounts.lockByIban(toIban).credit(amount, reference);
23
    }
24

25
    @Transactional
26
    public void freeze(String iban, String reason) {
27
        accounts.lockByIban(iban).freeze(reason);
28
        events.publishEvent(new AccountFrozen(iban, reason));   // who cares is not our business
29
    }
30
}

1
@Service
2
class TransferService {
3

4
    private final AccountFacade accounts;   // the api, never AccountRepository
5

6
    TransferService(AccountFacade accounts) {
7
        this.accounts = accounts;
8
    }
9

10
    @Transactional
11
    public TransferResult send(TransferCommand cmd) {
12
        AccountView from = accounts.find(cmd.fromIban()).orElseThrow(UnknownAccountException::new);
13
        if (from.frozen()) return TransferResult.rejected("ACCOUNT_FROZEN");
14
        if (from.available().compareTo(cmd.amount()) < 0) return TransferResult.rejected("INSUFFICIENT_FUNDS");
15
        accounts.move(cmd.fromIban(), cmd.toIban(), cmd.amount(), cmd.reference());
16
        return TransferResult.sent(cmd.reference());
17
    }
18
}

1
@Component
2
class StandingOrderSuspender {
3

4
    private final StandingOrderRepository standingOrders;
5

6
    StandingOrderSuspender(StandingOrderRepository standingOrders) {
7
        this.standingOrders = standingOrders;
8
    }
9

10
    // After the freeze commits, stop this account's standing orders.
11
    // Today an in-process event; after a split, the same event on Kafka.
12
    @TransactionalEventListener
13
    void on(AccountFrozen event) {
14
        standingOrders.suspendAllFrom(event.iban(), event.reason());
15
    }
16
}

1
@AnalyzeClasses(packages = "com.bank")
2
class ModuleBoundariesTest {
3

4
    // Nothing outside the account module may touch its internals.
5
    @ArchTest
6
    static final ArchRule accountInternalsStayInside = noClasses()
7
            .that().resideOutsideOfPackage("com.bank.account..")
8
            .should().dependOnClassesThat().resideInAPackage("com.bank.account.internal..");
9

10
    // Modules may use each other's api, but never in a circle: a cycle is two modules
11
    // that can only be split together, i.e. one module.
12
    @ArchTest
13
    static final ArchRule noCycles = slices().matching("com.bank.(*)..").should().beFreeOfCycles();
14

15
    // The card module holds card data (PCI scope): nothing else may depend on its internals,
16
    // so splitting it out later keeps the audit scope small.
17
    @ArchTest
18
    static final ArchRule cardIsIsolated = noClasses()
19
            .that().resideOutsideOfPackage("com.bank.card..")
20
            .should().dependOnClassesThat().resideInAPackage("com.bank.card.internal..");
21
}