Spring Data JPA

Spring Data JPA removes the boilerplate of writing DAO classes by hand. You define a repository interface, and Spring generates the implementation at runtime — including full CRUD operations and, for many common query shapes, even the query itself, derived directly from the method name.

JpaRepository and Built-In CRUD

Extending JpaRepository<EntityType, IdType> immediately gives you methods like save(), findById(), findAll(), deleteById(), and count() — with no implementation code required. Spring Data generates a proxy implementation at startup and registers it as a bean you can simply @Autowire or inject via constructor.

Derived Query Methods

Spring Data JPA can parse a method name and build the corresponding query automatically, as long as it follows the expected keyword conventions — findBy, And, Or, OrderBy, GreaterThan, Containing, and more. For example, findByEmailAndActiveTrue(String email) generates a query filtering on both the email column and an active flag, with zero SQL or JPQL written by hand.

Custom Queries with @Query

When a query is too complex to express as a method name, or you need specific join/aggregation logic, @Query lets you write JPQL (object-oriented, referencing entity fields) or native SQL (with nativeQuery = true) directly above the method signature, while Spring Data still handles binding the method's parameters into the query.

Return Types: Optional, Counts and Existence Checks

The return type of a repository method is part of the query. A method returning Optional<Product> gives you an empty Optional instead of null when nothing matches, which forces the caller to decide what "not found" means. countBy… returns a number computed in the database, and existsBy… returns a boolean without loading any entity, which is far cheaper than fetching a list just to check whether it is empty. findFirstBy… or findTop3By… limit the result size in SQL.

Bulk Updates with @Modifying

A JPQL UPDATE or DELETE needs @Modifying next to @Query, and it must run inside a transaction, so annotate the method or its caller with @Transactional. The method returns how many rows changed. Bulk statements go straight to the database and skip the persistence context: entities you already loaded in the same transaction keep their old values unless you set @Modifying(clearAutomatically = true) or reload them.

Choosing How to Write a Query

• Derived method names for simple filters on one or two fields. They are checked at startup, so a typo fails fast.
• @Query with JPQL when the name would get long, or you need joins, grouping or a bulk update.
• Native SQL (nativeQuery = true) only for database-specific features such as window functions or full-text search, because it ties the query to one database.
• Specifications (JpaSpecificationExecutor) when users can combine many optional filters, such as a product search page, where writing one method per combination is impossible.

When Spring Data JPA Is the Right Tool

It fits applications that mostly load, change and save business objects: orders, users, products. It is a weaker fit for reporting queries over millions of rows or for heavy batch jobs, where loading every row as a managed entity wastes memory. There, a projection, JdbcClient or a dedicated batch tool is usually faster, and you can use both in the same application.

Examples

public interface ProductRepository extends JpaRepository<Product, Long> {

    // Derived query: SELECT * FROM product WHERE category = ? AND price < ?
    List<Product> findByCategoryAndPriceLessThan(String category, BigDecimal price);

    // Derived query with ordering
    List<Product> findByCategoryOrderByPriceAsc(String category);

    // Custom JPQL query for a case a method name can't express cleanly
    @Query("SELECT p FROM Product p WHERE p.stock < :threshold")
    List<Product> findLowStockProducts(@Param("threshold") int threshold);
}

@Service
public class ProductService {
    private final ProductRepository repository;
    public ProductService(ProductRepository repository) { this.repository = repository; }

    public List<Product> cheapElectronics() {
        return repository.findByCategoryAndPriceLessThan("Electronics", new BigDecimal("50.00"));
    }
}

cheapElectronics() ->
[Product{id=3, name='USB Cable', price=8.99}, Product{id=7, name='Phone Stand', price=14.50}]

// Product.java
@Entity
public class Product {

    @Id
    @GeneratedValue
    private Long id;
    private String name;
    private String category;
    private BigDecimal price;
    private int stock;

    protected Product() { } // JPA needs a no-argument constructor

    public Product(String name, String category, String price, int stock) {
        this.name = name;
        this.category = category;
        this.price = new BigDecimal(price);
        this.stock = stock;
    }

    @Override
    public String toString() { return name + " (" + price + ", stock " + stock + ")"; }
}

// ProductRepository.java
public interface ProductRepository extends JpaRepository<Product, Long> {

    List<Product> findByCategoryAndPriceLessThan(String category, BigDecimal price);

    List<Product> findByCategoryOrderByPriceAsc(String category);

    Optional<Product> findFirstByNameIgnoreCase(String name);

    long countByStockLessThan(int stock);

    boolean existsByName(String name);

    @Query("SELECT p FROM Product p WHERE p.stock < :threshold ORDER BY p.stock")
    List<Product> findLowStock(@Param("threshold") int threshold);

    @Transactional
    @Modifying
    @Query("UPDATE Product p SET p.stock = p.stock + :amount WHERE p.category = :category")
    int restock(@Param("category") String category, @Param("amount") int amount);
}

// CatalogDemo.java
@Component
public class CatalogDemo implements CommandLineRunner {

    private final ProductRepository products;

    public CatalogDemo(ProductRepository products) {
        this.products = products;
    }

    @Override
    public void run(String... args) {
        products.saveAll(List.of(
                new Product("USB Cable", "Electronics", "8.99", 120),
                new Product("Phone Stand", "Electronics", "14.50", 4),
                new Product("Mechanical Keyboard", "Electronics", "89.00", 2),
                new Product("Notebook", "Stationery", "3.25", 300)));

        System.out.println("count = " + products.count());
        System.out.println("cheap electronics = "
                + products.findByCategoryAndPriceLessThan("Electronics", new BigDecimal("50.00")));
        System.out.println("electronics by price = " + products.findByCategoryOrderByPriceAsc("Electronics"));
        System.out.println("find 'notebook' = " + products.findFirstByNameIgnoreCase("notebook").orElse(null));
        System.out.println("find 'stapler' = " + products.findFirstByNameIgnoreCase("stapler").orElse(null));
        System.out.println("low stock (< 5) = " + products.findLowStock(5));
        System.out.println("rows restocked = " + products.restock("Electronics", 10));
        System.out.println("low stock after restock = " + products.countByStockLessThan(5));
        System.out.println("exists 'USB Cable' = " + products.existsByName("USB Cable"));
    }
}

// pom.xml: spring-boot-starter-data-jpa and com.h2database:h2 (runtime scope)

count = 4
cheap electronics = [USB Cable (8.99, stock 120), Phone Stand (14.50, stock 4)]
electronics by price = [USB Cable (8.99, stock 120), Phone Stand (14.50, stock 4), Mechanical Keyboard (89.00, stock 2)]
find 'notebook' = Notebook (3.25, stock 300)
find 'stapler' = null
low stock (< 5) = [Mechanical Keyboard (89.00, stock 2), Phone Stand (14.50, stock 4)]
rows restocked = 3
low stock after restock = 0
exists 'USB Cable' = true

Exercise

A teammate is about to make this mistake: Writing an @Modifying UPDATE or DELETE without a transaction, which fails with InvalidDataAccessApiUsageException caused by TransactionRequiredException ("No active transaction"). Put @Transactional on the repository method or on the service method that calls it. Use JpaRepository and Built-In CRUD to review the decision. Write a corrected implementation or design sketch that follows JpaRepository provides full CRUD operations with zero implementation code., then name one edge case you would check.

Quick quiz

Interview questions