Optimisation des requêtes de base de données dans une couche de persistance Java

1. Pour résoudre le problème de requête N 1, vous devez utiliser Join Fetch ou @entityGraph; 2. Restreignez la taille de l'ensemble de résultats grâce à la pagination et à la pagination du curseur; 3. Configurer raisonnablement le mappage des entités et le chargement paresseux pour éviter de charger trop de données associées; 4. Utiliser la projection DTO pour interroger uniquement les champs requis; 5. Activer la mise en cache secondaire et configurer raisonnablement les politiques de cache; 6. Activer les journaux SQL et utiliser des outils pour analyser les performances SQL générées; 7. Utiliser le SQL natif pour améliorer l'efficacité grâce à des opérations complexes; 8. Créer des index de base de données pour les conditions de requête communes et utiliser l'analyse du plan d'exécution; Le cœur de l'optimisation est de réduire les aller-retour de la base de données, de réduire la transmission des données et de sélectionner des stratégies d'acquisition appropriées basées sur le scénario, et finalement d'améliorer les performances en continu par le suivi.

Lorsque vous travaillez avec des applications Java qui s'appuient sur une couche de persistance - en particulier celles qui utilisent JPA (Java Persistance API) ou Hibernate - les performances de requête Database peuvent rapidement devenir un goulot d'étranglement. Les requêtes mal optimisées conduisent à des temps de réponse lents, à une utilisation élevée de la mémoire et à des problèmes d'évolutivité. Voici comment optimiser efficacement les requêtes de base de données dans une couche de persistance Java.

1. Évitez le problème de requête N 1

L'un des pièges de performance les plus courants dans JPA est le problème de la requête N 1 , qui se produit lors de la récupération d'une liste d'entités qui ont des associations chargées de paresseux.

Par exemple, le chargement d'une liste des entités Order , puis accéder Customer de chaque commande, un par un déclenche une requête distincte pour chaque client:

 List <ord> orders = EntityManager.CreateEquery ("Sélectionner O From Order O", Order.class)
                                  .getResultList ();

pour (commande d&#39;ordre: ordres) {
    System.out.println (order.getCustomer (). GetName ()); // déclenche une sélection individuelle
}

Solution : Utilisez JOIN FETCH dans votre JPQL pour charger avec impatience les associations dans une seule requête:

 List <ord> orders = EntityManager.Createequery (
    "Sélectionnez O dans l&#39;ordre o Join Fetch O.Customer", Order.class)
    .getResultList ();

Alternativement, utilisez @EntityGraph de HiberNate pour des plans de récupération plus réutilisables:

 @EntityGraph (attributepaths = "client")
@Query ("Sélectionner O dans l'ordre O")
List <ordr> findallWithCustomer ();

2. Utilisez des ensembles de résultats de pagination et limiter

Rechercher de grands ensembles de données sans limites peut épuiser la mémoire et ralentir la base de données.

Paginez toujours les résultats lorsqu'ils traitent de grandes collections:

 Pagable pagable = pageRequest.of (0, 20); // page 0, taille 20
Page <Order> Orders = OrderRepository.Findall (Pagable);

Pensez également à utiliser la pagination de Keyset (basée sur le curseur) pour de meilleures performances sur les grands ensembles de données:

 @Query ("Sélectionner O dans l'ordre o Where O.id>: Ordre du curseur par O.Id ASC")
List <ord> findnextbatch (@param ("curseur") curseur long, pagable pagable);

Cela évite OFFSET généraux décalés dans les grandes tables.

3. Optimiser les mappages d'entités et le chargement paresseux

• Marquez les relations comme fetch = FetchType.LAZY sauf si vous avez toujours besoin des données associées.
• Évitez les relations de vélo à moins que nécessaire.
• Soyez prudent avec les collections @OneToMany : le chargement d'un parent avec des milliers d'enfants peut provoquer des pics de mémoire.

Au lieu de:

 @Onetomany (mappedBy = "Order")
Éléments de liste privée <C.C. // charge tous les éléments à chaque fois

Envisagez d'utiliser une requête dédiée pour récupérer les articles uniquement en cas de besoin, ou utiliser @BatchSize pour réduire les aller-retour:

 @Onetomany (mappedBy = "Order")
@BatchSize (taille = 10)
Éléments de liste privée <C.C.

Cela charge jusqu'à 10 éléments connexes dans une seule requête lorsqu'il est accessible.

4. Utilisez des projections DTO au lieu de pleine entités

Si vous n'avez besoin que d'un sous-ensemble de champs, ne chargez pas l'entité entière. Utilisez des projets DTO pour sélectionner uniquement ce qui est nécessaire:

 @Query ("Sélectionner un nouveau com.example.ordersummary (O.ID, O.Total, O.Customer.Name)"  
       "De l'ordre o où o.status =: statut")
List <randumMary> finseSummariesByStatus (@param ("statut") statut de chaîne);

Cela réduit l'utilisation de la mémoire et les frais généraux du réseau en évitant la récupération des données inutile.

Vous pouvez également utiliser des projets basés sur des interfaces ou une prise en charge native de Spring Data pour les projets.

5. Activer et régler le cache de deuxième niveau

Hibernate prend en charge un cache de deuxième niveau pour stocker des entités ou des collections fréquemment accessibles à travers les sessions.

Activer la mise en cache pour les entités qui changent rarement:

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

Utilisez des fournisseurs de cache comme ehcache ou de la caféine, et soyez prudent avec READ_WRITE ou NONSTRICT_READ_WRITE dans des environnements à haute curances.

Envisagez également de mettre en cache les résultats de la requête:

 query.sethint ("org.hibernate.cacheable", true);

Mais uniquement pour les requêtes avec des résultats stables.

6. Monitor et analyser SQL généré

Activer la journalisation SQL pour voir ce que les requêtes JPA génèrent réellement:

 printemps.jpa.show-sql = true
printemps.jpa.properties.hibernate.format_sql = true
logging.level.org.hibernate.sql = débogage
logging.level.org.hibernate.type.descriptor.sql.basicbinder = trace

Utilisez des outils tels que les statistiques Hibernate , P6Spy ou le profileur de requête de JOOQ pour identifier les requêtes lentes, les appels redondants ou les jointures inefficaces.

7. Utilisez des requêtes natives pour des opérations complexes

Parfois, JPQL ne suffit pas pour les requêtes critiques. Pour des rapports ou des analyses complexes, utilisez SQL natif:

 @Query (valeur = "Select O.id, O.Total, C.Name dans les commandes o Rejoignez les clients C sur O.Customer_ID = C.ID WHERE O.DATE>? 1",
       nativeQuery = true)
Liste <objet []> findOrderReports (Date locale);

Ou mappez les requêtes natives vers les DTO à l'aide @SqlResultSetMapping ou des projections de Spring Data.

8. Tirer les index de la base de données et expliquer les plans

Aucune quantité de réglage JPA ne peut corriger les index de base de données manquants.

• Index des clés étrangères utilisées dans les jointures.
• Colonnes d'index utilisées dans les certificats WHERE , ORDER BY et JOIN .
• Utilisez EXPLAIN ou EXPLAIN ANALYZE pour comprendre les plans d'exécution de la requête.

Exemple:

 Créer un index idx_orders_customer sur les commandes (client_id);
Créer un index idx_orders_date_status sur les ordres (ordonnance_date, statut);

Réflexions finales

L'optimisation des requêtes de base de données dans une couche de persistance Java ne consiste pas seulement à rédiger un meilleur JPQL - il s'agit de comprendre comment JPA traduit votre code en SQL, de gérer judicieusement les associations et de tirer parti des capacités de base de données. Concentrez-vous sur la réduction des aller-retour, en minimisant le transfert de données et en utilisant la bonne stratégie de récupération pour chaque cas d'utilisation.

Fondamentalement: chercher moins, cache intelligent et mesurer toujours.

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!