TOC

Consultas que não diferenciam maiúsculas de minúsculas com repositório de dados do Spring

Consultas que não diferenciam maiúsculas de minúsculas com repositório de dados do Spring

1. Visão geral

As consultas JPA dos Dados da Spring, por padrão, diferenciam maiúsculas de minúsculas. Em outras palavras, as comparações de valores de campo diferenciam maiúsculas de minúsculas.

Neste tutorial, exploraremos como criar rapidamente uma consulta que não diferencia maiúsculas de minúsculas em um repositório Spring Data JPA.

2. Dependências

Em primeiro lugar, verifique se temos https://www..com/the-persistence-layer-with-spring-data-jpa [Spring Data] e https://www..com/java-in-memory-databases Dependências do banco de dados [H2] em nosso pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    <version>2.1.3.RELEASE</version>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
    <version>1.4.199</version>
</dependency>

As versões mais recentes estão disponíveis em https://search.maven.org/classic/#search%7Cga%7C1%7C(g%3A%22org.springframework.boot%22%20AND%20a%3A%22spring-boot -starter-data-jpa% 22)% 20OR% 20 (g% 3A% 22com.h2database% 22% 20AND% 20a% 3A% 22h2% 22) [Maven Central.]

3. Configuração inicial

Digamos que temos uma entidade Passenger com os atributos id, firstName e lastName:

@Entity
class Passenger {

    @Id
    @GeneratedValue
    @Column(nullable = false)
    private Long id;

    @Basic(optional = false)
    @Column(nullable = false)
    private String firstName;

    @Basic(optional = false)
    @Column(nullable = false)
    private String lastName;

   //constructor, static factory, getters, setters
}

Além disso, vamos preparar nossa classe de teste preenchendo o banco de dados com alguns exemplos de dados Passenger:

@DataJpaTest
@RunWith(SpringRunner.class)
public class PassengerRepositoryIntegrationTest {

    @PersistenceContext
    private EntityManager entityManager;
    @Autowired
    private PassengerRepository repository;

    @Before
    public void before() {
        entityManager.persist(Passenger.from("Jill", "Smith"));
        entityManager.persist(Passenger.from("Eve", "Jackson"));
        entityManager.persist(Passenger.from("Fred", "Bloggs"));
        entityManager.persist(Passenger.from("Ricki", "Bobbie"));
        entityManager.persist(Passenger.from("Siya", "Kolisi"));
    }

   //...
}

4. IgnoreCase para consultas que não diferenciam maiúsculas de minúsculas

Agora, suponha que desejemos realizar uma pesquisa que não diferencia maiúsculas de minúsculas para encontrar todos os passageiros com um determinado primeiro nome.

Para fazer isso, definiremos nosso PassengerRepository como:

@Repository
public interface PassengerRepository extends JpaRepository<Passenger, Long> {
    List<Passenger> findByFirstNameIgnoreCase(String firstName);
}

Aqui, a palavra-chave IgnoreCase garante que as correspondências da consulta não diferenciam maiúsculas de minúsculas.

Também podemos testar isso com a ajuda de um teste JUnit:

@Test
public void givenPassengers_whenMatchingIgnoreCase_thenExpectedReturned() {
    Passenger jill = Passenger.from("Jill", "Smith");
    Passenger eve = Passenger.from("Eve", "Jackson");
    Passenger fred = Passenger.from("Fred", "Bloggs");
    Passenger siya = Passenger.from("Siya", "Kolisi");
    Passenger ricki = Passenger.from("Ricki", "Bobbie");

    List<Passenger> passengers = repository.findByFirstNameIgnoreCase("FrED");

    assertThat(passengers, contains(fred));
    assertThat(passengers, not(contains(eve)));
    assertThat(passengers, not(contains(siya)));
    assertThat(passengers, not(contains(jill)));
    assertThat(passengers, not(contains(ricki)));
}

Apesar de ter passado _ "FrED" _ como argumento, nossa lista retornada de passengers contém um Passenger com o firstName como _ "Fred" ._ Claramente, com a ajuda da palavra-chave IgnoreCase, conseguimos uma correspondência que não diferencia maiúsculas de minúsculas.

5. Conclusão

Neste tutorial rápido, aprendemos como criar uma consulta que não diferencia maiúsculas de minúsculas em um repositório do Spring Data.

Por fim, exemplos de código estão disponíveis over no Github.

Related