évitez N 1 Problèmes de requête, réduisez le nombre de requêtes de base de données en chargeant à l'avance des données associées; 2. Sélectionnez uniquement les champs requis pour éviter de charger des entités complètes pour enregistrer la mémoire et la bande passante; 3. Utilisez raisonnablement les stratégies de cache, telles que le cache secondaire de la doctrine ou les résultats de requête à haute fréquence de cache de Doctrine; 4. Optimisez le cycle de vie de l'entité et appelez régulièrement () pour libérer la mémoire pour empêcher le débordement de la mémoire; 5. Assurez-vous que l'indice de base de données existe et analysez les instructions SQL générées pour éviter les requêtes inefficaces; 6. Désactiver le suivi automatique des changements dans les scénarios où les modifications ne sont pas nécessaires et utilisez des tableaux ou des modes légers pour améliorer les performances. L'utilisation correcte de l'ORM nécessite de combiner la surveillance SQL, la mise en cache, le traitement par lots et l'optimisation appropriée pour garantir les performances de l'application tout en maintenant l'efficacité du développement.

Des outils de cartographie relationnelle d'objet (ORM) comme la doctrine, l'éloquente (Laravel) et le propage rendent le développement de PHP plus rapide et plus maintenable en vous permettant de travailler avec des bases de données à l'aide du code orienté objet. Mais ils viennent avec un co?t de performance s'ils sont utilisés avec soin. L'utilisation ORM mal réglée peut entra?ner des requêtes lentes, des ballonnements de mémoire et des problèmes d'évolutivité - en particulier sous la charge.

Voici comment garder votre ORM Perforant sans renoncer à ses avantages de productivité.

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

Il s'agit du tueur de performance ORM le plus courant.

Lorsque vous récupérez une liste d'objets et accédez à une entité connexe à l'intérieur d'une boucle, ORMS émet souvent une requête supplémentaire par objet - conduisant à N 1 requêtes.

Exemple (mauvais):

 $ utilisateurs = $ entityManager-> getRepository (user :: class) -> findall ();
foreach ($ utilisateurs comme $ utilisateur) {
    echo $ user-> getProfile () -> getemail (); // une requête supplémentaire par utilisateur
}

Si vous avez 100 utilisateurs, cela se traduit par 101 requêtes.

Correction: utilisez un chargement avide

Chargez des données liées à l'avance à l'aide de jointures.

• Doctrine: Utilisez JOIN FETCH dans DQL ou configurez le mode Fetch dans les associations.

   $ dql = "SELECT U, P à partir de l'utilisateur u jointer fetch u.profile p";
  $ utilisateurs = $ entityManager-> createQuery ($ dql) -> getResult ();

• Eloquent: utilisez with() pour des relations de charge impatientes.

   $ utilisateurs = utilisateur :: avec ('profil') -> get ();
  foreach ($ utilisateurs comme $ utilisateur) {
      echo $ user-> profil-> e-mail;
  }

Surveillez toujours vos journaux ou utilisez des outils tels que Laravel Debugbar ou Doctrine's SQL Logger pour attraper les problèmes n 1 t?t.

2. Sélectionnez uniquement ce dont vous avez besoin

Récupérer des entités entières lorsque vous n'avez besoin que de quelques champs gaspille la mémoire et la bande passante.

Au lieu de:

 $ utilisateurs = $ re-> findall ();
foreach ($ utilisateurs comme $ utilisateur) {
    echo $ user-> getName ();
}

Utilisez des requêtes partielles ou scalaires:

• Doctrine: utilisez DQL pour sélectionner des champs spécifiques.

   $ dql = "Select U.Id, U.Name from User U";
  $ utilisateurs = $ entityManager-> createQuery ($ dql) -> getScalarResult ();

• Eloquent: utilisez select() et pluck() / get() .

   $ names = user :: select ('id', 'name') -> get ();

Pour les opérations en lecture seule, envisagez d'utiliser des requêtes brutes ou des DTO (objets de transfert de données) via SQL personnalisé - vous obtiendrez de bien meilleures performances.

3. Tire de la mise en cache stratégiquement

Les ORM fonctionnent mieux lorsqu'ils sont combinés avec des couches de mise en cache appropriées.

• Cache de deuxième niveau (doctrine): cache entités entières ou collections.

   // en doctrine
  $ query-> userSultCache (true, 3600, 'users_list');

• Cache de requête: stocker les résultats de l'analyse DQL et de la génération SQL.

• Redis / Memcached Eloquent: Cache requêtes fréquemment.

   $ utilisateurs = Cache :: Remember ('Users.active', 3600, function () {
      RETOUR USER :: WHERE ('actif', 1) -> get ();
  });

Soyez prudent avec l'invalidation du cache, mais même les TTL courts sur les points d'extrémité à lecture haute peuvent réduire considérablement la charge de DB.

4. Optimiser le cycle de vie des entités et l'utilisation de la mémoire

Orms Track Object State, qui consomme de la mémoire. Les scripts à long terme (par exemple, les importations, les travaux de lots) peuvent manquer de mémoire.

Problème:

 pour ($ i = 0; $ i <10000; $ i) {
    $ user = new User ();
    $ user-> setName ("user $ i");
    $ entityManager-> persistant ($ utilisateur);
}
$ entityManager-> flush ();

Toutes les 10K entités sont suivies en mémoire.

Correction: utilisez clear() ou detach() périodiquement

 pour ($ i = 0; $ i <10000; $ i) {
    $ user = new User ();
    $ user-> setName ("user $ i");
    $ entityManager-> persistant ($ utilisateur);

    if ($ i% 1000 === 0) {
        $ entityManager-> flush ();
        $ entityManager-> clear (); // mémoire libre
    }
}

Cela maintient l'utilisation de la mémoire constante quelle que soit la taille de l'ensemble de données.

5. Utiliser les index et analyser les requêtes

Même le meilleur code ORM ne peut pas corriger les index de base de données manquants.

• Indexez toujours les touches étrangères et les colonnes fréquemment interrogées.
• Utilisez EXPLAIN sur SQL généré pour repérer les scans de table complet.
• Surveillez les journaux de requête lents.

Exemple: si vous interrogez souvent User WHERE status = ? , assurez-vous que status est indexé.

évitez également les requêtes ORM complexes qui génèrent des SQL inefficaces. Parfois, écrire une requête optimisée à la main est mieux que de forcer l'ORM à le faire.

6. Désactiver le suivi automatique des effectifs lorsqu'il n'est pas nécessaire

Dans les opérations lourdes en lecture, vous n'avez pas besoin de l'ORM pour suivre les modifications.

• Doctrine: utilisez des entités HYDRATE_ARRAY ou de détachement.

   $ utilisateurs = $ entityManager-> CreateQuery ($ dql)
      -> SethydratationMode (Query :: Hydrate_Array)
      -> getResult ();

  Les tableaux sont plus rapides et plus légers que les entités complètes.

  • En éloquent, utilisez toArray() t?t ou utilisez select() avec get() pour éviter les frais généraux du modèle.

  ---

  Réflexions finales

  Les orms sont puissants - mais ils ne sont pas magiques. Le réglage des performances signifie:

  • Savoir quand les intervenir
  • Comprendre ce qu'ils génèrent SQL
  • Utilisation d'outils pour détecter les problèmes (n 1, fuites de mémoire)
  • Appliquer la mise en cache et les lots le cas échéant

  Vous n'avez pas à abandonner Orm pour aller vite. Utilisez-le à bon escient.

  Fondamentalement: récupérer moins, cache plus et vérifier toujours le SQL .

  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!