Spring Data JPA REST Query Criteria

qianmoQ發表於2019-01-23
SpringREST
案例概述

在本系列的第一篇文章中，我們將探索一種用於REST API的簡單查詢語言。我們將充分利用Spring作為REST API，並將JPA 2標準用於永續性方面。

為什麼使用查詢語言？因為 - 對於任何複雜的API - 透過非常簡單的欄位搜尋/過濾資源是不夠的。查詢語言更靈活，允許您精確過濾所需的資源。

User Entity

首先 - 讓我們提出我們將用於過濾器/搜尋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;
}
使用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();
 
        for (SearchCriteria param : params) {
            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()));
                }
            }
        }
        query.where(predicate);
 
        List<User> result = entityManager.createQuery(query).getResultList();
        return result;
    }
 
    @Override
    public void save(User entity) {
        entityManager.persist(entity);
    }
}

如您所見，searchUser API獲取非常簡單的約束列表，根據這些約束組成查詢，執行搜尋並返回結果。

約束類也很簡單：

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

該SearchCriteria實現持有我們的查詢引數：

  • key：用於儲存欄位名稱 - 例如：firstName，age，...等。
  • operation：用於保持操作 - 例如：Equality，less，...等。
  • value：用於儲存欄位值 - 例如：john，25，...等。
測試搜尋查詢

現在 - 讓我們測試我們的搜尋機制，以確保它可用。

首先 - 讓我們透過新增兩個使用者來初始化我們的資料庫以進行測試 - 如下例所示：

@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("john@doe.com");
        userJohn.setAge(22);
        userApi.save(userJohn);
 
        userTom = new User();
        userTom.setFirstName("Tom");
        userTom.setLastName("Doe");
        userTom.setEmail("tom@doe.com");
        userTom.setAge(26);
        userApi.save(userTom);
    }
}

現在，讓我們得到一個具有特定firstName和lastName的使用者 - 如下例所示：

@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));
}

接下來，讓age大於或等於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)));
}
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:8080/users?search=lastName:doe,age>25

這是它的回應：

[{
    "id":2,
    "firstName":"tom",
    "lastName":"doe",
    "email":"tom@doe.com",
    "age":26
}]
案例結論

這個簡單而強大的實現支援對REST API進行相當多的智慧過濾。是的—它仍然很粗糙，可以改進(下一篇文章將對此進行改進)—但它是在api上實現這種過濾功能的堅實起點。

相關文章