Zengin Domain Modeli — JPA Entity'de Kapsülleme

Bir kuralı yalnızca kapıdaki görevli biliyorsa, arka kapıdan giren onu hiç duymaz.

Spring Boot projelerinin çoğunda aynı ikili vardır: her alanı setter’lı bir @Entity ve bütün kuralları bilen bir OrderService. Çalışır — ta ki biri servisi atlayıp entity’ye doğrudan dokunana kadar.

Kural herkeste, sahibi kimsede

Tanıdık bir kod:

1
@Entity
2
@Getter @Setter
3
public class Order {
4
    @Id @GeneratedValue private Long id;
5
    @OneToMany(cascade = ALL) private List<OrderLine> lines = new ArrayList<>();
6
    private BigDecimal total = BigDecimal.ZERO;
7
    private Status status = Status.NEW;
8
}
9

10
@Service
11
public class OrderService {
12
    public void addLine(Order order, Product p, int qty, BigDecimal price) {
13
        if (qty <= 0) throw new IllegalArgumentException("miktar > 0 olmalı");
14
        order.getLines().add(new OrderLine(p, qty, price));
15
        order.setTotal(order.getTotal().add(price.multiply(BigDecimal.valueOf(qty))));
16
    }
17
}

Buna anemik model?Terimin tanımını açanemik modelYalnızca alan ve getter/setter taşıyan, kuralları başka bir sınıfa (genellikle bir Service) bırakan domain nesnesi. Veri bir yerde, onu koruyan kural başka yerdedir.Sözlükte gör → denir: veri Order’da, onu koruyan kural OrderService’te. Kural ancak çağıran servisten geçerse çalışır.

Sorun şu: getLines() ve setTotal() herkese açık. Başka bir servis, bir batch işi ya da bir test aynı işi servisten geçmeden yapabilir. O zaman miktar kontrolü de toplam hesabı da atlanır.

Satır satır: kuralı entity’ye taşımak

Aynı kural, bu kez koruduğu verinin yanında. Siparişin geçerli kalması için her zaman doğru olması gereken şeylere değişmez kural?Terimin tanımını açdeğişmez kuralNesne var olduğu sürece doğru kalması gereken şey. Kapsüllemenin ölçütü kaç alanın private olduğu değil, hangi kuralın dışarıdan bozulamadığıdır.Bir setter, koruduğu kural varsa onu atlanabilir kılar. Kuralı metodun içine koymak (withdraw gibi) nesneyi geçersiz duruma düşürmeyi imkânsız hâle getirir.Sözlükte gör → denir ve bu kurallar artık yalnızca Order’ın metotlarından geçerek değiştirilebilir.

Dikkat: setTotal yok. Toplam hesaplanır, atanmaz — bu yüzden onu satırlardan koparacak bir kod yazmak derlenmez bile.

JPA ile uyumlu bir zengin entity

Zengin model JPA ile çatışmaz, yalnızca birkaç kurala uyman gerekir:

Nesneyi oluşturmanın anlamlı yolu da bir fabrika metodu olabilir: Order.placeBy(customerId). Böylece “müşterisi olmayan sipariş” diye bir ara durum hiç oluşmaz.

Sipariş ve satırları birlikte tutarlı kalması gereken bir küme. Bu kümeye aggregate?Terimin tanımını açaggregateBirlikte tutarlı kalması gereken ve tek bir kök nesne üzerinden değiştirilen nesne kümesi. Dışarıdan yalnızca köke erişilir; başka aggregate'lara id ile referans verilir.Sözlükte gör → denir: dışarıdan yalnızca köke (Order) erişilir, OrderLine’a doğrudan dokunulmaz.

Aynı fikir bir banka hesabında da çok doğal durur. Bakiye ve hesap hareketleri birlikte değişir, kilit de hesabın kendisindedir.

1
@Entity
2
public class Account {
3

4
    @Id @GeneratedValue private Long id;
5
    private Long customerId;              // other aggregates are referenced by id
6
    private Iban iban;
7

8
    @Embedded private Money balance;
9

10
    @Enumerated(EnumType.STRING) private AccountStatus status;
11

12
    @OneToMany(mappedBy = "account", cascade = CascadeType.ALL, orphanRemoval = true)
13
    private List<AccountEntry> entries = new ArrayList<>();
14

15
    protected Account() {
16
        // for JPA only
17
    }
18

19
    public static Account open(Long customerId, Iban iban, Currency currency) {
20
        Account account = new Account();
21
        account.customerId = customerId;
22
        account.iban = iban;
23
        account.balance = new Money(BigDecimal.ZERO, currency);
24
        account.status = AccountStatus.ACTIVE;
25
        return account;
26
    }
27

28
    public void deposit(Money amount, String description) {
29
        requireActive();
30
        balance = balance.plus(amount);
31
        entries.add(new AccountEntry(this, amount, EntryType.CREDIT, description));
32
    }
33

34
    public void withdraw(Money amount, String description) {
35
        requireActive();
36
        if (balance.isLessThan(amount)) throw new IllegalStateException("insufficient balance");
37
        balance = balance.minus(amount);
38
        entries.add(new AccountEntry(this, amount, EntryType.DEBIT, description));
39
    }
40

41
    public void freeze() {
42
        status = AccountStatus.FROZEN;
43
    }
44

45
    public Money balance() { return balance; }
46
    public List<AccountEntry> entries() { return List.copyOf(entries); }
47

48
    private void requireActive() {
49
        if (status != AccountStatus.ACTIVE) throw new IllegalStateException("account is " + status);
50
    }
51
}

1
@Entity
2
public class AccountEntry {
3

4
    @Id @GeneratedValue private Long id;
5
    @ManyToOne(fetch = FetchType.LAZY) private Account account;
6
    @Embedded private Money amount;
7
    @Enumerated(EnumType.STRING) private EntryType type;
8
    private String description;
9

10
    protected AccountEntry() {
11
        // for JPA only
12
    }
13

14
    // Package-private: only Account, in the same package, creates entries.
15
    AccountEntry(Account account, Money amount, EntryType type, String description) {
16
        this.account = account;
17
        this.amount = amount;
18
        this.type = type;
19
        this.description = description;
20
    }
21
}

1
@Service
2
public class WithdrawalService {
3

4
    private final AccountRepository accounts;
5
    private final FraudCheck fraudCheck;
6

7
    WithdrawalService(AccountRepository accounts, FraudCheck fraudCheck) {
8
        this.accounts = accounts;
9
        this.fraudCheck = fraudCheck;
10
    }
11

12
    // The service opens the transaction and talks to other systems.
13
    // The balance rule is not here: it lives in Account.withdraw.
14
    @Transactional
15
    public AtmDecision withdrawAtAtm(Iban iban, Money amount, AtmId atm) {
16
        Account account = accounts.findByIban(iban).orElseThrow();
17
        if (fraudCheck.isSuspicious(iban, amount, atm)) {
18
            account.freeze();   // committed with the transaction; the ATM declines
19
            return AtmDecision.DECLINED;
20
        }
21
        account.withdraw(amount, "ATM " + atm.value());
22
        return AtmDecision.APPROVED;
23
    }
24
}

1
// The setter version: works while every caller goes through the service.
2
@Entity
3
@Getter @Setter
4
public class SetterAccount {
5

6
    @Id @GeneratedValue private Long id;
7
    private BigDecimal balance;
8
    private String currency;
9
    private String status;
10
}
11

12
// A nightly fee job that skips the service: no status check, no entry, and
13
// setBalance happily stores a negative number.
14
// account.setBalance(account.getBalance().subtract(monthlyFee));

Kendin gör

Aynı sekiz çağrı üç farklı modele karşı çalışıyor. Sağdaki liste siparişin kurallarını, alttaki sayaç kötü bir çağrının nerede durduğunu gösteriyor.

1. Anemik modelle oynat. Hiçbir çağrı hata vermiyor — ve kuralların çoğu kırmızıya dönüyor. Hatasız çalışmak doğru çalışmak demek değil.
2. Zengin entity’ye geç. Negatif miktar, dışarıdan liste ve iptal artık metot seviyesinde duruyor. setTotal hiç derlenmiyor.
3. Ama iki kural hâlâ kırmızı. Para birimi ve yer değiştirmiş argümanlar geçiyor, çünkü BigDecimal ve int anlam taşımıyor. Bu, bir sonraki dersin konusu: value object?Terimin tanımını açvalue objectKimliği olmayan, değeriyle eşit sayılan ve değiştirilemeyen küçük nesne: Money, Email, Quantity. Kendi geçerlilik kuralını kurucusunda taşır.Sözlükte gör →.
4. Görevleri tamamla. Sonuncusu sıfır bozulma istiyor ve bunu yalnızca üçüncü model yapabiliyor.

Tuzaklar

Entity’de Lombok @Data. Her alana setter açar — kapsülleme bir anotasyonla geri alınmış olur. Üstelik lazy koleksiyonlar dahil bütün alanlar üzerinden equals, hashCode ve toString üretir: beklenmedik sorgular, LazyInitializationException ya da çift yönlü ilişkilerde sonsuz özyineleme.

Entity’yi doğrudan JSON’a bağlamak. @RequestBody Order Jackson’ın setter’lara ya da alanlara yazmasını gerektirir ve istemcinin total göndermesine izin verir. İstek için bir record DTO al, entity’yi metotlarla değiştir.

Dev aggregate. Customer içinde bütün siparişleri List<Order> olarak tutmak, bir siparişi değiştirmek için müşteriyi ve tüm siparişlerini yüklemek demek. Aggregate’lar birbirine id ile referans verir.

Servisi yok etmek. Zengin model “servis yok” demek değil.

Servis transaction’ı açar, siparişi yükler, ödeme gibi dış sistemleri çağırır. Yalnızca kural taşımayı bırakır.

Kendini sına