Cascade ve İlişkinin Sahibi — Kalem Gerçekten Eklendi mi?

1
// A company's supplier payment run: one debit account, many payment lines,
2
// approved as a whole by two signatories before it is sent.
3
@Entity
4
@Table(name = "bulk_payments")
5
public class BulkPayment {
6

7
    @Id @GeneratedValue(strategy = GenerationType.SEQUENCE)
8
    private Long id;
9

10
    @Enumerated(EnumType.STRING)
11
    private BulkStatus status = BulkStatus.DRAFT;
12

13
    // Lines live and die with the run: cascade + orphanRemoval.
14
    @OneToMany(mappedBy = "bulkPayment", cascade = CascadeType.ALL, orphanRemoval = true)
15
    private List<PaymentLine> lines = new ArrayList<>();
16

17
    public void addLine(Payee payee, BigDecimal amount) {
18
        requireDraft();
19
        lines.add(new PaymentLine(this, payee, amount));   // owning side set in the constructor
20
    }
21

22
    public void removeLine(long lineId) {
23
        requireDraft();
24
        lines.removeIf(line -> line.getId() != null && line.getId() == lineId);  // orphanRemoval deletes it
25
    }
26

27
    public void replaceLines(List<LineSpec> specs, Function<Long, Payee> payees) {
28
        requireDraft();
29
        lines.clear();                                // same collection instance, never a new list
30
        specs.forEach(spec -> addLine(payees.apply(spec.payeeId()), spec.amount()));
31
    }
32

33
    private void requireDraft() {
34
        // Once signed, the lines are what the signatories approved: no edits.
35
        if (status != BulkStatus.DRAFT) throw new IllegalStateException("bulk payment is " + status);
36
    }
37

38
    // Read-only view: outside code cannot add a line without the owning side.
39
    public List<PaymentLine> getLines() {
40
        return Collections.unmodifiableList(lines);
41
    }
42

43
    public Long getId() { return id; }
44
}

1
@Entity
2
@Table(name = "payment_lines")
3
public class PaymentLine {
4

5
    @Id @GeneratedValue(strategy = GenerationType.SEQUENCE)
6
    private Long id;
7

8
    // Owning side: this field decides bulk_payment_id.
9
    @ManyToOne(fetch = FetchType.LAZY, optional = false)
10
    @JoinColumn(name = "bulk_payment_id")
11
    private BulkPayment bulkPayment;
12

13
    // Shared data: no cascade. Removing a line must never delete a saved payee.
14
    @ManyToOne(fetch = FetchType.LAZY, optional = false)
15
    private Payee payee;
16

17
    private BigDecimal amount;
18

19
    protected PaymentLine() {}
20

21
    PaymentLine(BulkPayment bulkPayment, Payee payee, BigDecimal amount) {
22
        this.bulkPayment = bulkPayment;
23
        this.payee = payee;
24
        this.amount = amount;
25
    }
26

27
    public Long getId() { return id; }
28
    public BigDecimal getAmount() { return amount; }
29
}

1
@Service
2
class BulkPaymentEditing {
3

4
    private final BulkPaymentRepository bulkPayments;
5
    private final PayeeRepository payees;
6

7
    BulkPaymentEditing(BulkPaymentRepository bulkPayments, PayeeRepository payees) {
8
        this.bulkPayments = bulkPayments;
9
        this.payees = payees;
10
    }
11

12
    // The accountant re-uploads the corrected supplier list before signing.
13
    @Transactional
14
    public void replaceLines(long bulkId, List<LineSpec> specs) {
15
        BulkPayment bulk = bulkPayments.findById(bulkId).orElseThrow();
16
        // getReferenceById: a proxy, no SELECT per payee, just its id for the FK.
17
        bulk.replaceLines(specs, payees::getReferenceById);
18
        // No save(): orphanRemoval deletes the old lines, cascade inserts the new ones at commit.
19
    }
20
}

1
CREATE TABLE payment_lines (
2
    id              BIGINT         PRIMARY KEY,
3
    bulk_payment_id BIGINT         NOT NULL REFERENCES bulk_payments (id),   -- a forgotten owning side fails here
4
    payee_id        BIGINT         NOT NULL REFERENCES payees (id),
5
    amount          NUMERIC(15, 2) NOT NULL CHECK (amount > 0)
6
);
7
CREATE INDEX payment_lines_bulk_payment_id ON payment_lines (bulk_payment_id);

1
@DataJpaTest
2
class PaymentLinesMappingTest {
3

4
    @Autowired TestEntityManager em;
5

6
    @Test
7
    void addAndRemoveReachTheDatabase() {
8
        Payee supplier = em.persist(new Payee(7L, "TR330006100519786457841326", "Kırtasiye A.Ş."));
9
        BulkPayment bulk = new BulkPayment();
10
        bulk.addLine(supplier, new BigDecimal("1200.00"));
11
        bulk.addLine(supplier, new BigDecimal("350.50"));
12
        em.persist(bulk);
13
        em.flush();
14
        em.clear();                                   // forget everything in memory
15

16
        BulkPayment reloaded = em.find(BulkPayment.class, bulk.getId());
17
        assertThat(reloaded.getLines()).hasSize(2);   // cascade inserted both, with bulk_payment_id
18

19
        long first = reloaded.getLines().get(0).getId();
20
        reloaded.removeLine(first);
21
        em.flush();
22
        em.clear();
23

24
        assertThat(em.find(PaymentLine.class, first)).isNull();            // orphanRemoval deleted it
25
        assertThat(em.find(Payee.class, supplier.getId())).isNotNull();    // the payee survived
26
    }
27
}