Métodos find en repositorios

Consultas con métodos derivados

Los métodos derivados en Spring Data JPA representan una de las características más elegantes del framework, permitiendo crear consultas automáticamente basándose únicamente en el nombre del método. Esta funcionalidad elimina la necesidad de escribir código SQL o JPQL para operaciones comunes de consulta.

Spring Data JPA analiza el nombre del método y genera automáticamente la consulta correspondiente. El framework utiliza convenciones de nomenclatura específicas que traducen directamente a operaciones de base de datos, lo que resulta en un código más limpio y mantenible.

Estructura básica de los métodos derivados

Los métodos derivados siguen un patrón específico que comienza con palabras clave como find, get, query, count o delete, seguidas de By y los criterios de búsqueda:

@Repository
public interface UsuarioRepository extends JpaRepository<Usuario, Long> {
    
    // Buscar por nombre
    List<Usuario> findByNombre(String nombre);
    
    // Buscar por email
    Optional<Usuario> findByEmail(String email);
    
    // Contar usuarios por estado
    long countByActivo(boolean activo);
}

La palabra clave inicial determina el tipo de operación que se realizará. findBy genera una consulta SELECT, countBy cuenta registros, y deleteBy elimina registros que coincidan con los criterios especificados.

Consultas por propiedades simples

Las consultas más básicas buscan por una sola propiedad de la entidad. Spring Data JPA mapea automáticamente el nombre de la propiedad en el método con el campo correspondiente en la base de datos:

public interface ProductoRepository extends JpaRepository<Producto, Long> {
    
    // SELECT * FROM producto WHERE nombre = ?
    List<Producto> findByNombre(String nombre);
    
    // SELECT * FROM producto WHERE precio = ?
    List<Producto> findByPrecio(BigDecimal precio);
    
    // SELECT * FROM producto WHERE categoria_id = ?
    List<Producto> findByCategoriaId(Long categoriaId);
}

Es importante que el nombre de la propiedad en el método coincida exactamente con el nombre del atributo en la entidad Java. Spring Data JPA es sensible a mayúsculas y minúsculas en este aspecto.

Operadores de comparación

Los métodos derivados soportan diversos operadores de comparación que se expresan mediante sufijos específicos en el nombre del método:

public interface ProductoRepository extends JpaRepository<Producto, Long> {
    
    // Mayor que
    List<Producto> findByPrecioGreaterThan(BigDecimal precio);
    
    // Menor que
    List<Producto> findByPrecioLessThan(BigDecimal precio);
    
    // Mayor o igual que
    List<Producto> findByPrecioGreaterThanEqual(BigDecimal precio);
    
    // Menor o igual que
    List<Producto> findByPrecioLessThanEqual(BigDecimal precio);
    
    // Entre dos valores
    List<Producto> findByPrecioBetween(BigDecimal min, BigDecimal max);
}

Estos operadores se traducen directamente a las cláusulas SQL correspondientes, proporcionando una forma intuitiva de expresar condiciones de rango y comparación.

Consultas con múltiples criterios

Los métodos derivados permiten combinar múltiples criterios utilizando las palabras clave And y Or:

public interface UsuarioRepository extends JpaRepository<Usuario, Long> {
    
    // Combinación con AND
    List<Usuario> findByNombreAndEmail(String nombre, String email);
    
    // Combinación con OR
    List<Usuario> findByNombreOrEmail(String nombre, String email);
    
    // Múltiples condiciones
    List<Usuario> findByNombreAndActivoAndEdadGreaterThan(
        String nombre, boolean activo, int edad);
}

El orden de los parámetros del método debe coincidir exactamente con el orden en que aparecen las propiedades en el nombre del método. Esta correspondencia es fundamental para que Spring Data JPA genere correctamente la consulta.

Operaciones con cadenas de texto

Para trabajar con campos de texto, Spring Data JPA ofrece operadores específicos que facilitan búsquedas flexibles:

public interface ProductoRepository extends JpaRepository<Producto, Long> {
    
    // Contiene texto (LIKE %texto%)
    List<Producto> findByNombreContaining(String texto);
    
    // Comienza con texto (LIKE texto%)
    List<Producto> findByNombreStartingWith(String prefijo);
    
    // Termina con texto (LIKE %texto)
    List<Producto> findByNombreEndingWith(String sufijo);
    
    // Ignora mayúsculas y minúsculas
    List<Producto> findByNombreIgnoreCase(String nombre);
    
    // Combinación de operadores
    List<Producto> findByNombreContainingIgnoreCase(String texto);
}

Estos operadores son especialmente útiles para implementar funcionalidades de búsqueda donde los usuarios pueden introducir términos parciales o con diferentes combinaciones de mayúsculas y minúsculas.

Ordenación y limitación de resultados

Los métodos derivados pueden incluir criterios de ordenación utilizando la palabra clave OrderBy:

public interface ProductoRepository extends JpaRepository<Producto, Long> {
    
    // Ordenar por precio ascendente
    List<Producto> findByActivoOrderByPrecioAsc(boolean activo);
    
    // Ordenar por precio descendente
    List<Producto> findByActivoOrderByPrecioDesc(boolean activo);
    
    // Múltiples criterios de ordenación
    List<Producto> findByActivoOrderByPrecioAscNombreDesc(boolean activo);
    
    // Limitar resultados
    List<Producto> findTop5ByActivoOrderByPrecioDesc(boolean activo);
    
    // Primer resultado
    Optional<Producto> findFirstByActivoOrderByPrecioAsc(boolean activo);
}

La limitación de resultados mediante Top o First es útil para obtener los elementos más relevantes según los criterios de ordenación establecidos.

Consultas de existencia y conteo

Spring Data JPA proporciona métodos especializados para verificar la existencia de registros y realizar conteos:

public interface UsuarioRepository extends JpaRepository<Usuario, Long> {
    
    // Verificar existencia
    boolean existsByEmail(String email);
    
    // Contar registros
    long countByActivo(boolean activo);
    
    // Contar con múltiples criterios
    long countByActivoAndEdadGreaterThan(boolean activo, int edad);
    
    // Verificar existencia con múltiples criterios
    boolean existsByNombreAndEmail(String nombre, String email);
}

Estos métodos son más eficientes que recuperar todos los registros y luego verificar su existencia o contar elementos en memoria, ya que la operación se realiza directamente en la base de datos.

Consultas con valores nulos

Los métodos derivados también permiten trabajar con valores nulos mediante operadores específicos:

public interface UsuarioRepository extends JpaRepository<Usuario, Long> {
    
    // Campos que son null
    List<Usuario> findByTelefonoIsNull();
    
    // Campos que no son null
    List<Usuario> findByTelefonoIsNotNull();
    
    // Combinación con otros criterios
    List<Usuario> findByActivoAndTelefonoIsNotNull(boolean activo);
}

Esta funcionalidad es especialmente útil para filtrar registros basándose en la presencia o ausencia de información opcional en los campos de la entidad.

Ejemplo práctico completo

Consideremos un repositorio completo que demuestra la versatilidad de los métodos derivados:

@Repository
public interface ProductoRepository extends JpaRepository<Producto, Long> {
    
    // Búsquedas básicas
    List<Producto> findByNombre(String nombre);
    Optional<Producto> findByCodigo(String codigo);
    
    // Búsquedas con rangos
    List<Producto> findByPrecioBetween(BigDecimal min, BigDecimal max);
    List<Producto> findByFechaCreacionAfter(LocalDateTime fecha);
    
    // Búsquedas de texto
    List<Producto> findByNombreContainingIgnoreCase(String termino);
    List<Producto> findByDescripcionStartingWith(String prefijo);
    
    // Múltiples criterios
    List<Producto> findByActivoAndPrecioLessThan(boolean activo, BigDecimal precio);
    List<Producto> findByCategoriaIdAndActivoOrderByNombreAsc(Long categoriaId, boolean activo);
    
    // Conteos y existencia
    long countByActivo(boolean activo);
    boolean existsByCodigo(String codigo);
    
    // Limitación de resultados
    List<Producto> findTop10ByActivoOrderByFechaCreacionDesc(boolean activo);
    Optional<Producto> findFirstByActivoOrderByPrecioAsc(boolean activo);
}

Los métodos derivados proporcionan una solución elegante para la mayoría de consultas comunes en aplicaciones Spring Boot, reduciendo significativamente la cantidad de código necesario y mejorando la legibilidad del repositorio.