YeLogs.com
知識庫

知識庫 / JPA RSS 訂閱

Spring 和 JPA 領域查詢語言

JPA,REST,Spring
HongKong
6
04:00 AM · Dec 06 ,2025 
<div>
 <a class="article-series-header" href="javascript:void(0);">該文章是系列的一部分</a>
 <div>
  <div>
   <div>
    • 使用 Spring 和 JPA Criteria 的 REST 查詢語言 （當前文章）
   </div>
   • 使用 Spring Data JPA Specifications 的 REST 查詢語言
   <br>
   • 使用 Spring Data JPA 和 Querydsl 的 REST 查詢語言
   <br>
   • REST 查詢語言 – 高級搜索操作
   <br>
   • REST 查詢語言 – 實現 OR 操作
   <br>
   • 使用 RSQL 的 REST 查詢語言
   <br>
   • 使用 Querydsl Web 支持的 REST 查詢語言
   <br>
  </div>
  <!-- end of article series inner -->
 </div>
 <!-- .article-series-links -->
</div>
<!-- end of article series section -->

1. 概述

在本文檔系列的第一篇文章中，我們將探討一個簡單的查詢語言，用於 REST API。我們將充分利用 Spring 構建 REST API，以及 JPA 2 Criteria 用於持久化方面。

為什麼需要查詢語言？ 因為 – 對於足夠複雜的 API 來説 – 僅僅通過簡單的字段進行搜索/過濾資源，已經不夠用了。 查詢語言更靈活，可以讓你精確地篩選出所需資源。

2. 用户實體

首先，我們提出將用於我們的過濾/搜索 API 的一個基本實體——一個基本的 用户：

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String firstName;
    private String lastName;
    private String email;

    private int age;
}

3. 使用 CriteriaBuilder 過濾

現在，讓我們深入探討問題的核心——持久層中的查詢。

構建查詢抽象是一個平衡的過程。一方面，我們需要足夠的靈活性；另一方面，我們需要保持複雜性可控。高層功能很簡單——您傳遞一些約束條件，即可獲得一些結果。

下面是如何實現它的：

@Repository
public class UserDAO implements IUserDAO {

    @PersistenceContext
    private EntityManager entityManager;

    @Override
    public List<User> searchUser(List<SearchCriteria> params) {
        CriteriaBuilder builder = entityManager.getCriteriaBuilder();
        CriteriaQuery<User> query = builder.createQuery(User.class);
        Root r = query.from(User.class);

        Predicate predicate = builder.conjunction();

        UserSearchQueryCriteriaConsumer searchConsumer = 
          new UserSearchQueryCriteriaConsumer(predicate, builder, r);
        params.stream().forEach(searchConsumer);
        predicate = searchConsumer.getPredicate();
        query.where(predicate);

        List<User> result = entityManager.createQuery(query).getResultList();
        return result;
    }

    @Override
    public void save(User entity) {
        entityManager.persist(entity);
    }
}

讓我們來查看一下 UserSearchQueryCriteriaConsumer 類：

public class UserSearchQueryCriteriaConsumer implements Consumer<SearchCriteria>{

    private Predicate predicate;
    private CriteriaBuilder builder;
    private Root r;

    @Override
    public void accept(SearchCriteria param) {
        if (param.getOperation().equalsIgnoreCase(">")) {
            predicate = builder.and(predicate, builder
              .greaterThanOrEqualTo(r.get(param.getKey()), param.getValue().toString()));
        } else if (param.getOperation().equalsIgnoreCase("<")) {
            predicate = builder.and(predicate, builder.lessThanOrEqualTo(
              r.get(param.getKey()), param.getValue().toString()));
        } else if (param.getOperation().equalsIgnoreCase(":")) {
            if (r.get(param.getKey()).getJavaType() == String.class) {
                predicate = builder.and(predicate, builder.like(
                  r.get(param.getKey()), "%" + param.getValue() + "%"));
            } else {
                predicate = builder.and(predicate, builder.equal(
                  r.get(param.getKey()), param.getValue()));
            }
        }
    }

    // standard constructor, getter, setter
}

如你所見，searchUser API 接受一個包含非常簡單約束條件的列表，根據這些約束條件組合一個查詢，執行搜索並返回結果。

約束類本身也非常簡單：

public class SearchCriteria {
    private String key;
    private String operation;
    private Object value;
}

SearchCriteria 實現持有我們的 Query 參數:

  • key：用於存儲字段名稱 – 例如：firstName、age 等等。
  • operation：用於存儲操作 – 例如：相等、小於等。
  • value：用於存儲字段值 – 例如：john、25 等等。

4. 測試搜索查詢

現在，讓我們測試我們的搜索機制，以確保其有效性。

首先，讓我們通過添加兩個用户（如以下示例所示）來初始化測試數據庫：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { PersistenceConfig.class })
@Transactional
@TransactionConfiguration
public class JPACriteriaQueryTest {

    @Autowired
    private IUserDAO userApi;

    private User userJohn;

    private User userTom;

    @Before
    public void init() {
        userJohn = new User();
        userJohn.setFirstName("John");
        userJohn.setLastName("Doe");
        userJohn.setEmail("[email protected]");
        userJohn.setAge(22);
        userApi.save(userJohn);

        userTom = new User();
        userTom.setFirstName("Tom");
        userTom.setLastName("Doe");
        userTom.setEmail("[email protected]");
        userTom.setAge(26);
        userApi.save(userTom);
    }
}

現在，讓我們獲取一個具有特定firstName 和 lastName 的 User，如以下示例所示：

@Test
public void givenFirstAndLastName_whenGettingListOfUsers_thenCorrect() {
    List<SearchCriteria> params = new ArrayList<SearchCriteria>();
    params.add(new SearchCriteria("firstName", ":", "John"));
    params.add(new SearchCriteria("lastName", ":", "Doe"));

    List<User> results = userApi.searchUser(params);

    assertThat(userJohn, isIn(results));
    assertThat(userTom, not(isIn(results)));
}

接下來，我們獲取所有具有相同lastName的用户列表：

@Test
public void givenLast_whenGettingListOfUsers_thenCorrect() {
    List<SearchCriteria> params = new ArrayList<SearchCriteria>();
    params.add(new SearchCriteria("lastName", ":", "Doe"));

    List<User> results = userApi.searchUser(params);
    assertThat(userJohn, isIn(results));
    assertThat(userTom, isIn(results));
}

接下來，我們獲取年齡大於或等於 25 歲的用户：

@Test
public void givenLastAndAge_whenGettingListOfUsers_thenCorrect() {
    List<SearchCriteria> params = new ArrayList<SearchCriteria>();
    params.add(new SearchCriteria("lastName", ":", "Doe"));
    params.add(new SearchCriteria("age", ">", "25"));

    List<User> results = userApi.searchUser(params);

    assertThat(userTom, isIn(results));
    assertThat(userJohn, not(isIn(results)));
}

接下來，我們來搜索那些實際上不存在的用户：

@Test
public void givenWrongFirstAndLast_whenGettingListOfUsers_thenCorrect() {
    List<SearchCriteria> params = new ArrayList<SearchCriteria>();
    params.add(new SearchCriteria("firstName", ":", "Adam"));
    params.add(new SearchCriteria("lastName", ":", "Fox"));

    List<User> results = userApi.searchUser(params);
    assertThat(userJohn, not(isIn(results)));
    assertThat(userTom, not(isIn(results)));
}

最後，我們僅根據部分firstName進行查找用户：

@Test
public void givenPartialFirst_whenGettingListOfUsers_thenCorrect() {
    List<SearchCriteria> params = new ArrayList<SearchCriteria>();
    params.add(new SearchCriteria("firstName", ":", "jo"));

    List<User> results = userApi.searchUser(params);

    assertThat(userJohn, isIn(results));
    assertThat(userTom, not(isIn(results)));
}

6. UserController

我們現在將持久化支持集成到這個靈活的搜索功能中，用於我們的 REST API。

我們將創建一個簡單的 UserController，其中使用 findAll() 方法，並使用“search”參數傳遞完整的搜索/過濾表達式。

@Controller
public class UserController {

    @Autowired
    private IUserDao api;

    @RequestMapping(method = RequestMethod.GET, value = "/users")
    @ResponseBody
    public List<User> findAll(@RequestParam(value = "search", required = false) String search) {
        List<SearchCriteria> params = new ArrayList<SearchCriteria>();
        if (search != null) {
            Pattern pattern = Pattern.compile("(\w+?)(:|<|>)(\w+?),");
            Matcher matcher = pattern.matcher(search + ",");
            while (matcher.find()) {
                params.add(new SearchCriteria(matcher.group(1), 
                  matcher.group(2), matcher.group(3)));
            }
        }
        return api.searchUser(params);
    }
}

請注意，我們正在通過將搜索表達式轉換為搜索條件對象。

現在，我們可以開始使用 API 進行測試，並確保一切正常工作：

http://localhost:8082/spring-rest-query-language/auth/users?search=lastName:doe,age%3E25

以下是它的響應:

[{
    "id":2,
    "firstName":"tom",
    "lastName":"doe",
    "email":"[email protected]",
    "age":26
}]

7. 結論

這個簡單但強大的實現方案能夠在一個 REST API 上實現相當智能的過濾功能。是的，它仍然有些粗糙，並且可以得到改進（並且將在下一篇文章中得到改進）——但它仍然是一個可靠的起點，用於在您的 API 上實現這種過濾功能。

下一章 » Spring Data JPA Specifications 中的 REST 查詢語言
user avatar
0 位用戶收藏了這個故事！
收藏

發佈 評論

Some HTML is okay.