JPA prend en charge deux façons d'exprimer des requêtes pour récupérer des entités et d'autres données persistantes de la base de données: instructions de requête (Language de requête de persistance Java, JPQL) et API Critères (API Criteria). JPQL est une instruction de requête indépendante de la base de données qui est utilisée pour faire fonctionner des modèles d'entités logiques plutôt que des modèles de données physiques. L'API conditionnelle consiste à construire des conditions de requête en fonction du modèle d'entité
1. Débutant des déclarations de requête persistantes Java
La copie de code est la suivante: Liste <ponse> Persons = EntityManager.CreateeQuy ("SELECT P FROM Person P"). GetResultList ();
1. Cette instruction de requête est similaire à SQL. Mais la différence entre l'informatique et le SQL réel est qu'au lieu de faire une requête de sélection à partir d'un tableau, il spécifie l'entité du modèle de domaine d'application.
2. La clause de sélection de requête répertorie uniquement l'alias de l'entité de requête. Si vous interrogez seulement une certaine colonne, vous pouvez utiliser l'opérateur DOT (.) Pour naviguer dans les propriétés de l'entité. Comme indiqué ci-dessous:
La copie de code est la suivante: Liste <string> Persons = EntityManager.CreateeQuery ("SELECT P.FirstName From Person P"). GetResultList ();
1.1. Critères de filtre
Comme SQL, JPQL prend également en charge les clauses, qui sont utilisées pour filtrer les critères de recherche. Comprend la plupart des opérateurs, tels que: dans, entre, comme le sous-chaîne d'expression de fonction, la longueur, etc.
La copie de code est la suivante: Liste <ponse> Persons = EntityManager.CreateeQuery ("SELECT P FROM Person P Where P.Age> 23"). GetResultList ();
1.2. Résultats de la projection
Si la quantité de données interrogées est relativement importante, vous pouvez utiliser la projection pour interroger uniquement les colonnes utiles.
La copie de code est la suivante: / Liste de projet <Bject> Persons = EntityManager.CreateeQuery ("SELECT P.FirstName, P.Age From Person P"). GetResultList ();
1.3. Requête d'agrégation
La syntaxe de requête globale de JPQL est similaire à SQL. Par exemple, compter
La copie de code est la suivante: Liste <Integer> count = EntityManager.CreateEQury ("SELECT COUNT (P) FROM Person P"). GetResultList ();
1.4. Paramètres de requête
JPQL prend en charge deux types de syntaxe de liaison des paramètres.
1. Représentation des paramètres de position
Où le paramètre est indiqué dans la chaîne de requête, qui est le nombre qui suit le paramètre immédiatement après un point d'interrogation (?). Lors de l'exécution d'une requête, le développeur spécifie les paramètres qui doivent être remplacés
Query Query = EntityManager.CreateEQury ("SELECT P FROM Person P Where P.Age =? 1 et P.FirstName =? 2"); Query.setParameter (1,21); query.setParameter (2, "Jack"); 2. Notation des paramètres nommés
En suivant un côlon (:) et en l'indiquant dans la chaîne de requête, le développeur spécifie le nom du paramètre qui doit être remplacé lors de l'exécution de la requête
Query Query = EntityManager.CreateeQuery ("SELECT P FROM Person P Where P.Age =: Age and P.FirstName =: Name"); Query.setParameter ("Age", 21); query.setParameter ("Name", "Jack");2. Définissez la requête
JPA fournit des interfaces de requête et typedQuery (introduites par JPA 2.0) pour configurer et exécuter des requêtes. La requête renvoie le type d'objet, tandis que TypedQuery renvoie le type de classe spécifié.
// Aucun type spécifié, retour d'objet requête Q = entityManager.CreateEquery ("SELECT P FROM Person P"); // Spécifiez le type de retour en tant que type de personne typedQuery <ponv> Q1 = EntityManager.CreateEquery ("SELECT P FROM Person P", Person.class);2.1. Définition de la requête dynamique
Le moteur de requête JPA peut analyser les chaînes JPQL dans les arbres de syntaxe, obtenir les métadonnées des cartes relationnelles d'objets d'entité dans les expressions, puis générer un SQL équivalent. Par conséquent, il existe deux façons de mener une requête dynamique.
1. Méthode de chaîne Split
Astuce: provoquera des problèmes d'injection SQL
/ ** * CONDITIONS DE CONSTRUCTION DE CONSTRUCTION DE CONSTRUCTION Dynamique * * @param Nom * @param Age * @return * / public static String QueryPersonJPQL (nom de chaîne, int Age) {String Queryql = "SELECT P FROM Person p Where P.Firstname = '" + Name + "' and P.Age =" + Age; return queryql;} // appelle query query = EntityManager.CreateeQuey (QueryPersonJPQL ("Jack", 21)); 2. Construction paramétrée dynamique des conditions de requête (recommandée)
/ ** * Conditions de requête de construction paramétrée dynamique * * @return * / public static static QueryPersonjpqlBYPARAMS () {String Queryql = "select p Fath Person p où p.firstname =: name et p.age =: Âge"; return QueryQl;} query query = EntityManager.CreateEquery (QueryPersonJpQlByParams ()); query.setParameter ("Name", "Jack"); query.setParameter ("Age", 21);2.2. Définition de la requête nommée
La question nommée est un outil puissant. Utilisez l'annotation @NameDquery pour définir une requête nommée qui peut être placée au-dessus de la définition de classe de toute entité. Cette annotation définit le nom de la requête et de son texte.
Astuce: la requête nommée est placée sur la classe d'entité correspondant au résultat de la requête
@ Entité @ nAwequery (name = "findbyage", query = "select p from Person p où p.age =: Âge") public classe personne {// omis} Le nom défini dans la pointe: NAMSQUERY doit être unique dans toute l'unité de persistance, sinon il y aura une erreur dans l'opération.
Par exemple:
La copie de code est la suivante:
Exception dans le thread "Main" org.hibernate.DuplicateMappingException: découverte de mappage de requête en double FindByage sur org.hibernate.boot.internal.inflightMetadatacollectorImpl.checkqueryName
Appel
La copie de code est la suivante:
List <ponv> People = EntityManager.CreateNameDquery ("FindByage", Person.class) .setParameter ("Age", 21) .getResultList ();
Si une classe définit deux ou plusieurs requêtes nommées, elle doit être placée dans @NamedQueries ()
2.3.Binding Paramètres
Grâce à l'exemple précédent, nous pouvons voir qu'il existe deux façons de lier les paramètres: 1. La liaison de paramétrage de position. 2. Nom de liaison paramétrée. Tous sont liés à travers la méthode SetParameter de l'interface de requête.
1. Paramétrage de position
TypedQuery <x> setParameter (position int, valeur objet);
2. Nom paramétrage
TypedQuery <x> setParameter (nom de chaîne, valeur de l'objet);
Le premier est la liaison paramétrée de position. Si la position change, le code lié doit être modifié. Le deuxième type est recommandé.
2.4. Exécuter la requête
L'interface de requête et l'interface TypedQuery fournissent trois façons différentes d'effectuer des requêtes.
1.EXECUTEUPDATE
Utilisé pour effectuer des mises à jour par lots ou une suppression
2. GettesingleResult
Obtenez un seul ensemble de résultats. Si aucune donnée n'est obtenue, une nofferise sera lancée. Si plusieurs éléments de données sont obtenus, une non-UnimeResultexception sera lancée
3.GetResultList
Obtenez l'ensemble de résultats correspondant et spécifiez l'ordre de l'ensemble. La liste doit être utilisée comme type de valeur de retour. Si aucune donnée n'est obtenue, un ensemble vide est renvoyé et aucune exception n'est lancée
2.5. Pagination
La requête de pagination peut être remplie via les méthodes SetFirStResult () et SetMaxResults ()
Le numéro de page de requête est 0 et 2 éléments de données sont affichés sur chaque page
La copie de code est la suivante:
List <ponv> People = EntityManager.CreateeQuey ("SELECT P FROM Person P", Person.class) .setFirStResult (0) .SetMaxResults (2) .getResultList ();
Conseil: ne peut pas être utilisé pour les requêtes connectées par les relations de collecte, car ces requêtes peuvent renvoyer des valeurs en double.
2.6. Timeout de requête
Si une application doit définir une limite de temps de réponse de la requête, vous pouvez définir la propriété javax.persistence.query.timeout dans la requête (introduite par JPA 2.0) ou l'utiliser dans le cadre de la propriété Persistance. Cette propriété définit le nombre de millisecondes == autorisée à fonctionner avant la résiliation de la requête. Si le délai d'expiration de la requête, une question de requête enTexception sera lancée.
TypedQuery <ponge> Query = EntityManager.Createery ("SELECT P FROM Person P", Person.class); // L'unité est millisecondes javax.persistence.query.timeoutQuery.sethint ("javax.persistence.Query.timeout", 5000); List <ponde> People = Query.getResultList ();2.7. Mises à jour par lots et suppressions
L'entité de mise à jour par lots est terminée via l'instruction de mise à jour. La suppression par lots d'entités se fait via des instructions de suppression. Les deux spécifient les propriétés d'une entité et de sa classe.
entityManager.getTransaction (). begin (); query query = EntityManager.CreateEquery ("Update Person p set p.firstName =: name où p.id =: id"); query.setParameter ("name", "xiaobai"); query.setparamètre ("id", 2); query.executeupdate (); query query1 = EntityManager.CreateEarery ("Delete Person P Where P.Id =: Id"); query1.setParameter ("Id", 9); query1.ExecuteUpdate (); EntityManager.GetTransaction (). Commit ();3. Suggestions d'utilisation de la requête JPQL
Dans les systèmes d'application, le nombre de requêtes est généralement utilisé plus que l'ajout, la modification et la suppression. Par conséquent, il est particulièrement important d'utiliser la requête et de s'afficher raisonnablement.
1. Il est recommandé d'utiliser la question nommée (NAWQUERY)
Les programmes fournis par la persistance utilisent généralement des méthodes précompilées pour utiliser les requêtes nommées dans le cadre de la phase d'initialisation du programme. Cela évite les frais généraux du système de l'analyse continue de JPQL et la génération de SQL.
2. Utilisez d'abord la projection pour récupérer un petit nombre de colonnes.
La requête JPA renvoie généralement toutes les colonnes de l'entité entière, mais pour une énorme quantité de données, toutes les colonnes d'entités ne doivent pas être utilisées. Ensuite, nous pouvons utiliser la projection pour le gérer.
List <list <object [] >> Persons = EntityManager.CreateEquery ("Select New List (FirstName, Age) From Person P"). GetResultList (); pour (objet O: Persons) {System.out.println (O);} // Output Result [Jack, 21] [Jack, 21] [Jack, 21] [Lily, 19] [Tom, 23] [Tom, 23]Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.