เมธอดคำค้นหาที่อนุมานและการแปลคีย์เวิร์ด

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.

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.

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

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.

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.

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

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.

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.

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.

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.

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.

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?

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.