Spring Boot 4 Complete Guide · 课时

派生查询方法与关键字解析

使用 Spring Data 的属性关键字语法，仅根据方法名构建复杂的存储库查询。

派生查询方法与关键字解析 是 CoddyKit 上的免费 Spring Boot 4 Complete Guide 课时。这是第 1 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 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.

常见问题解答

「派生查询方法与关键字解析」课时是免费的吗？

是的 — 「派生查询方法与关键字解析」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Spring Boot 4 Complete Guide 课程的其余内容，请升级到 CoddyKit PRO。 Spring Boot 4 Complete Guide 课程共包含 4 节课。

「派生查询方法与关键字解析」这节课中我会学到什么？

使用 Spring Data 的属性关键字语法，仅根据方法名构建复杂的存储库查询。你通过在浏览器中直接运行的动手代码来练习 Spring Boot 4 Complete Guide，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Spring Boot 4 Complete Guide 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Spring Boot 4 Complete Guide 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 1 节课，共 4 节。

「派生查询方法与关键字解析」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Spring Boot 4 Complete Guide 课中编写并运行代码吗？

能。每节 Spring Boot 4 Complete Guide 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Spring Boot 4 Complete Guide