Repository Abstraction

@Entity
@Table(name = "orders")
public class Order {
    @Id private UUID id;
    @Enumerated(EnumType.STRING) private OrderStatus status;
    private BigDecimal total;
    private Instant createdAt;
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<OrderLine> lines = new ArrayList<>();
    // constructors, domain methods
}
 
public interface OrderRepository extends ListCrudRepository<Order, UUID>,
                                         ListPagingAndSortingRepository<Order, UUID> {
    Page<Order> findByStatus(OrderStatus status, Pageable pageable);
}

Page<Order> page = orders.findByStatus(OrderStatus.OPEN, PageRequest.of(2, 20));
page.getContent();          // up to 20 orders
page.getTotalElements();    // requires a COUNT query
page.hasNext();
 
Slice<Order> slice = orders.findSliceByStatus(OrderStatus.OPEN, PageRequest.of(2, 20));
slice.hasNext();            // fetches 21 rows to decide — no COUNT query

// stable ordering
Sort sort = Sort.by(Sort.Order.desc("createdAt"), Sort.Order.asc("id"));
List<Order> recent = orders.findAll(sort);
 
// Type-safe sort with property references
Sort typed = Sort.sort(Order.class).by(Order::getCreatedAt).descending();

@Entity
public class Customer implements Persistable<UUID> {
    @Id private UUID id = UUID.randomUUID();            // assigned before persisting
    @Transient private boolean isNew = true;
 
    @Override public UUID getId() { return id; }
    @Override public boolean isNew() { return isNew; }
 
    @PostLoad @PostPersist
    void markNotNew() { this.isNew = false; }
}

@GetMapping("/api/orders")
PagedModel<OrderView> list(@RequestParam OrderStatus status,
                           @PageableDefault(size = 20, sort = "createdAt",
                                   direction = Sort.Direction.DESC) Pageable pageable) {
    return new PagedModel<>(orders.findByStatus(status, pageable).map(OrderView::from));
}

select o1_0.id, o1_0.created_at, o1_0.status, o1_0.total
from orders o1_0 where o1_0.status = ? order by o1_0.created_at desc
offset ? rows fetch first ? rows only;
select count(o1_0.id) from orders o1_0 where o1_0.status = ?;

@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Testcontainers
class OrderRepositoryTest {
    @Container @ServiceConnection
    static PostgreSQLContainer<?> db = new PostgreSQLContainer<>("postgres:17");
 
    @Autowired OrderRepository orders;
 
    @Test
    void pagesOpenOrders() {
        orders.saveAll(sampleOrders(45));
        Page<Order> page = orders.findByStatus(OrderStatus.OPEN, PageRequest.of(2, 20));
        assertThat(page.getContent()).hasSize(5);
        assertThat(page.getTotalElements()).isEqualTo(45);
    }
}

@Transactional
public void purgeCancelled(List<UUID> ids) {
    // single DELETE ... WHERE id IN (...) — no cascades/callbacks
    orders.deleteAllByIdInBatch(ids);
}

// Type-safe sort with property paths
Sort sort = Sort.sort(Order.class).by(Order::getCreatedAt).descending()
                .and(Sort.by("id").descending());               // unique tie-breaker
 
// Sorting by a computed expression requires JpaSort.unsafe (never with client input)
Sort byLineCount = JpaSort.unsafe(Sort.Direction.DESC, "size(o.lines)");

Answer: Both represent one chunk of a larger result. A Page knows the total number of elements and pages, so the user interface can show "page 3 of 42"; to get that, Spring Data runs an extra count query, which can be expensive on large tables. A Slice only knows whether a next slice exists, which it finds by fetching one more row than requested, so no count query is needed. Use Page when users really need totals, and Slice for infinite scrolling or "load more" buttons. For very large data sets, keyset-based scrolling is more efficient than offset paging.

Answer: SimpleJpaRepository.save asks the entity information whether the entity is new. By default, an entity is new if its identifier is null, or, when it has a @Version attribute, if the version is null; an entity can also decide for itself by implementing Persistable and its isNew method. For a new entity, save calls EntityManager.persist, which schedules an INSERT. Otherwise it calls merge, which loads the existing row if it is not already in the persistence context and copies the state across, resulting in an UPDATE at flush time. Knowing this explains several surprising extra SELECT statements.