[JAVA] Résumer les principaux points de démarrage avec JPA appris avec Hibernate

1. Motivation

La société développe des applications Web utilisant le framework struts2. Cette application utilise Hibernate au lieu de JDBC pour l'accès à la base de données, mais j'étais en difficulté car je n'avais aucune connaissance. Pendant ce temps, je suis tombé sur les bons livres suivants, j'ai donc compris le contenu et résumé les principaux points.

--Introduction à JPA pour l'accès aux bases de données appris avec Seasar2 et Hibernate Écrit par Toshihiro Nakamura, publié par Mainichi Communications

2. Mots clés qui apparaissent

• JPA
• JPQL
• Cartographie O / R --N + 1 problème --Délai de chargement

3. Glossaire

a. Mappage O / R

Associez un objet Java (Object) aux données d'une base de données relationnelle (Relationnelle). Une caractéristique majeure de JPA est qu'il dispose d'une fonction de mappage O / R. D'autre part, JDBC (*) doit programmer l'association entre les objets et DB. (Le programme devient compliqué.)

• JDBC: API pour émettre du SQL à partir d'un programme Java pour accéder à la base de données

b. JPA（Java Persistence API） API incluse dans Java EE (*). JPA n'est qu'une spécification, et il existe plusieurs produits qui implémentent JPA, et les représentants sont Hibernate, TopLink Essentials et Open JPA. Aspect environnemental: peut être utilisé avec Java EE et Java SE. JDK 5.0 ou supérieur est requis.

• Java EE: Java SE avec ajout de fonctions côté serveur. Voir ci-dessous pour plus de détails.

• [Introduction à Java] La différence entre Java SE et EE et JRE / JDK est expliquée de la manière la plus compréhensible au monde. https://www.sejuku.net/blog/12902
• Différences entre Java et Java EE dans Eclipse https://qiita.com/kojocho/items/b5d3646012b7a6411c3d

c. Hibernate

Une implémentation JPA open source fournie par Red Hat. Pour utiliser Hibernate comme une implémentation JPA, vous avez besoin de trois produits: Hibernate Core, Hibernate Annotations et Hibernate Entity Manager. Par rapport à JDBC, les 4 processus suivants sont inutiles. (Les détails seront décrits plus tard)

• Instruction SQL --Remplissage des données de ResultSet
• Ressource fermer --Gestion des exceptions

4. Comment mettre en œuvre l'acquisition / la mise à jour / l'ajout / la suppression de données

JPA associe une table à une classe Java par mappage O / R et traite un enregistrement de la table comme une instance de la classe Java. Cette fois. Les classes Java sont appelées ** classes d'entité **, leurs instances sont appelées ** entités ** et les entités sont gérées via ** EntityManager **.

Lorsqu'une application demande à obtenir une entité, EntityManager vérifie d'abord si elle est mise en cache dans le contexte de persistance et renvoie l'entité mise en cache si elle existe.

L'image ressemble à ceci.

a. Acquisition de données

Il existe deux types de méthodes d'acquisition d'entités: l'acquisition de clé primaire (1) et l'acquisition de JPQL (2).

(1) Acquisition par entité

Pour obtenir une entité avec une clé primaire, utilisez la méthode *** find d'EntityManager ***.

public void findById() throws Exception{
	// EntityManager(em)Est injecté avec DI
	//Obtenez l'enregistrement (entité) dont la clé primaire de la classe Emp (table) est "1"
	Emp emp = em.find(Emp.class, 1L);
}

(2) Acquisition par JPQL

Dans le cas où l'entité n'est pas acquise en spécifiant la clé primaire, la méthode find d'EntityManager ne peut pas être utilisée, et il est nécessaire de l'implémenter dans JPQL. JPQL est le propre langage de requête de JPA et est complètement différent de SQL. Dans JPQL, vous pouvez créer un objet Query en passant un argument à la *** méthode createQuery *** d'EntityManager. Vous pouvez transmettre des paramètres de variable de liaison et des informations de pagination à Query. Les entités peuvent être obtenues en exécutant la méthode getResultList et la méthode getSingleResult de Query.

b. Mise à jour des données

Vous pouvez mettre à jour les données en obtenant l'entité que vous souhaitez mettre à jour avec EntityManager et en modifiant l'état de cette entité. EntityManager gère les données d'origine avant la modification, compare les données d'origine avec les données actuelles à un moment approprié et détecte automatiquement la mise à jour. Une instruction de mise à jour est automatiquement émise lorsqu'elle détecte qu'une entité a été mise à jour.

(La condition de la colonne de version (décrite plus loin) utilisée dans le contrôle exclusif optimiste est automatiquement ajoutée à l'instruction Update émise à ce moment.)

• JPA n'a pas de méthode pour mettre à jour les données.

public void updateEntity() throws Exception{
	// EntityManager(em)Est injecté avec DI
	//Obtenez l'enregistrement (entité) dont la clé primaire de la classe Emp (table) est "1"
	Emp emp = em.find(Emp.class, 1L);
    emp.setEmpName("NEWNAME");
    //La déclaration de mise à jour est émise automatiquement
}

c. Ajouter des données

Pour ajouter une entité, transmettez l'entité nouvellement créée à la *** méthode persist *** d'EntityManager. Si l'annotation @GeneratedValue est spécifiée pour l'enregistrement de clé primaire dans la définition de classe d'entité de la cible d'opération, elle est automatiquement définie sans définir la valeur de l'élément de clé primaire.

public void persistEntity() throws Exception{
	// EntityManager(em)Est injecté avec DI
	//Générer l'entité Emp suivante
    Emp emp = new Emp();
    emp.setEmpNo (123);
    emp.setEnpName("123Name");
    em.persist(emp);
    //La déclaration d'insertion est émise automatiquement
}

d. Supprimer les données

Pour supprimer une entité, transmettez l'entité que vous souhaitez supprimer à la *** méthode de suppression *** d'EntityManager. EntityManager émet une instruction SQL Delete au bon moment.

(La condition de la colonne de version (décrite plus loin) utilisée dans le contrôle exclusif optimiste est automatiquement ajoutée à l'instruction Delete émise à ce moment.)

public void removeEntity() throws Exception{
	// EntityManager(em)Est injecté avec DI
	//Supprimer l'entité suivante
    em.remove(emp);
    //La déclaration de suppression est émise automatiquement
}

5. Cartographie O / R

a. Annotation

Les annotations requises pour le mappage O / R sont les suivantes. Toutes ces annotations appartiennent au package "javax.persistence".

*** Pour l'attribut fetch de @ManyToOne, @OneToMany et @OneToOne, spécifiez essentiellement "fetchType.LAZY" (décrit plus loin). *** ***

b. Chargement paresseux

Lorsqu'une table a une configuration parent-enfant, la table enfant n'est pas acquise lors de l'acquisition de la table parente, mais est acquise en cas de besoin (au verso).

L'attribut fetch de @ManyToOne, @OneToMany et @OneToOne est défini par défaut sur "fetchType.EAGER", utilisez donc le chargement différé "fetchType.LAZY" sauf si vous avez une intention spécifique.

C. Problème N + 1

Émettez une instruction SELECT une fois pour obtenir N enregistrements (entités parentes) à partir de n'importe quelle table, N enregistrements émettent une instruction SELECT une fois pour obtenir les données associées (entité enfant), un total de N fois. Veuillez noter qu'une grande quantité de SQL sera émise involontairement. Il existe les deux solutions suivantes.

--Utilisation de JOIN FETCH avec JPQL -Utiliser l'annotation @Fetch

référence

• Problèmes de performance JPA et contre-mesures https://qiita.com/itagakishintaro/items/04b6933a29e92f8ee4b7

6. JPQL JPQL est interprété par l'implémentation JPA, converti en SQL adapté à la base de données à utiliser, puis exécuté. SQL a un dialecte pour chaque base de données, mais en utilisant JPQL, certaines différences entre les dialectes peuvent être absorbées.

a. Grammaire et terminologie

(1) Nom de l'entité et variable d'identification

Spécifiez le nom de l'entité (≠ nom de la table) dans la section FROM de JPQL. La variable d'identification (ci-après dénommée "e" en SQL) est déclarée après le nom de l'entité, et les éléments d'extraction, etc. sont spécifiés en l'utilisant.

• Les noms d'entités sont sensibles à la casse

select e from Employee e;

(2) Récupérer la jointure

Avec le chargement différé appliqué, les entités enfants ne sont récupérées qu'en cas de besoin. En revanche, si l'on sait que les entités enfants sont également requises depuis le début, il est plus efficace de les acquérir en même temps avec un seul SQL. Dans de tels cas, utilisez *** fetch join ***. Le SQL utilisant la jointure de récupération est le suivant.

select distinct d d from Department d inner join fetch d.employees where d.name = "ABC";

7. Cycle de vie de l'entité

a. Quatre états de l'entité

Une fois récupérée, l'entité est gérée dans un contexte persistant. Dans le contexte persistant, il est géré dans les quatre états suivants. Ces états changent en raison de l'exécution des méthodes EntityManager et de la fin des contextes persistants, et sont appelés *** cycle de vie d'entité ***. La figure est la suivante.

--Nouveau La nouvelle entité reste une nouvelle entité, sauf si vous spécifiez les méthodes persist ou merge d'EntityManager.

• Géré Lorsqu'une entité est acquise à l'aide de la méthode find ou JPQL d'EntityManager, et que l'entité est passée à la méthode merge par la méthode persist d'EntityManager, l'entité est gérée dans un contexte persistant. Les modifications de champ persistantes pour les entités gérées sont automatiquement détectées.

--Détaché Même si vous apportez des modifications à l'entité séparée, les modifications ne seront pas reflétées dans le contexte de persistance, sauf si l'entité est re-gérée par la méthode de fusion d'EntityManager.

• Supprimé La transmission d'une entité gérée à la méthode remove d'EntityManager la supprime du contexte de persistance.

b. Synchronisation de la base de données

EntityManager reflète les entités gérées et supprimées dans la base de données. Ce processus s'appelle *** synchronisation de base de données ***. La synchronisation écrit les informations de modification d'entité stockées dans le contexte de persistance dans la base de données.

La synchronisation par défaut de la base de données est la suivante:

--Lorsque la méthode flush d'EntityManager est appelée

• Juste avant que la transaction ne soit validée
• Juste avant d'exécuter l'enquête

8. Contrôle exclusif optimiste de JPA

Le contrôle exclusif inclut un contrôle exclusif pessimiste qui verrouille des données spécifiques et interdit CRUD d'autres transactions, et un contrôle exclusif optimiste qui ne verrouille pas les données et échoue l'autre traitement en cas de conflit de mise à jour. ..

JPA peut réaliser un contrôle exclusif optimiste basé sur ce numéro de version en préparant une colonne de type entier qui gère le numéro de version (affectation @Version) dans la base de données.

• Le contrôle exclusif optimiste est une méthode utilisée sur l'hypothèse que les mêmes données sont rarement mises à jour en même temps.

* Edition supplémentaire * Ce qu'il est utile de savoir

--Je veux vérifier le SQL émis par Hibernate dans le journal → Définissez "true" dans la propriété hibernate.show_sql de persistence.xml (*).

<property name = "hibernate.show_sql" value = "true" />

--Je souhaite formater et afficher le SQL dans le journal émis par Hibernate → Définissez "true" dans la propriété hibernate.format_sql de persistence.xml (*).

<property name = "hibernate.format_sql" value = "true" />

• Définissez les paramètres communs à JPA, tels que le nom de la source de données et le type de transaction, ainsi que les paramètres propres à l'implémentation JPA.