0Pricing
Spring Boot 4 Complete Guide · 강의

파생 쿼리 메서드와 키워드 해석

Spring Data의 속성 키워드 문법을 사용해 메서드 이름만으로 복잡한 저장소 쿼리를 구축합니다.

파생 쿼리 메서드와 키워드 해석은(는) CoddyKit의 무료 Spring Boot 4 Complete Guide 강의입니다. 이것은 4개 중 1번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Spring Boot 4 Complete Guide 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Spring Boot 4 Complete Guide 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

What Are Derived Query Methods?

Spring Data JPA can generate a full SQL query just by reading the name of a repository method. You write the method signature, leave the body to the framework, and Spring parses the name into a query at startup.

  • No @Query annotation needed
  • No hand-written JPQL or SQL
  • The method name is the query specification

This is called a derived query method, because the query is derived from the method name.

public interface UserRepository extends JpaRepository<User, Long> {

    // Spring derives: SELECT u FROM User u WHERE u.email = ?1
    User findByEmail(String email);
}

The Subject and the Predicate

Every derived method name splits into two parts:

  • The subject (an introducer like findBy, readBy, queryBy, getBy) which tells Spring what action to perform.
  • The predicate (everything after By) which becomes the WHERE clause.

In findByLastName, find is the subject and LastName is the predicate that maps to the lastName entity property.

public interface CustomerRepository extends JpaRepository<Customer, Long> {

    List<Customer> findByLastName(String lastName);

    List<Customer> readByCity(String city);  // 'readBy' works too

    Customer getById(Long id);               // 'getBy' works too
}

Combining Conditions with And / Or

You chain multiple properties using the keywords And and Or. Each property name in the chain must match an entity field, and the method parameters are bound left-to-right in the same order they appear.

  • findByFirstNameAndLastName → WHERE first_name = ?1 AND last_name = ?2
  • findByCityOrCountry → WHERE city = ?1 OR country = ?2
public interface CustomerRepository extends JpaRepository<Customer, Long> {

    List<Customer> findByFirstNameAndLastName(String firstName, String lastName);

    List<Customer> findByCityOrCountry(String city, String country);
}

Comparison Keywords

Beyond equality, Spring Data understands a rich set of comparison keywords appended after the property name:

  • LessThan, LessThanEqual, GreaterThan, GreaterThanEqual
  • Between — needs two parameters
  • Before, After — handy for dates

The keyword binds to the property right before it, so findByAgeGreaterThan targets the age property.

public interface ProductRepository extends JpaRepository<Product, Long> {

    List<Product> findByPriceLessThan(BigDecimal max);

    List<Product> findByPriceBetween(BigDecimal low, BigDecimal high);

    List<Product> findByCreatedAtAfter(LocalDateTime since);
}

Null, True, and Boolean Keywords

Some keywords take no parameter at all because the condition is baked into the name:

  • IsNull / IsNotNull → IS NULL / IS NOT NULL
  • True / False → compares a boolean property to true/false

Notice that findByActiveTrue() has an empty parameter list — the value is fixed by the keyword.

public interface AccountRepository extends JpaRepository<Account, Long> {

    List<Account> findByDeletedAtIsNull();

    List<Account> findByActiveTrue();

    List<Account> findByActiveFalse();
}

String Matching Keywords

For text columns, Spring Data offers keywords that translate into LIKE patterns:

  • Like — you supply the wildcards (%) yourself
  • StartingWith — appends % automatically
  • EndingWith — prepends %
  • Containing — wraps the value in %value%
  • IgnoreCase — makes the comparison case-insensitive
public interface CustomerRepository extends JpaRepository<Customer, Long> {

    List<Customer> findByEmailContaining(String fragment);

    List<Customer> findByLastNameStartingWith(String prefix);

    List<Customer> findByLastNameIgnoreCase(String lastName);
}

Ordering Results with OrderBy

You can embed sorting directly in the method name using OrderBy followed by the property and a direction (Asc or Desc). It goes at the very end of the predicate.

  • findByLastNameOrderByFirstNameAsc
  • findByActiveTrueOrderByCreatedAtDesc

For dynamic sorting at call time, prefer passing a Sort parameter instead of hard-coding it in the name.

public interface CustomerRepository extends JpaRepository<Customer, Long> {

    List<Customer> findByLastNameOrderByFirstNameAsc(String lastName);

    // Dynamic sort, supplied by the caller
    List<Customer> findByCity(String city, Sort sort);
}

Limiting with First and Top

To restrict how many rows come back, add First or Top right after the subject. They are interchangeable, and an optional number sets the limit.

  • findFirstByOrderByCreatedAtDesc → the single newest row
  • findTop3ByCategory → at most 3 rows for that category

Combined with OrderBy this is the idiomatic way to fetch "the latest N" records.

public interface OrderRepository extends JpaRepository<Order, Long> {

    Order findFirstByCustomerIdOrderByPlacedAtDesc(Long customerId);

    List<Order> findTop5ByStatusOrderByPlacedAtDesc(String status);
}

Traversing Nested Properties

Derived queries can reach into related entities. If Order has a Customer and the customer has an address.city, you can write findByCustomerAddressCity.

Spring resolves the path greedily, splitting on camel-case humps. When a property name is itself ambiguous (e.g. a field literally named customerAddress), insert an underscore to make the boundary explicit: findByCustomer_AddressCity.

public interface OrderRepository extends JpaRepository<Order, Long> {

    // Order -> customer -> address -> city
    List<Order> findByCustomerAddressCity(String city);

    // Explicit traversal boundary with underscore
    List<Order> findByCustomer_AddressCity(String city);
}

Counting, Existence, and Deletion

The subject keyword controls the operation, not just selection. Beyond find, you can derive:

  • countBy... → returns a long
  • existsBy... → returns a boolean
  • deleteBy... / removeBy... → deletes matching rows (use with @Transactional)

The predicate grammar is identical; only the return type and the action change.

public interface UserRepository extends JpaRepository<User, Long> {

    long countByActiveTrue();

    boolean existsByEmail(String email);

    @Transactional
    long deleteByLastLoginBefore(LocalDateTime cutoff);
}

How Keyword Resolution Actually Works

At application startup, Spring Data parses each method name into a PartTree. For every segment it tries the longest matching property path first, then peels off trailing keywords.

  • It validates each property against the entity's metamodel — a typo like findByemaill fails fast with PropertyReferenceException.
  • Because parsing happens at startup, broken method names break the context immediately, not at first call.

This pure-Java example shows the same camel-case splitting idea the parser uses.

public class PartTreeDemo {
    public static void main(String[] args) {
        String predicate = "FirstNameAndLastName";
        String[] parts = predicate.split("And");
        for (String p : parts) {
            // Lower-case the first letter to get the property name
            String prop = Character.toLowerCase(p.charAt(0)) + p.substring(1);
            System.out.println("Property: " + prop);
        }
    }
}

Quick Check

You need a repository method that returns the 3 most recently placed orders for a given status, newest first. Which derived method name is correct?

Recap

You now know how to build queries straight from method names:

  • Subject (find/read/get/count/exists/delete) sets the operation; predicate after By becomes the WHERE clause.
  • Combine fields with And/Or; compare with LessThan, Between, After; match text with Containing, StartingWith, IgnoreCase.
  • Parameter-free keywords: IsNull, True, False.
  • Sort with OrderBy...Asc/Desc (or a Sort param); limit with First/Top[N].
  • Traverse relations (findByCustomerAddressCity, use _ to disambiguate).
  • Spring parses names into a PartTree at startup, so invalid property paths fail fast.

For very long or complex names, switch to @Query — readability beats cleverness.

자주 묻는 질문

“파생 쿼리 메서드와 키워드 해석” 강의는 무료인가요?

네 — “파생 쿼리 메서드와 키워드 해석” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Spring Boot 4 Complete Guide 강의 전체를 잠금 해제할 수 있습니다. Spring Boot 4 Complete Guide 강의에는 총 4개의 강의가 포함되어 있습니다.

“파생 쿼리 메서드와 키워드 해석”에서 뭘 배우나요?

Spring Data의 속성 키워드 문법을 사용해 메서드 이름만으로 복잡한 저장소 쿼리를 구축합니다. 브라우저에서 직접 실행하는 실습 코드로 Spring Boot 4 Complete Guide을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

Spring Boot 4 Complete Guide을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 Spring Boot 4 Complete Guide은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 1번째 강의입니다.

“파생 쿼리 메서드와 키워드 해석” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 Spring Boot 4 Complete Guide 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 Spring Boot 4 Complete Guide 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

  1. 파생 쿼리 메서드와 키워드 해석
  2. @Query를 활용한 JPQL 및 네이티브 쿼리
  3. Specification과 기준 기반 동적 필터링
  4. 페이지 매김, 정렬 및 슬라이스 스트리밍
← Spring Boot 4 Complete Guide(으)로 돌아가기