JPA Projection ve DTO — Üç Alan İçin Ne Kadar Veri?

1
// "Her ayın 1'inde kira için 15.000 TL gönder": a customer's recurring payment instruction.
2
@Entity
3
@Table(name = "standing_orders")
4
public class StandingOrder {
5

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

9
    @ManyToOne(fetch = FetchType.LAZY, optional = false)
10
    private Account account;
11

12
    private String payeeName;
13
    private String payeeIban;
14
    private BigDecimal amount;
15
    private int dayOfMonth;
16

17
    @Enumerated(EnumType.STRING)
18
    private StandingOrderStatus status;
19

20
    private Instant cancelledAt;
21

22
    @Lob
23
    private String changeHistory;   // large, never needed on the list screen
24

25
    public void cancel(Clock clock) {
26
        if (status == StandingOrderStatus.EXECUTING) {
27
            // Today's payment is already with the clearing system; cancelling now
28
            // would show "cancelled" while the money still leaves.
29
            throw new IllegalStateException("cannot cancel while today's payment is executing");
30
        }
31
        status = StandingOrderStatus.CANCELLED;
32
        cancelledAt = Instant.now(clock);
33
    }
34

35
    // getters omitted
36
}

1
public record StandingOrderRow(Long id, String payeeName, BigDecimal amount, int dayOfMonth,
2
                               StandingOrderStatus status) {
3
}

1
interface StandingOrderRepository extends JpaRepository<StandingOrder, Long> {
2

3
    // 1. Record DTO: one query, five columns, nothing in the persistence context.
4
    @Query("""
5
            select new com.bank.standingorder.StandingOrderRow(s.id, s.payeeName, s.amount, s.dayOfMonth, s.status)
6
            from StandingOrder s join s.account a
7
            where a.customerNo = :customerNo and s.status = :status
8
            """)
9
    Page<StandingOrderRow> findRows(String customerNo, StandingOrderStatus status, Pageable pageable);
10

11
    // 2. Closed interface projection: getters match the aliases.
12
    interface MonthlyOutflow {
13
        String getIban();
14
        BigDecimal getTotal();
15
    }
16

17
    @Query("""
18
            select a.iban as iban, sum(s.amount) as total
19
            from StandingOrder s join s.account a
20
            where s.status = com.bank.standingorder.StandingOrderStatus.ACTIVE
21
            group by a.iban
22
            """)
23
    List<MonthlyOutflow> findMonthlyOutflows();
24

25
    // 3. Dynamic projection: the caller picks the shape.
26
    <T> List<T> findByDayOfMonthAndStatus(int dayOfMonth, StandingOrderStatus status, Class<T> type);
27

28
    // 4. Native SQL: alias every column to the getter name, or the value stays null.
29
    @Query(value = """
30
            SELECT a.iban AS iban, SUM(s.amount) AS total
31
            FROM standing_orders s JOIN accounts a ON a.id = s.account_id
32
            WHERE s.status = 'ACTIVE' AND s.day_of_month = :day
33
            GROUP BY a.iban
34
            """, nativeQuery = true)
35
    List<MonthlyOutflow> findDueOnDayNative(int day);
36
}

1
@Service
2
class StandingOrderService {
3

4
    private final StandingOrderRepository standingOrders;
5
    private final Clock clock;
6

7
    StandingOrderService(StandingOrderRepository standingOrders, Clock clock) {
8
        this.standingOrders = standingOrders;
9
        this.clock = clock;
10
    }
11

12
    // Read path: a projection. No entities, no dirty-checking snapshots.
13
    @Transactional(readOnly = true)
14
    public Page<StandingOrderRow> list(String customerNo, StandingOrderStatus status, Pageable pageable) {
15
        return standingOrders.findRows(customerNo, status, pageable);
16
    }
17

18
    // Write path: load the entity, call the domain method, let dirty checking write it.
19
    @Transactional
20
    public void cancel(long id) {
21
        StandingOrder order = standingOrders.findById(id)
22
                .orElseThrow(() -> new StandingOrderNotFoundException(id));
23
        order.cancel(clock);
24
    }
25
}

1
@RestController
2
@RequestMapping("/standing-orders")
3
class StandingOrderController {
4

5
    private final StandingOrderService service;
6

7
    StandingOrderController(StandingOrderService service) {
8
        this.service = service;
9
    }
10

11
    @GetMapping
12
    Page<StandingOrderRow> list(@AuthenticationPrincipal Customer customer,
13
                                @RequestParam(defaultValue = "ACTIVE") StandingOrderStatus status,
14
                                @PageableDefault(size = 20, sort = "dayOfMonth") Pageable pageable) {
15
        return service.list(customer.number(), status, pageable);
16
    }
17

18
    @PostMapping("/{id}/cancel")
19
    ResponseEntity<Void> cancel(@PathVariable long id) {
20
        service.cancel(id);            // ownership is checked with @PreAuthorize in the real code
21
        return ResponseEntity.noContent().build();
22
    }
23
}