JPA fournit une spécification ORM standardisée tandis que Hibernate l'implémente avec des fonctionnalités ajoutées. Utilisez JPA pour la portabilité et l'hibernate pour les capacités avancées. Les entités passent à travers des états transitoires, gérés, détachés et supprimés dans le contexte de persistance, ce qui assure la cartographie de l'identité. Préférez toujours FetchType.lazy pour les collections pour éviter le problème N 1, mais résolvez-le en utilisant la jointure Fetch, @entityGraph ou @BatchSize en cas de besoin. Activez la mise en cache de deuxième niveau avec prudence avec des fournisseurs comme la caféine et utilisez la mise en cache de requête uniquement à c?té. Appliquer le verrouillage optimiste via @version par défaut pour une meilleure évolutivité, en réservant le verrouillage pessimiste pour les scénarios à forte contention. évitez les appels inutiles Flush (), utilisez des projections DTO au lieu d'entités complètes lorsque cela est possible, fermez rapidement les sessions, initialisez les données paresseuses avant le rendu et utilisez @DamicupDate pour optimiser SQL. La récupération, la mise en cache, le contr?le concurrentiel et la gestion du contexte sont essentielles pour une persistance haute performance.

Java Persistance avec JPA et Hibernate est la pierre angulaire du développement de Java en entreprise moderne. Alors que JPA (Java Persistance API) fournit un moyen standardisé de gérer les données relationnelles dans les applications Java, Hibernate est l'implémentation JPA la plus utilisée, offrant des fonctionnalités puissantes et une flexibilité. Cette plongée profonde explore les concepts clés, les meilleures pratiques et les pièges communs lorsque vous travaillez avec JPA et Hibernate.

Comprendre la relation JPA et Hibernate

JPA est une spécification - une partie de Jakarta EE (anciennement Java EE) - qui définit comment les objets Java sont mappés sur des tables de base de données. Il fournit des annotations, des API et des contrats pour la cartographie relationnelle des objets (ORM), mais n'inclut pas une implémentation concrète.

Hibernate, en revanche, est un cadre ORM complet qui implémente la spécification JPA. Vous pouvez utiliser des annotations JPA (comme @Entity , @Id , @OneToMany ) avec Hibernate comme moteur sous-jacent, tout en tirant parti des fonctionnalités spécifiques à l'hibernate en cas de besoin (par exemple, filtres, types personnalisés, cache de second niveau).

Prise à retenir:

• Utilisez des annotations JPA et des API pour la portabilité.
• Utilisez des extensions Hibernate lorsque vous avez besoin de performances ou de fonctionnalités avancées.

Cycle de vie de l'entité et contexte de persistance

L'un des concepts les plus importants de la JPA est le contexte de persistance , géré par l' EntityManager . Il agit comme un cache de premier niveau et suit les transitions de l'état d'entité.

Une entité peut être dans l'un des quatre états:

• Nouveau (transitoire) : non associé à un contexte de persistance. Aucune représentation de base de données.
• Géré (persistant) : attaché à un contexte de persistance. Tous les modifications sont suivies et synchronisées avec la DB.
• Détaché : précédemment géré, mais maintenant en dehors du contexte de persistance (par exemple, après la fermeture de la session).
• Supprimé : marqué pour la suppression; sera supprimé lors de la validation des transactions.

Exemple:

 EntityTransaction tx = em.getTransaction ();
tx.begin ();

Utilisateur utilisateur = nouvel utilisateur ("John"); // transitoire
EM.PERSIST (utilisateur); // maintenant géré

user.setName ("John_Doe"); // modifie automatiquement le suivi

tx.Commit (); // Mise à jour exécutée pendant la chasse d'eau

? Le contexte de persistance garantit que dans une transaction, vous obtenez la même instance pour une ligne de base de données donnée (modèle de carte d'identité), empêchant les incohérences.

LAZY VS EAGER LOCKING ET LE PROBLèME N 1

La stratégie de récupération est essentielle pour les performances.

• FetchType.EAGER : La relation est chargée immédiatement.
• FetchType.LAZY : la relation est chargée sur le premier accès.

Problème : l'utilisation LAZY n'empêche pas toujours le problème de la requête N 1 si vous itérez une collection et accédez aux associations paresseuses sans récupération appropriée.

Exemple de n 1:

 List <ost> poters = em.createeQuey ("From Post", post.class) .getResultList ();
pour (Post P: Posts) {
    System.out.println (p.getComments (). Size ()); // déclenche une requête DB à chaque fois!
}

Solutions :

• Utilisez JOIN FETCH dans JPQL:

   à partir du post p

• Utilisez @EntityGraph pour définir des plans de récupération réutilisables.
• Utilisez @BatchSize(size = N) pour réduire les aller-retour.

? Meilleure pratique: par défaut à LAZY pour les collections et récupérer explicitement ce dont vous avez besoin dans chaque cas d'utilisation.

Cache: cache de premier niveau, de deuxième niveau et de requête

Hibernate fournit plusieurs couches de mise en cache:

1. Cache de premier niveau : lié au contexte de persistance (session). Toujours activé.
2. Cache de deuxième niveau : partagé entre les sessions. Facultatif; nécessite une intégration avec des fournisseurs comme ehcache, infinispan ou caféine.
3. Cache de requête : Caches Résultats de requêtes spécifiques (uniquement efficace avec le cache de deuxième niveau activé).

Activer le cache de deuxième niveau:

 @Enablecaching
@Configuration
classe publique hibernateconfig {
    @Haricot
    Public LocalSessionFactoryBean SessionFactory () {
        Propriétés Properties = New Properties ();
        Properties.put ("hibernate.cache.use_second_level_cache", "true");
        Properties.put ("hibernate.cache.region.factory_class", "Caffeine");
        // ...
    }
}

Entités annotées:

 @Entité
@Cacheable
@ org.hibernate.annotations.cache (usage = cacheCurrencystrategy.read_write)
Utilisateur de classe publique {...}

?? Soyez prudent avec la mise en cache des données mutables. L'invalidation du cache peut être délicate dans les environnements en cluster.

Verrouillage optimiste vs pessimiste

Le contr?le de la concurrence est essentiel dans les systèmes multi-utilisateurs.

• Verrouillage optimiste : les conflits supposent que les conflits sont rares. Utilise un champ de version ( @Version ) pour détecter les modifications simultanées.

   @Entité
  Compte de classe publique {
      @Version
      version int privée;
      équilibre privé BigDecimal;
  }

  à la mise à jour, Hibernate Checks:

   Mettre à jour le set de compte Balance =?, Version =? Où id =? Et version =?

  Si aucune ligne n'est mise à jour, un OptimisticLockException est lancé.

• Verrouillage pessimiste : acquiert les verrous de la base de données immédiatement à l'aide d' em.lock(entity, LockModeType.PESSIMISTIC_WRITE) .

? Utilisez le verrouillage optimiste par défaut. Il évolue mieux et évite les verrous de DB à long terme.

Conseils de performance et pièges communs

• évitez d'appeler flush() inutilement : forces l'exécution de SQL, peut nuire aux performances.
• Utilisez des projections DTO lorsque vous n'avez pas besoin d'entités complètes :

   List <userNamedTo> dtos = em.createery (
      "Sélectionnez New Com.example.UserNamedto (U.Name) From User U", UsernameDto.class)
      .getResultList ();

• Ne gardez pas les séances ouvertes trop longtemps : peut entra?ner des fuites de mémoire et des données périmées.
• Initialisez les collections paresseuses avant le rendu de la vue (par exemple, dans une couche de service, pas dans les modèles).
• Utilisez @DynamicUpdate pour générer des instructions de mise à jour avec uniquement des champs modifiés.

---

Conclusion

JPA et Hibernate offrent ensemble une solution robuste pour la persistance de Java, mais ils nécessitent une compréhension minutieuse pour éviter les problèmes de performances et les bogues subtils. Se concentrer sur:

• Stratégies de récupération appropriées
• Gérer le cycle de vie du contexte de persistance
• Tirant la mise en cache sagement
• Gérer la concurrence avec le verrouillage
• écrire des requêtes efficaces et lisibles

Bien utilisé, Hibernate réduit le passe-partout et vous permet de vous concentrer sur la logique métier - sans sacrifier le contr?le ni les performances.

Fondamentalement, il ne s'agit pas seulement de cartographier les objets aux tables; Il s'agit de comprendre comment les données circulent entre votre application et la base de données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!