JPA admite dos formas de expresar consultas para recuperar entidades y otros datos persistentes de la base de datos: declaraciones de consulta (lenguaje de consulta de persistencia Java, JPQL) y API de criterios (API de criterios). JPQL es una declaración de consulta independiente de la base de datos que se utiliza para operar modelos de entidades lógicas en lugar de modelos de datos físicos. La API condicional es construir condiciones de consulta basadas en el modelo de entidad
1. Comenzando con Java Declaraciones de consultas persistentes
La copia del código es la siguiente: List <Oll> Persons = EntityManager.CreateChery ("Seleccione P de la persona P"). GetResultList ();
1. Esta declaración de consulta es similar a SQL. Pero la diferencia entre TI y SQL real es que, en lugar de hacer una consulta de selección desde una tabla, especifica la entidad del modelo de dominio de la aplicación.
2. La cláusula de selección de consulta solo enumera el alias de la entidad de consulta. Si solo consulta una determinada columna, puede usar el operador Dot (.) Para navegar por las propiedades de la entidad. Como se muestra a continuación:
La copia del código es la siguiente: List <String> Persons = EntityManager.CreateQuery ("Seleccione P.FirstName de la persona P"). GetResultList ();
1.1. Criterio de filtro
Al igual que SQL, JPQL también admite dónde las cláusulas, que se utilizan para filtrar los criterios de búsqueda. Incluye la mayoría de los operadores, como: en, entre, como, como, la subcadena de expresión de funciones, longitud, etc.
La copia del código es la siguiente: Lista <Oll> Persons = EntityManager.CreateChery ("Seleccione P de la persona P donde P.AGE> 23"). GetResultList ();
1.2. Resultados de proyección
Si la cantidad de datos consultado es relativamente grande, puede usar la proyección para consultar solo columnas útiles.
La copia del código es la siguiente:/Lista de proyectos <S Object> Persons = EntityManager.CreateQuery ("Seleccione P.FirstName, P.AGE de Person P"). GetResultList ();
1.3. Consulta de agregación
La sintaxis de consulta agregada de JPQL es similar a SQL. Por ejemplo contar
La copia del código es la siguiente: List <Integer> Count = EntityManager.CreateQuery ("Seleccione Conte (P) de la persona P"). GetResultList ();
1.4. Parámetros de consulta
JPQL admite dos tipos de sintaxis de unión de parámetros.
1. Representación de parámetros de posición
Donde el parámetro se indica en la cadena de consulta, que es el número que sigue el parámetro inmediatamente después de un signo de interrogación (?). Al ejecutar una consulta, el desarrollador especifica los parámetros que deben reemplazarse
Consulta consulta = entityManager.createQuery ("Seleccione P de la persona P donde p.age =? 1 y p.firstname =? 2"); Query.SetParameter (1,21); Query.SetParameter (2, "Jack"); 2. Notación de parámetros con nombre
Siguiendo un colon (:) e indicándolo en la cadena de consulta, el desarrollador especifica el nombre del parámetro que debe reemplazarse al ejecutar la consulta
Consulta consulta = entityManager.createQuery ("Seleccione P de la persona P Where p.age =: edad y p.firstname =: name"); Query.SetParameter ("Age", 21); Query.SetParameter ("Nombre", "Jack");2. Defina la consulta
JPA proporciona interfaces consultas y typedQuery (introducidas por JPA 2.0) para configurar y ejecutar consultas. La consulta devuelve el tipo de objeto, mientras que TypedQuery devuelve el tipo de clase especificado.
// sin tipo especificado, return Tipo de objeto Consulta q = entityManager.CreateQuery ("Seleccione P de la persona P"); // Especifique el tipo de retorno como Tipo de persona TypedQuery <Oll> Q1 = EntityManager.CreateQuery ("Seleccione P de Person P", Person.class);2.1. Definición de consulta dinámica
El motor de consultas JPA puede analizar las cadenas JPQL en árboles de sintaxis, obtener los metadatos de los mapas de los objetos de la entidad en las expresiones y luego generar SQL equivalente. Por lo tanto, hay dos formas de realizar una consulta dinámica.
1.Split String Method
Consejo: causará problemas de inyección SQL
/** * Condiciones de consulta de construcción de cadena de empalme dinámico * * @param nombre * @param edad * @return */public static string Querypersonjpql (name de cadena, int ave) {String QUERYQL = "Seleccione P de Persona P Where P.FirstName = '" + Name + "' y P.age =" + Age; return Queryql;} // consulta de consulta de llamada = entityManager.createQuery (Querypersonjpql ("Jack", 21)); 2. Construcción parametrizada dinámica de condiciones de consulta (recomendado)
/** * Condiciones de consulta de construcción parametrizada dinámica * * @return */public static string QuerypersonjpqlByParams () {String QUERYQL = "Seleccione P de la persona P Where P.FirstName =: Name and P.AGE =: Age"; return Queryql;} Query Query = EntityManager.CreateQuery (QuerypersonjpqlByParams ()); Query.SetParameter ("Nombre", "Jack"); Query.SetParameter ("Age", 21);2.2. Definición de consulta nombrada
La consulta nombrada es una herramienta poderosa. Use la anotación @NamedQuery para definir una consulta con nombre que se puede colocar encima de la definición de clase de cualquier entidad. Esta anotación define el nombre de la consulta y su texto.
Consejo: la consulta nombrada se coloca en la clase de entidad correspondiente al resultado de la consulta
@Entity@namedQuery (name = "findByage", query = "Seleccione P de la persona P P.AGE =: Age") Persona de clase pública {// omitido} El nombre definido en el consejo: NamedQuery debe ser único en toda la unidad de persistencia, de lo contrario habrá un error en la operación.
p.ej:
La copia del código es la siguiente:
Excepción en el hilo "principal" org.hibernate.dupplicateMappingException: mapeo de consultas duplicados FindByage en org.hibernate.boot.internal.inflightmetadataCollectorImpl.CheckQueryName
Llamar
La copia del código es la siguiente:
Lista <Oll> People = EntityManager.CreateDeCyQuery ("FindByGyage", Person.Class) .SetParameter ("Age", 21) .getResultList ();
Si una clase define dos o más consultas con nombre, debe colocarse en @namedqueries ()
2.3. Parámetros de fijación
A través del ejemplo anterior, podemos ver que hay dos formas de unir los parámetros: 1. Unión de parametrización de posición. 2. Nombre de enlace parametrizado. Todos están unidos a través del método SetParameter de la interfaz de consulta.
1. Parametrización de posición
TypedQuery <x> setParameter (intica int, valor de objeto);
2. Parametrización de nombre
TypedQuery <x> setParameter (nombre de cadena, valor de objeto);
El primero es la posición de enlace parametrizado de posición. Si la posición cambia, el código límite debe cambiarse. Se recomienda el segundo tipo.
2.4. Ejecutar consulta
La interfaz de consulta y la interfaz TypedQuery proporcionan tres formas diferentes de realizar consultas.
1.ExCuteUpdate
Se utiliza para realizar actualizaciones o eliminación por lotes
2.getSinglerEsult
Obtenga un solo conjunto de resultados. Si no se obtienen datos, se lanzará una noresultException. Si se obtienen múltiples datos, se lanzará una no uniqueresultException
3.getResultList
Obtenga el conjunto de resultados correspondiente y especifique el orden del conjunto. La lista debe usarse como tipo de valor de retorno. Si no se obtienen datos, se devuelve un conjunto vacío y no se arroja ninguna excepción
2.5. Paginación
La consulta de paginación se puede completar a través de los métodos setFirStresult () y setmaxResults ()
El número de página de consulta es 0, y se muestran 2 datos en cada página
La copia del código es la siguiente:
Lista <Oll> People = EntityManager.CreateQuery ("Seleccione P de la persona P", Person.Class) .SetFirStresult (0) .SetMaxResults (2) .getResultList ();
Consejo: no se puede utilizar para consultas conectadas por las relaciones de recolección, porque estas consultas pueden devolver los valores duplicados.
2.6. Tiempo de espera de la consulta
Si una aplicación necesita establecer un límite en el tiempo de respuesta de la consulta, puede establecer la propiedad javax.persistence.query.timeout en la consulta (introducida por JPA 2.0) o usarla como parte de la propiedad de persistencia. Esta propiedad define el número de == milisegundos permitidos para ejecutarse antes de que termine la consulta. Si el tiempo de espera de la consulta, se lanzará una consulta TimeOutException.
TypedQuery <Oller> QUERY = EntityManager.CreateQuery ("Seleccione P de Persona P", Person.class); // La unidad es MilliseConds javax.persistence.Query.timeoutquery.sethint ("javax.persistence.Query.timeout", 5000); Listing People = Quercy.gergeResultlist (););2.7. Actualizaciones y deleciones de lotes
La entidad de actualización de lotes se completa a través de la declaración de actualización. La eliminación por lotes de las entidades se realiza a través de declaraciones de eliminación. Ambos especifican las propiedades de una entidad y su clase.
entityManager.getTransaction (). begin (); Query Query = EntityManager.CreateQuery ("Actualizar Persona P Set P.FirstName =: Name Where P.ID =: ID"); Query.SetParameter ("Nombre", "Xiaobai"); Query.SetParameter ("id", 2); Query.ExecuteUpdate (); QUERY1 = QUERY1 = entityManager.createQuery ("Eliminar persona p donde p.id =: id"); query1.setParameter ("id", 9); Query1.ExecuteUpdate (); entityManager.getTransaction (). commit ();3. Sugerencias para usar la consulta JPQL
En los sistemas de aplicación, el número de consultas generalmente se usa más que agregar, modificar y eliminar. Por lo tanto, es particularmente importante usar la consulta y mostrar razonablemente.
1. Se recomienda usar la consulta nombrada (NamedQuery)
Los programas proporcionados por persistencia generalmente usan métodos precompilados para usar consultas con nombre como parte de la fase de inicialización del programa. Esto evita la sobrecarga del sistema del análisis continuo de JPQL y la generación de SQL.
2. Use la proyección para recuperar un pequeño número de columnas primero.
La consulta JPA generalmente devuelve todas las columnas de toda la entidad, pero para una gran cantidad de datos, no todas las columnas de entidad deben usarse. Entonces podemos usar la proyección para manejarla.
LIST <LIST <Object [] >> Persons = EntityManager.CreateQuery ("Seleccione nueva lista (FirstName, Age) de la persona P"). GetResultList (); para (Object O: Persons) {System.out.println (O);} // Resultado de salida [Jack, 21] [Jack, 21] [Jack, 21] [Lily, 19] [Tom, 23] [Tom, 23]Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.