Le c?ur de la ma?trise des données de printemps avancées JPA est de sélectionner la méthode d'accès aux données appropriée en fonction du scénario et d'assurer les performances et la maintenabilité. 1. Dans la requête personnalisée, @Query prend en charge JPQL et Native SQL, qui convient aux opérations d'association et d'agrégation complexes. Il est recommandé d'utiliser un DTO ou une projection d'interface pour effectuer une cartographie de type type pour éviter les problèmes de maintenance causés à l'aide de l'objet []. 2. L'opération de pagination doit être implémentée en combinaison avec Pagable, mais méfiez-vous des problèmes de requête. Vous pouvez précharger les données associées par le jointure de jointure ou d'utiliser la projection pour réduire le chargement des entités, améliorant ainsi les performances. 3. Pour les requêtes dynamiques multi-conditions, JPaspecificationExECUTOR doit être utilisée pour combiner la spécification pour créer une logique de requête réutilisable et composable pour améliorer la lisibilité et la flexibilité du code. 4. La fonction d'audit remplit automatiquement l'heure et l'opérateur via des annotations telles que @CreatedDate, @LastModifiedBy, etc., et doit être activée avec @entityListeners et @enablejpaauditing, et fournit des informations utilisateur actuelles via AuditorWare. 5. Le référentiel personnalisé nécessite la classe d'implémentation de l'interface et du suffixe IMP. Les données de printemps seront automatiquement assemblées, ce qui convient à l'encapsulation de la logique complexe telle que les appels de procédure stockés. 6. Dans la gestion des transactions, @Transactional peut configurer Readonly pour améliorer les performances de la requête. Pendant les opérations par lots, le manager entièrement et clair doit être rincé manuellement et claire entityManager pour contr?ler la taille du cache et éviter le débordement de la mémoire. En résumé, la couche DAO véritablement au niveau de la production doit utiliser de manière approfondie ces technologies pour équilibrer l'efficacité, la sécurité et la maintenabilité, et finalement obtenir un accès efficace et stable.

Si vous avez utilisé Spring Data JPA pour effectuer des opérations CRUD de base et que vous souhaitez maintenant améliorer l'efficacité et la maintenabilité de la couche d'accès aux données, "Advanced Spring Data JPA" est ce que vous devez ma?triser en profondeur. Il ne s'agit pas seulement d'écrire JpaRepository<t id></t> , mais aussi de faire fonctionner la base de données efficace, flexiblement et en toute sécurité dans des scénarios d'entreprise complexes.

Ce qui suit est quelques instructions clés pour vous emmener dans une utilisation avancée.

1. Requête personnalisée: non seulement @Query, mais aussi besoin de comprendre le SQL natif et l'épissage dynamique

Spring Data JPA fournit une variété de fa?ons d'exécuter des requêtes. En plus de la résolution du nom de la méthode (comme findByStatusAndCreateTimeAfter ), les développeurs avancés devraient le ma?triser:

• Utilisation avancée des annotations @Query
  Prend en charge JPQL et natif SQL. Le SQL natif est plus flexible lorsqu'il est nécessaire d'associer plusieurs tables, fonctions agrégées ou fonctions spécifiques à la base de données.

   @Query (valeur = "" "
      Sélectionnez U.ID, U.Name, Count (O.ID) comme OrderCount
      Des utilisateurs u
      Gauche de jointure des ordres o sur u.id = o.user_id
      Où u.status =: statut
      Groupe par U.ID, Name
      "" ", nativeQuery = true)
  List <object []> findUserWithOrderCount (@param ("status") statut de cha?ne);

  Remarque: Lors du retour de List<Object[]> , l'ordre de champ doit être mappé manuellement. Il est recommandé de le résumer dans un DTO.

  

• Simplifiez la cartographie des résultats à l'aide de la projection
  Définit une interface ou une classe pour recevoir des champs partiels pour éviter de charger des entités complètes.

   Interface publique Usershummary {
      Long getID ();
      String getName ();
      Integer GetOrderCount ();
  }

  Puis utilisez dans @Query :

   @Query ("Sélectionnez U.ID As ID, U.Name comme nom, Count (O) comme OrderCount"  
         "De l'utilisateur u laissé rejoindre u.orders o"  
         "Où U.status =: statut"  
         "Groupe par U.ID")
  List <utilisateurAmmary> findUserSersummaryByStatus (@param ("statut") statut de cha?ne);

2. Pagination et optimisation des performances: éviter les problèmes de requête n 1

La pagination peut sembler simple, mais elle peut facilement provoquer des problèmes de performance en réalité, en particulier lorsque les requêtes associées.

• Utilisez Pagable pour paginer correctement
  Avec la signature de la méthode plus le paramètre Pageable , Spring traitera automatiquement la logique de pagination.

   Page <User> findByROLE (r?le de cha?ne, pagable pagable);

  Lorsqu'on appelle:

   Pageable Page = PageRequest.of (0, 10, Sort.By ("CreateEtime"). Descending ());
  Page <Serser> users = userRepository.FindByrole ("admin", page);

• Méfiez-vous de N 1 Query
  Lorsqu'une entité contient une association @OneToMany , le retour directement à Page<User> peut amener chaque utilisateur à déclencher une requête d'association.

  Solution:

  • Preload Données associées dans la requête principale à l'aide JOIN FETCH :

     @Query ("Sélectionnez U depuis l'utilisateur u gauche jointer fetch u.orders où u.role =: r?le")
    Page <User> FindUsersWithordersByrole (@param ("r?le") R?le de cha?ne, Pagable Pagable);

  • Ou utilisez la projection DTO pour éviter de charger l'entité entière.

3. Spécification: une solution élégante pour la requête dynamique

Lorsque les conditions de requête sont complexes et facultatives (telles que les recherches de gestion de fond), @Query à code dur peut devenir difficile à maintenir. Specification JpaSpecificationExecutor est un outil puissant pour construire des requêtes dynamiques.

 Interface publique UserRepository étend JParePository <utilisateur, long>, jpaspecificationExecutor <serser> {
}

Puis construire des conditions dynamiques:

 Spécification statique publique <User> Hasnamelike (nom de cha?ne) {
    return (root, requête, cb) -> 
        name == null? null: cb.like (root.get ("name"), "%" name "%");
}

Spécification statique publique <User> Hasstatus (statut de cha?ne) {
    return (root, requête, cb) -> 
        statut == null? null: cb.equal (root.get ("statut"), statut);
}

Utilisation de la combinaison:

 Spécification <User> Spec = Spécification.Where (Hasnamelike (nom))
                                       .et (Hasstatus (statut));
Page <User> result = userRepository.Findall (spec, pagable);

Cette méthode est lisible et facile à réutiliser et à tester.

4. Audit et remplissage automatique: @createdDate, @lastmodifiedBy, etc.

Spring Data JPA prend en charge l'enregistrement automatique du temps de création / modification avec les utilisateurs, réduisant le code de la bail.

• Activer l'audit sur l'entité:

   @Entité
  @EntityListeners (AuditEntityListener.class)
  classe publique User {
      @Createddate
      Private LocalDatetime CreateTime;
  
      @LastModifiedBy
      String privé LastModifiedBy;
  }

• La classe de configuration permet l'audit:

   @Configuration
  @Enablejpaaudit
  classe publique jpaconfig {
      @Haricot
      public AuditorWare <string> AuditorProvider () {
          return () -> Facultatif.of (SecurityContexTholder.getContext ()
                                                       .GetAuthentication ()
                                                       .getName ());
      }
  }

Convient pour l'enregistrement des traces de fonctionnement, des audits de journal et d'autres scénarios.

5. Implémentation du référentiel personnalisé: complétez les capacités d'interface

Spring Data JPA permet d'ajouter des méthodes personnalisées à un référentiel.

Règles de dénomination structurelles: Interface CustomUserRepository → Classe de mise en ?uvre CustomUserRepositoryImpl .

 Interface publique CustomUserRepository {
    vide rafra?chisseursfromlegacysystem ();
}

classe publique CustomUserRepositoryIMP implémente CustomUserRepository {
    @Persistencecontext
    entité privée entitéManager entité;

    @Outrepasser
    Rafra?chissement public du vide de la vie du public () {) {
        // Personnalisez la logique complexe, comme les appels de procédures stockées, les mises à jour par lots, etc. StoredProcedUrequery Query = EntityManager
            .CreateStoredProceDurequery ("Refresh_users_From_Legacy");
        query.execute ();
    }
}

Laissez le référentiel principal l'hériter:

 Interface publique UserRepository étend JParePository <utilisateur, long>, personnaliséSerRepository {
}

6. Gestion des transactions et contr?le du mode Flush

Par défaut, @Transactional de Spring est REQUIRED , mais certains scénarios nécessitent un contr?le plus granulaire.

• Contr?le manuel de la chasse (pour le traitement par lots):

   @Transactional
  public void batchInserTusers (list <ser utilisateur> utilisateurs) {
      for (int i = 0; i <users.size (); i) {
          userRepository.save (users.get (i));
          if (i% 50 == 0) {
              EntityManager.Flush ();
              EntityManager.Clear (); // évitez le cache de niveau 1 excessif}
      }
  }

• Définition des transactions en lecture seule pour améliorer les performances:

   @Transactional (readonly = true)
  PAGE PUBLIQUE <DERSER> Searchusers (mot-clé String, Pagable Pagable) {
      // Fonctionnement de la requête, la base de données peut optimiser le plan d&#39;exécution}

Fondamentalement, c'est tout. Le c?ur des données de ressort avancées JPA ne "sait pas utiliser les interfaces", mais:
Choisissez la bonne voie dans le bon scénario - utilise-t-il le nom de la méthode? @Requête? Spécification? Ou une implémentation personnalisée?
Dans le même temps, concentrez-vous sur les performances, la maintenabilité et l'efficacité d'interaction de la base de données.

Ce n'est qu'en ma?trisant ceux-ci que la couche DAO que vous écrivez vraiment être "au niveau de la production".

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!