TOC

Linguagem de Consulta REST com Critérios Spring e JPA

Linguagem de Consulta REST com Critérios Spring e JPA

1. Visão geral

Neste primeiro artigo dethis new series, exploraremosa simple query language for a REST API. Faremos bom uso do Spring para a API REST e dos critérios JPA 2 para os aspectos de persistência.

Why a query language? Porque - para qualquer API suficientemente complexa - pesquisar / filtrar seus recursos por campos muito simples simplesmente não é suficiente. Uma linguagem de consulta é mais flexível e permite filtrar exatamente os recursos necessários.

2. User Entidade

Primeiro - vamos apresentar a entidade simples que vamos usar para nossa API de filtro / pesquisa - umUser básico: 

@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. Filtrar usandoCriteriaBuilder

Agora - vamos entrar no cerne do problema - a consulta na camada de persistência.

Construir uma abstração de consulta é uma questão de equilíbrio. Precisamos de uma boa quantidade de flexibilidade, por um lado, e precisamos manter a complexidade administrável, por outro. De alto nível, a funcionalidade é simples -you pass in some constraints and you get back some results.

Vamos ver como isso funciona: 

@Repository
public class UserDAO implements IUserDAO {

    @PersistenceContext
    private EntityManager entityManager;

    @Override
    public List searchUser(List params) {
        CriteriaBuilder builder = entityManager.getCriteriaBuilder();
        CriteriaQuery 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 result = entityManager.createQuery(query).getResultList();
        return result;
    }

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

Vamos dar uma olhada na classeUserSearchQueryCriteriaConsumer: 

public class UserSearchQueryCriteriaConsumer implements Consumer{

    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
}

Como você pode ver, a APIsearchUser pega uma lista de restrições muito simples, compõe uma consulta com base nessas restrições, faz a pesquisa e retorna os resultados.

A classe de restrição também é bastante simples: 

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

A implementaçãoSearchCriteria contém nossos parâmetrosQuery:

  • key: usado para conter o nome do campo - por exemplo:firstName,age, ... etc.

  • operation: usado para manter a operação - por exemplo: Igualdade, menos que, ... etc.

  • value: usado para manter o valor do campo - por exemplo: john, 25,… etc.

4. Teste as consultas de pesquisa

Agora - vamos testar nosso mecanismo de pesquisa para ter certeza de que contém água.

Primeiro - vamos inicializar nosso banco de dados para teste adicionando dois usuários - como no exemplo a seguir: 

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

Agora, vamos obter umUser comfirstNameelastName específicos - como no exemplo a seguir: 

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

    List results = userApi.searchUser(params);

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

A seguir, vamos obter umList deUser com o mesmolastName: 

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

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

A seguir, vamos obter os usuários comagegreater than or equal 25: 

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

    List results = userApi.searchUser(params);

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

A seguir, vamos procurar usuários quedon’t actually exist: 

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

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

Por fim, vamos pesquisar os usuários que receberam apenaspartialfirstName: 

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

    List results = userApi.searchUser(params);

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

6. OUserController

Por fim, vamos conectar o suporte de persistência para essa pesquisa flexível à nossa API REST.

Estaremos configurando umUserController simples - com umfindAll()using the “search” to pass in the entire search/filter expression: 

@Controller
public class UserController {

    @Autowired
    private IUserDao api;

    @RequestMapping(method = RequestMethod.GET, value = "/users")
    @ResponseBody
    public List findAll(@RequestParam(value = "search", required = false) String search) {
        List params = new ArrayList();
        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);
    }
}

Observe como estamos simplesmente criando nossos objetos de critérios de pesquisa a partir da expressão de pesquisa.

Agora estamos no ponto em que podemos começar a brincar com a API e ter certeza de que tudo está funcionando corretamente: 

http://localhost:8080/users?search=lastName:doe,age>25

E aqui está sua resposta: 

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

7. Conclusão

Essa implementação simples, porém poderosa, permite bastante filtragem inteligente em uma API REST. Sim - ainda é difícil e pode ser melhorado (e será melhorado no próximo artigo) - mas é um ponto de partida sólido para implementar esse tipo de funcionalidade de filtragem em suas APIs.

Ofull implementation deste artigo pode ser encontrado emthe GitHub project - este é um projeto baseado em Maven, portanto, deve ser fácil de importar e executar como está.

Related