Cómo Crear Consultas Sin Distinción de Mayúsculas y Minúsculas en Spring Data JPA

En este artículo, exploraremos cómo crear rápidamente una consulta sin distinción de mayúsculas y minúsculas en un repositorio de Spring Data JPA. Por defecto, las consultas de Spring Data JPA son sensibles a las mayúsculas, lo que puede ser un desafío cuando necesitamos comparar cadenas de texto sin tomar en cuenta el caso. Aprendamos juntos este aspecto fundamental del desarrollo en Java.

1. Overview

Spring Data JPA queries, by default, are case-sensitive. In other words, the field value comparisons are case-sensitive. En este tutorial, exploraremos cómo crear rápidamente una consulta sin distinción de mayúsculas y minúsculas en un repositorio de Spring Data JPA. Esto es especialmente útil en aplicaciones donde queremos que la búsqueda no se vea afectada por si el usuario introdujo texto en mayúsculas o en minúsculas.

2. Dependencies

Primero, asegúrate de que tenemos las dependencias de Spring Data y de la base de datos H2 en nuestro archivo pom.xml:

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

Las últimas versiones de estas dependencias están disponibles en Maven Central y H2.

3. Initial Setup

Supongamos que tenemos una entidad Passenger con los atributos id, firstName y 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...
}

También prepararemos nuestra clase de prueba llenando la base de datos con algunos datos de muestra de 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 Sin Distinción de Mayúsculas y Minúsculas

Ahora, supongamos que queremos realizar una búsqueda sin distinción de mayúsculas y minúsculas para encontrar todos los pasajeros con un determinado firstName. Para hacer esto, definiremos nuestro PassengerRepository de la siguiente manera:

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

Aquí, el keyword IgnoreCase asegura que las coincidencias en la consulta sean sin distinción de mayúsculas y minúsculas.

Podemos también probar esto con la ayuda de una prueba de JUnit:

@Test
public void givenPassengers_whenMatchingIgnoreCase_thenExpectedReturned() {
    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)));
}

A pesar de haber pasado "FrED" como argumento, nuestra lista de passengers contiene un Passenger con el firstName "Fred." Claramente, con la ayuda del keyword IgnoreCase, hemos logrado una coincidencia sin distinción de mayúsculas y minúsculas.

5. Conclusión

En este breve tutorial, aprendimos cómo crear una consulta sin distinción de mayúsculas y minúsculas en un repositorio de Spring Data.

Consejos prácticos para programadores de JAVA:

• Utiliza IgnoreCase en tus repositorios: Siempre que necesites realizar búsquedas que no sean sensibles a los casos, asegúrate de utilizar IgnoreCase en tus métodos de repositorio.
• Pruebas unitarias: No subestimes la importancia de probar tus métodos de consulta. Las pruebas unitarias garantizan que tu lógica de búsqueda se comporta como esperas, incluso en situaciones de entrada diversa.
• Mantén tus dependencias actualizadas: Revisa periódicamente las versiones de tus dependencias para asegurarte de que estás aprovechando las últimas mejoras y correcciones de seguridad.
• Optimiza las consultas: Si trabajas con grandes conjuntos de datos, considera la posibilidad de optimizar tus consultas y utilizar índices para mejorar el rendimiento.

Implementar consultas sin distinción de mayúsculas y minúsculas puede mejorar significativamente la experiencia del usuario y ofrecer resultados más relevantes. Utiliza estas herramientas y técnicas para mejorar tus aplicaciones y ofrecer una búsqueda eficiente.