案例概述
在本系列的第一篇文章中，我们将探索一种用于 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 上实现这种过滤功能的坚实起点。