Why @Query for custom JPQL in Spring Boot? - Purpose & Use Cases

The Big Idea

Discover how a simple annotation can save you hours of debugging messy database code!

The Scenario

Imagine you have a database with many tables and you want to get specific data by writing complex queries manually in your code.

You write SQL queries as strings everywhere, mixing them with your Java code.

The Problem

Writing raw SQL queries manually is error-prone and hard to maintain.

It mixes database logic with Java code, making your code messy and difficult to read.

Also, if the database changes, you have to find and update all those queries yourself.

The Solution

The @Query annotation lets you write custom JPQL queries directly in your repository interfaces.

This keeps your queries organized, readable, and close to your Java code without mixing raw SQL strings everywhere.

It also integrates well with Spring Data, so you get type safety and easier maintenance.

Before vs After

✗ Before

String sql = "SELECT * FROM users WHERE age > 30"; // raw SQL in code
List<User> users = entityManager.createNativeQuery(sql, User.class).getResultList();

✓ After

@Query("SELECT u FROM User u WHERE u.age > 30")
List<User> findUsersOlderThan30();

What It Enables

You can write clear, reusable, and maintainable database queries directly in your Java interfaces, making your data access layer clean and efficient.

Real Life Example

In an online store app, you want to find all orders placed in the last month with a total price above a certain amount.

Using @Query, you write this complex query once in your repository and call it easily from your service code.

Key Takeaways

Manual SQL queries scattered in code are hard to maintain.

@Query centralizes and organizes custom JPQL queries.

This improves readability, safety, and ease of updates.