Implementar las operaciones de Consulta con JPA Repository

Clase 23 de 38 • Curso de Hibernate y Java Spring 2018

Resumen

Spring Data cuenta con soporte para realizar consultas personalizadas basado en los atributos de la clase base que se generan de forma automática en el tiempo de ejecución (Query Generation Strategy). También soporta otro tipo de consultas basadas en JPQL (Java Persistence Query Language) como @Query y @NamedQuery.

Mauro Gomez

student•

Para las consultas a bases de datos recomiendo el uso de patrón Criteria aquí ponen un ejemplo. Eso para evitar tener esos metodos buscarPor* https://www.arquitecturajava.com/jpa-criteria-api-un-enfoque-diferente/

William Rodriguez

student•

Interesante aporte

Cesar David Ramírez Dimaté

student•

JPA Criteria API es una forma antigua de hacerlo, aprox de hace 5 o 7 años ya que depende de un EntityManager para la construcción y ejecución de un query.

Pero bueno, es una forma de hacerlo como muchas que existen en el mercado.

Claudio Jesus Vázquez Villanueva

student•

Les recuerdo que Todos los DDLs son en Mayuscula.

Edinson Padrón

student•

Recomiendo darle un vistazo a JOOQ: https://www.jooq.org/

Luis Fernando Pedroza Taborda

student•

Excelente aporte EPadronU23, muchas gracias.

Luis José Villarreal Rincón

student•

para mejorar un poco la consulta de fechas, lo que se hizo (se que fue un ejemplo) fue igualar las fechas, osea esa consulta solo se aplicará cuando los parametros sean iguales. Yo aplicaría lo siguiente:

@Query("select r from Reserva r where r.fechaIngresoRes >=: fechaIngreso and r.fechaSalidaRes <=: fechaSalida")
    public List<Reserva> find(@Param("fechaIngreso")Date fechaIngreso, @Param("fechaSalida") Date fechaSalida);

Nadir Antonio Soza Solis

student•

Hola Marcos, nos regalas el link de ducumentacion de las palabras reservadas porfa.

Marco Antonio Toscano Freire

teacher•

Hola Nardis en el apendice C puedes revisarle.

Alex Soto Mendez

student•

Palabras reservadas

Juan Felipe Zuluaga Gómez

student•

Si quiera crear un servicio en el que la consulta se arme de forma dinámica, es decir, si tenemos la clase Cliente, y tiene 3 campos, que la consulta se pueda hacer por 1 campo, 2 campos cualquiera o los 3.

Logré hacerlo con Criteria Query, también he leído algo con procedimientos almacenados, pero quisiera saber si en sus experiencias tienen una forma mas optima de hacerlo.

Gracias.

William Rodriguez

student•

Interesante la clase

Cesar Figueroa

student•

Muy interesante las consultas que hace hibernate

César Espitia

student•

No es que el nombre del método sea o use una palabras reservadas. Lo que pasa es que la interface padre JpaRepository tiene métodos que utilizan las palabras "findBy" como: findById() o findAllById().

Jorge Alexander López Molina

student•

Para la consulta de las fechas de ingreso y salida en la interfaz de reserva según la documentación de Spring se debería utilizar etiquetas como value y nativeQuery?

@Query(value="Select r from Reserva r where r.fechaIngresoRes = :fechaInicio "
			+ "and r.fechaSalidaRes = :fechaSalida", nativeQuery = true)
	public List<Reserva> find(@Param("fechaInicio") Date fechaInicio, 
			@Param("fechaSalida") Date fechaSalida);

Harrison Gutierrez Coronado

student•

En este caso como tienes la notación de la consulta, si es necesario agregar el nativeQuery.

Luis Guzmán

student•

Como dice Jorge si se maneja fechas es necesario cambiar a nativeQuery

@Query(Select r frp, Reserva r Where r.fechaIngresoRes>= :fechaIngresoRes AND r.fechaSalidaRes <= :fechaSalidaRes")

Por

@Query(value = "Select r frp, Reserva r Where r.fechaIngresoRes>= :fechaIngresoRes AND r.fechaSalidaRes <= :fechaSalidaRes", nativeQuery = true)

Caso contrario al realizar Maven build presenta error

java.lang.IllegalArgumentException:  Validation failed for query Repository.find(java.util.Date

Mario Jesús Arango Cupe

student•

Si quisiera un metodo que haga consultas en donde traiga distintos atributos de distintas tablas segun su relacion, "join", como se haria?

Alexander Galvis

student•

Puedes definir namedquery para realizar eso, en la clase respectiva según tu necesidad, también puedes armar tu query usando el criteriabuilder lo cual hace parte de JPA. También hay opciones como el uso de JOOQ, algunos links acá: https://www.objectdb.com/java/jpa/query/named https://www.objectdb.com/java/jpa/query/criteria https://www.jooq.org/doc/3.12/manual/getting-started/tutorials/jooq-in-7-steps/

Rodrigo Machado

student•

Le dejo al profe un link para eliminar el tema de la muletillas. https://www.youtube.com/watch?v=kLsnNPF1gqw

Diego Armando Ubilluz Carrillo

student•

Estas 2 ultimas clases estan geniales :D

Alexander Moreno

student•

ya era justo, estaba a punto de cambiar de curso

Cesar David Ramírez Dimaté

student•

Iba a escribir lo mismo. Ahora si estoy viendo anotaciones y construcción de queries bastante interesantes.

Luis Fernando Pedroza Taborda

student•

Vaya que locura que hayan 3 maneras de implementar consultas con JPA Repository, de verdad Spring es muy interesante.

Cristhian Maciel

student•

Como JPA sabe armar la query a partir del metodo findByApellidoCli? Veo que no se tiene que implementar ese metodo y no me queda claro esa magia....

Luis Romero

student•

----- RESPUESTA LARGA -----

En Spring Data JPA, al momento de definir métodos encargados de la persistencia de datos, puedes usar diferentes sintáxis para armar los queries.

Por ejemplo, se puede definir en una anotación @query, @namedQuery o @namedNativeQuery

Tu consulta es sobre una cuarta opción, Query DSL (Domain Specific languaje). Y la respuesta es que Spring compara la sintaxis que estás escribiendo con su lógica para la persistencia de datos, verifica que sea correcta y la transforma en una consulta SQL válida.

Es decir, nos permite escribir menos código y sustituir la sintaxis SQL en casos puntuales, nos da un abanico de opciones.

Al escribir:

List<entidad>findBy[campo](String valor);

Spring sabe que debe buscar en la columna [campo] todas las coincidencias de [valor] y regresarlas en una lista de objetos del tipo [entidad]

Spring tiene una lista de prioridades para evaluar cuál método estamos usando:

Evalua si existe la anotación @Query
Evalua si existe la anotacion @NamedQuery o @NamedNativeQuery
Y por último, intenta detectar una sintaxis válida de Query DSL en el nombre del método

Complemento: Mira como uso el método anterior y utilizando query DSL le digo a Spring Data JPA que ordene los resultados por [campo2] de manera ascendente

List<entidad>findBy[campo]OrderBy[campo2]Asc(String valor);

----- RESPUESTA CORTA -----

Es magia, Query DSL nos ayuda a escribir muchísimo menos código, aunque no siempre es conveniente usarlo

Leonel Lopez

student•

La notacion correcta no deberia ser "findByIdentificacionCli" ?

Daniel Alejandro Vera Chávez

student•

Tengo una duda respecto a la configuración del archivo yaml. Cuando se especifica que se generen las sentencias DLL. Que sucede en los casos en que se agregan atributos a las clases Cliente, Reserva? El framework realizaría los ALTER para agregar o quitar las columnas? Y Cuando se agregan las relaciones en las clases, esto hace que se creen las claves primarias y foráneas en la base de datos? o estas definiciones no pasan a las estructuras de la base de datos?

Mario Ignacio Ledesma Merino

student•

Hola @Daniel, cuando agregas las sentencias de alter, al compilarse tu aplicación, el ORM se encarga de verificar las diferencias entre tu base de datos, y efectivamente se encarga de agregar y quitar las columnas que falten. Las relaciones también son afectadas, siempre y cuando se encuentren mapeadas de manera correcta en tu código.

Saludos.

Carlos Villanueva A.

student•

por que menciona c.identificacionCli? si en la definicion de la clase se llama idCli

JESUS ALMIRCAR CASTELLANOS

student•

✅Ir a repositorio
✅Ir a repositorio

Francisco Ruiz Lezcano

student•

También se puede realziar de la siguiente forma

@NamedQueries({
        @NamedQuery(name = "Client.findByEmail", query = "select c from Client c where c.email = :email"),
        @NamedQuery(name = "Client.findByIdentity", query = "select c from Client c where c.identity = :identity"),
        @NamedQuery(name = "Client.findByPhone", query = "select c from Client c where c.phone = :phone"),
})
public class Client implements Serializable {

@NamedQueries({
        @NamedQuery(name = "Reserve.findByClient", query = "select r from Reserve r where r.client = :client"),
        @NamedQuery(name = "Reserve.findByCheckInDate", query = "select r from Reserve r where r.checkInDate = :checkInDate"),
        @NamedQuery(name = "Reserve.findByEgressDate", query = "select r from Reserve r where r.egressDate = :egressDate"),
})
public class Reserve implements Serializable {

public interface ClientRepository extends JpaRepository<Client, Integer> {

    /**
     * @param email
     * @return Client
     * @author Francisco
     * */
    public Client findByEmail(@Param("email") String email);

    /**
     * @param identity
     * @return Client
     * @author Francisco
     * */
    public Client findByIdentity(@Param("identity") String identity);

    /**
     * @param phone
     * @return Client
     * @author Francisco
     * */
    public Client findByPhone(@Param("phone") String phone);

}

public interface ReserveRepository extends JpaRepository<Reserve, Integer> {

    /**
     * @param client
     * @return List<Reserve>
     * @author Francisco
     * */
    public List<Reserve> findByClient(@Param("client") Client client);

    /**
     * @param checkInDate
     * @return List<Reserve>
     * @author Francisco
     * */
    public List<Reserve> findByCheckInDate(@Param("checkInDate") Date checkInDate);

    /**
     * @param egressDate
     * @return List<Reserve>
     * @author Francisco
     * */
    public List<Reserve> findByEgressDate(@Param("egressDate") Date egressDate);
}