TOC

Métodos de consulta derivados em repositórios JPA de dados de primavera

Métodos de consulta derivados em repositórios JPA de dados de primavera

1. Introdução

Para consultas simples, é fácil derivar o que a consulta deve serjust by looking at the corresponding method name in our code.

Neste tutorial, vamos explorar comoSpring Data JPA aproveita essa ideia na forma de uma convenção de nomenclatura de método.

2. Estrutura dos métodos de consulta derivados na primavera

Os nomes dos métodos derivados têm duas partes principais separadas pela primeira palavra-chaveBy: 

List findByName(String name)

A primeira parte - comofind - é ointroducere o resto - comoByName - é ocriteria.

Spring Data JPA supports find, read, query, count and get. Então, por exemplo, poderíamos ter feitoqueryByName and Spring Data se comportaria da mesma forma.

Também podemos usarDistinct, First, orTop para remover duplicatas oulimit our result set: 

List findTop3ByAge()

The criteria part contains the entity-specific condition expressions of the query. Podemos usar as palavras-chave da condição junto com os nomes das propriedades da entidade. Também podemos concatenar as expressões comAndeOr, , como veremos em instantes.

3. Aplicação de amostra

Primeiro, vamos, é claro, precisar dean application using Spring Data JPA.

Nesse aplicativo, vamos definir uma classe de entidade: 

@Table(name = "users")
@Entity
class User {
    @Id
    @GeneratedValue
    private Integer id;

    private String name;
    private Integer age;
    private ZonedDateTime birthDate;
    private Boolean active;

    // standard getters and setters
}

E, vamos também definir um repositório. Ele estenderáJpaRepository, um dethe Spring Data Repository types: 

interface UserRepository extends JpaRepository {}

É aqui que colocaremos todos os nossos métodos de consulta derivados.

4. Palavras-chave Condição de Igualdade

A igualdade exata é uma das condições mais usadas nas consultas. Temos várias opções para expressar= ou operadores IS na consulta.

Podemos apenas acrescentar o nome da propriedade sem nenhuma palavra-chave para uma condição de correspondência exata: 

List findByName(String name);

E podemos adicionarIs ouEquals para facilitar a leitura: 

List findByNameIs(String name);
List findByNameEquals(String name);

Essa legibilidade extra é útil quando precisamos expressar desigualdade: 

List findByNameIsNot(String name);

Isso é um pouco mais legível do quefindByNameNot(String)!

Como a igualdadenull é um caso especial, não devemos usar o operador =. Spring Data JPA lida comnull parameters por padrão. Portanto, quando passamos um valornull para uma condição de igualdade, o Spring interpreta a consulta como IS NULL no SQL gerado.

Também podemos usar a palavra-chaveIsNull para adicionar critérios IS NULL à consulta: 

List findByNameIsNull();
List findByNameIsNotNull();

Observe que nemIsNull nemIsNotNull requerem um argumento de método.

Existem também mais duas palavras-chave que não requerem nenhum argumento. Podemos usar as palavras-chaveTrueeFalse para adicionar condições de igualdade para os tiposboolean: 

List findByActiveTrue();
List findByActiveFalse();

Claro, às vezes queremos algo mais tolerante do que igualdade exata, vamos ver o que mais podemos fazer.

5. Palavras-chave Condição de similaridade

Quando precisamos consultar os resultados com um padrão de propriedade, temos algumas opções.

Podemos encontrar nomes que começam com um valor usandoStartingWith: 

List findByNameStartingWith(String prefix);

A grosso modo, isso se traduz em “WHEREname LIKE‘value%'“.

Se quisermos nomes que terminam com um valor, entãoEndingWith é o que queremos: 

List findByNameEndingWith(String suffix);

Ou podemos encontrar quais nomes contêm um valor comContaining: 

List findByNameContaining(String infix);

Observe que todas as condições acima são chamadas de expressões padrão predefinidas. Portanto,we don’t need to add % operator inside the argument quando esses métodos são chamados.

Mas, vamos supor que estejamos fazendo algo mais complexo. Digamos que precisamos buscar os usuários cujos nomes começam coma, contêmb,e terminam comc.

Para isso, podemos adicionar nosso próprio LIKE com a palavra-chaveLike: 

List findByNameLike(String likePattern);

E então podemos entregar nosso padrão LIKE quando chamamos o método: 

String likePattern = "a%b%c";
userRepository.findByNameLike(likePattern);

Isso é o suficiente sobre nomes por agora. Vamos tentar alguns outros valores emUser.

6. Palavras-chave da condição de comparação

Além disso, podemos usar as palavras-chaveLessThaneLessThanEqual para comparar os registros com o valor fornecido usando os operadores<e⇐: 

List findByAgeLessThan(Integer age);
List findByAgeLessThanEqual(Integer age);

Por outro lado, na situação oposta, podemos usar as palavras-chaveGreaterThaneGreaterThanEqual: 

List findByAgeGreaterThan(Integer age);
List findByAgeGreaterThanEqual(Integer age);

Ou podemos encontrar usuários que têm entre duas idades comBetween: 

List findByAgeBetween(Integer startAge, Integer endAge);

Também podemos fornecer uma coleção de idades para comparar usandoIn: 

List findByAgeIn(Collection ages);

Como sabemos as datas de nascimento dos usuários, convém consultar usuários que nasceram antes ou depois de uma determinada data. UsaríamosBefore eAfter para isso: 

List findByBirthDateAfter(ZonedDateTime birthDate);
List findByBirthDateBefore(ZonedDateTime birthDate);

7. Expressões de várias condições

Podemos combinar quantas expressões precisarmos usando as palavras-chaveAndeOr: 

List findByNameOrBirthDate(String name, ZonedDateTime birthDate);
List findByNameOrBirthDateAndActive(String name, ZonedDateTime birthDate, Boolean active);

A ordem de precedência éAnd entãoOr, , exatamente como Java.

While Spring Data JPA imposes no limit to how many expressions we can add, we shouldn’t go crazy here. Nomes longos são ilegíveis e difíceis de manter. Para consultas complexas, dê uma olhada emthe @Query annotation instead.

8. Classificando os resultados

Em seguida é a triagem. Poderíamos pedir que os usuários sejam classificados em ordem alfabética por seus nomes usandoOrderBy: 

List findByNameOrderByName(String name);
List findByNameOrderByNameAsc(String name);

A ordem crescente é a opção de classificação padrão, mas podemos usarDesc em vez de classificá-los ao contrário: 

List findByNameOrderByNameDesc(String name);

9. findOne vsfindById em aCrudRepository

A equipe do Spring fez algumas mudanças importantes emCrudRepository com Spring Boot2.x. Um deles está renomeandofindOne parafindById.

Anteriormente com Spring Boot 1.x, chamávamosfindOne quando queríamos recuperar uma entidade por sua chave primária: 

User user = userRepository.findOne(1);

Desde o Spring Boot 2.x, podemos fazer o mesmo comfindById: 

User user = userRepository.findById(1);

Observe que o métodofindById() já está definido emCrudRepository para nós. Portanto, não temos que defini-lo explicitamente em repositórios personalizados que estendemCrudRepository.

10. Conclusão

Neste artigo, explicamos o mecanismo de derivação de consulta no Spring Data JPA. Usamos as palavras-chave de condição de propriedade para escrever métodos de consulta derivados nos repositórios Spring Data JPA.

O código-fonte deste tutorial está disponível emthe Github project.

Related