Tutoriel sur l'utilisation efficace des dérivés du plugin Drupal 8

Les plats clés

• Les dérivés du plugin dans Drupal 8 permettent la déclaration dynamique de plusieurs instances du même plugin, transformant les fonctionnalités configurées par l'utilisateur en plugins.
• Les classes de dérive sont utilisées pour fournir une liste des définitions de plugins basées sur le plugin initial mais qui ont des données de configuration ou de définition légèrement différentes.
• Le dérivation encoverydecorator dans le gestionnaire de plugin est utilisé pour récupérer les dérivés, à la recherche d'une classe de dérive sur chaque plugin et à lui demander la liste.
• Bien que les dérivés du plugin soient un outil puissant, ils peuvent être complexes à configurer et à gérer, en particulier pour les développeurs nouveaux sur Drupal ou inconnues avec son système de plugin. Une gestion et des tests minutieux sont nécessaires car les modifications du plugin de base peuvent avoir un impact sur toutes ses dérivés.

Dans un tutoriel précédent, nous avons examiné le système de plugin Drupal 8 et comment créer notre propre type de plugin personnalisé. Nous avons vu qu'une grande partie de la fonctionnalité déclarée via des crochets _info dans Drupal 7 a été remplacé par ces plugins. Notre cas d'utilisation était très basique et il a permis à chaque instance de ces fonctionnalités d'être déclarées manuellement via une nouvelle classe de plugin et une forme associée.

Mais que se passe-t-il si nous avions besoin de tels instances déclarés dynamiquement en fonction de certains facteurs externes à notre petit sous-système? Par exemple, lors de la déclaration des crochets _info dans Drupal 7, nous pouvons obtenir une liste de quelque chose , boucle dessus et déclarer un nouvel élément dans le tableau retourné pour chaque individu quelque chose . Le système de menu le fait afin de fournir un nouveau bloc pour chaque menu qui est livré avec Drupal Core ou est créé plus tard via l'interface utilisateur.

Alors qu'en est-il de Drupal 8? Nous avons vu que pour chaque plugin d'un certain type, nous devons déclarer une classe PHP différente. Pour créer un nouveau bloc, nous avons besoin d'une nouvelle classe. Pour créer un autre bloc, nous avons besoin d'une autre classe. Alors, où cette Looping nous voyons-nous dans Drupal 7 se déroulerait? La réponse courte à cela est: dans un dérivé du plugin .

Dans cet article, nous allons explorer la longue réponse à cela et apprendre ce que sont les dérivés et comment nous pouvons les utiliser. Pour ces derniers, nous créerons un exemple à l'intérieur du module de démonstration qui peut être trouvé dans ce référentiel GIT et qui, espérons-le, nous aidera à mieux comprendre ce qui se passe. Pour un exemple légèrement plus complexe, le système de menu est excellent car il fournit un bloc individuel pour chacun de ses menus (similaire à Drupal 7 mais en utilisant des plugins).

Ce que nous allons faire est en fait très simple. Nous allons implémenter la fonctionnalité de bloc de nœuds de base par lequel pour tous les nœuds d'article sur notre site, nous aurons un bloc. Ridicule? Bien sûr. Devrions-nous faire cela pour tous les nœuds de notre site? Certainement pas! Mais c'est une implémentation très basique destinée à garder les choses courtes et à démontrer l'utilisation des dérivés du plugin.

Dérivés du plugin

Les dérivés du plugin sont le moyen par lequel un plugin d'un certain type peut être représenté dans le système comme plusieurs instances de lui-même. En d'autres termes, un plugin peut faire référence à une classe de dérive qui est responsable de la fourniture d'une liste des définitions de plugins basée sur le plugin initial (démarrer à partir de la même définition de base) mais qui ont des données de configuration ou de définition légèrement différentes. Le SystemMenuBlock que nous avons mentionné ci-dessus est un excellent exemple. Il s'agit d'un seul plugin qui a autant de dérivés qu'il y a de menus sur le site.

Pour aller un peu plus loin, lorsqu'une liste de tous les plugins d'un certain type est demandée, le gestionnaire de plugin utilise son mécanisme de découverte pour charger tous les plugins de ce type. Si ce mécanisme est décoré avec le décorateur dérivé de la covergure, le gestionnaire pourra également récupérer des dérivés. Pour ce faire, la découverte dérivée recherche une classe de dérive sur chaque plugin et, s'il en trouve un, lui demande cette liste.

Les gestionnaires de type de plugin qui étendent la classe de base de DefaultPluginManager devraient normalement avoir le mécanisme de découverte dérivé décorant la découverte par défaut (annotations). Il s'agit du modèle le plus courant dans le système de plugin Drupal Core: découverte annotée enveloppée de dérivés.

La classe dérivée

Maintenant que nous savons quel est le rôle des dérivés du plugin, créons notre première classe de dérive qui sera utilisée par notre plugin de bloc (que nous créerons en une minute).

À l'intérieur de Src / Plugin / Derivative / nodeBlock.php du module de démonstration, nous avons les suivants:

<?php

/**
 * @file
 * Contains \Drupal\demo\Plugin\Derivative\NodeBlock.
 */

namespace Drupal\demo\Plugin\Derivative;

use Drupal\Component\Plugin\Derivative\DeriverBase;
use Drupal\Core\Entity\EntityStorageInterface;
use Drupal\Core\Plugin\Discovery\ContainerDeriverInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;

/**
 * Provides block plugin definitions for nodes.
 *
 * @see \Drupal\demo\Plugin\Block\NodeBlock
 */
class NodeBlock extends DeriverBase implements ContainerDeriverInterface {

  /**
   * The node storage.
   *
   * @var \Drupal\Core\Entity\EntityStorageInterface
   */
  protected $nodeStorage;

  /**
   * Constructs new NodeBlock.
   *
   * @param \Drupal\Core\Entity\EntityStorageInterface $node_storage
   *   The node storage.
   */
  public function __construct(EntityStorageInterface $node_storage) {
    $this->nodeStorage = $node_storage;
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, $base_plugin_id) {
    return new static(
      $container->get('entity.manager')->getStorage('node')
    );
  }

  /**
   * {@inheritdoc}
   */
  public function getDerivativeDefinitions($base_plugin_definition) {
    $nodes = $this->nodeStorage->loadByProperties(['type' => 'article']);
    foreach ($nodes as $node) {
      $this->derivatives[$node->id()] = $base_plugin_definition;
      $this->derivatives[$node->id()]['admin_label'] = t('Node block: ') . $node->label();
    }
    return $this->derivatives;
  }
}

Tout ce que notre classe doit implémenter est le DeriveRinterface et implémenter ses deux méthodes. Nous utilisons à la place le contenerderiverInterface car nous voulons faire connaître notre conteneur dérivé. Pourquoi? Parce que nous utilisons l'injection de dépendance pour charger le gestionnaire d'entités de Drupal afin que nous puissions accéder au stockage du nœud (c'est ce que font le constructeur et la méthode create ()). De plus, notre classe de dérive s'étend de la classe DeriverBase car cela prend déjà en charge l'une des méthodes requises (gotderivativedEfinition ()).

Enfin, GetderivativedEFinitions () est la méthode responsable de la fourniture d'un tableau de définitions de plugins qui dérivent du plugin qui utilise cette classe. Il reçoit le $ base_plugin_definition comme un argument (la définition du plugin réel qui utilise ce dérivé) et nous l'utilisons pour construire nos définitions dérivées. Dans notre cas, nous chargeons sans discernement tous les nœuds de l'article et, pour chacun d'eux, créons une définition distincte qui ne diffère qu'en ayant un ADMIN_LABEL différent (il s'agit d'une propriété sur la classe d'annotation DrupalcoreBlockannotationBlock). Le tableau des dérivés est clés par l'ID du dérivé (dans notre cas, l'ID de nœud que nous utiliserons plus tard).

Un point très important que nous devons souligner ici est que le chargement de tous les nœuds et la création de plugins sont jamais une bonne idée. Ce qui serait peut-être intéressant, c'est d'implémenter les fonctionnalités par lesquelles les nœuds individuels peuvent être exposés en blocs via une case à cocher ou quelque chose comme ça.

le plugin de bloc

Maintenant que nous avons notre classe de dérive, créons un plugin de bloc simple qui l'utilise pour générer plusieurs instances de lui-même (une pour chaque nœud d'article).

à l'intérieur src / plugin / block / nodeblock.php:

<?php

/**
 * @file
 * Contains \Drupal\demo\Plugin\Derivative\NodeBlock.
 */

namespace Drupal\demo\Plugin\Derivative;

use Drupal\Component\Plugin\Derivative\DeriverBase;
use Drupal\Core\Entity\EntityStorageInterface;
use Drupal\Core\Plugin\Discovery\ContainerDeriverInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;

/**
 * Provides block plugin definitions for nodes.
 *
 * @see \Drupal\demo\Plugin\Block\NodeBlock
 */
class NodeBlock extends DeriverBase implements ContainerDeriverInterface {

  /**
   * The node storage.
   *
   * @var \Drupal\Core\Entity\EntityStorageInterface
   */
  protected $nodeStorage;

  /**
   * Constructs new NodeBlock.
   *
   * @param \Drupal\Core\Entity\EntityStorageInterface $node_storage
   *   The node storage.
   */
  public function __construct(EntityStorageInterface $node_storage) {
    $this->nodeStorage = $node_storage;
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, $base_plugin_id) {
    return new static(
      $container->get('entity.manager')->getStorage('node')
    );
  }

  /**
   * {@inheritdoc}
   */
  public function getDerivativeDefinitions($base_plugin_definition) {
    $nodes = $this->nodeStorage->loadByProperties(['type' => 'article']);
    foreach ($nodes as $node) {
      $this->derivatives[$node->id()] = $base_plugin_definition;
      $this->derivatives[$node->id()]['admin_label'] = t('Node block: ') . $node->label();
    }
    return $this->derivatives;
  }
}

La première chose que nous remarquons dans l'annotation de ce plugin est la clé de dérive qui pointe vers la classe que nous avons créée auparavant. Et c'est essentiellement tout ce dont nous avons besoin pour associer les deux. Le décorateur de découverte dérivé gère le levage lourd.

Une grande partie du reste est un bâtiment de bloc de base que nous devrions connaître. Ce qui est intéressant, c'est que nous pouvons utiliser la méthode gotderivativeId () pour récupérer l'ID de nœud que nous avons également utilisé comme l'ID de la dérivée affichée et, en utilisant cela, nous chargeons l'objet de nœud et construisons le bloc comme sortie du nœud réel. Enfin, à l'intérieur de la méthode BlockAccess (), nous nous assurons que ce bloc a les mêmes vérifications d'accès que le nœud réel lui-même. Donc, si l'utilisateur actuel n'a pas accès pour afficher le nœud actuel, le bloc n'apparaîtra même pas.

Maintenant, si nous effacons les caches et naviguons vers l'interface de mise en page de bloc, nous devrions voir certains blocs appelés Node Block: [Titre du nœud]. Vous pouvez les placer où vous voulez et ils rendront le nœud pertinent.

Conclusion

Dans cet article, nous avons examiné les dérivés du plugin et vu un exemple simple de leur fonctionnement. La clé à emporter sur ce sujet est que les dérivés du plugin sont la façon dont nous déclarons dynamiquement plusieurs instances du même plugin. Ils nous aident généralement à transformer les fonctionnalités configurées par l'utilisateur (par exemple les menus) en plugins (par exemple les blocs de menu).

Pour illustrer l'utilisation des dérivés, nous avons vu une technique très simple qui nous permet de rendre les nœuds d'article comme blocs. Nous devons nous rappeler, mais de ne pas essayer ceci sur un site Web avec de nombreux nœuds d'article, mais plutôt implémenter des fonctionnalités supplémentaires qui limitent le nombre de nœuds qui sont exposés. Vous savez, donc nous ne glissons pas notre site.

Questions? Commentaires? Quelque chose que vous aimeriez expliquer davantage? Faites-nous savoir!

Questions fréquemment posées (FAQ) sur l'utilisation efficace des dérivés du plugin Drupal 8

Que sont les dérivés du plugin Drupal 8 et pourquoi sont-ils importants?

Les dérivés du plugin Drupal 8 sont une caractéristique puissante de Drupal 8 qui permettent aux développeurs de générer dynamiquement plusieurs instances d'un seul plugin. Ceci est particulièrement utile lorsque vous avez un grand nombre de tâches similaires à effectuer, mais chaque tâche nécessite une configuration légèrement différente. En utilisant des dérivés de plugin, vous pouvez créer un plugin de base unique, puis générer autant de variations de ce plugin que vous avez besoin, chacune avec sa propre configuration unique. Cela peut considérablement simplifier votre code et rendre votre site Drupal 8 plus efficace et plus facile à gérer.

Comment créer un dérivé du plugin Drupal 8?

La création d'un dérivé du plugin Drupal 8 implique plusieurs étapes . Tout d'abord, vous devez créer un plugin de base qui définit les fonctionnalités de base que tous les dérivés partageront. Ensuite, vous devez créer une classe dérivée de plugin qui étend le plugin de base et implémente le dérivé Interface. Cette classe est responsable de la génération des dérivés individuels. Enfin, vous devez enregistrer votre dérivé de plugin auprès du Plugin Manager de Drupal afin qu'il puisse être découvert et utilisé.

Puis-je utiliser les dérivés de plugin Drupal 8 avec des modules personnalisés?

Oui, le plugin Drupal 8 Les dérivés peuvent être utilisés avec des modules personnalisés. En fait, ils sont particulièrement utiles dans ce contexte, car ils vous permettent de créer un module de base unique, puis de générer plusieurs variations de ce module, chacune avec sa propre configuration unique. Cela peut simplifier considérablement le processus de développement et rendre vos modules personnalisés plus efficaces et plus faciles à gérer.

Quels sont les cas d'utilisation courants pour les dérivés du plugin Drupal 8?

Les dérivés de plugin Drupal 8 sont incroyablement polyvalents polyvalents et peut être utilisé dans un large éventail de scénarios. Certains cas d'utilisation courants incluent la création de plusieurs instances d'un plugin de bloc, chacune avec une configuration différente; générer plusieurs liens de menu à partir d'un plugin de base unique; et la création de plusieurs variations d'un module personnalisé, chacune adaptée à une tâche ou à une exigence spécifique.

Comment gérer et maintenir les dérivés de plugin Drupal 8?

Gérer et maintenir les dérivés du plugin Drupal 8 implique de garder Piste du plugin de base et de toutes ses dérivés, garantissant qu'ils sont tous à jour et fonctionnent correctement. Cela peut être fait via le Plugin Manager de Drupal, qui fournit une interface centralisée pour gérer tous vos plugins. De plus, il est important d'examiner et de mettre à jour régulièrement vos dérivés de plugin pour s'assurer qu'ils continuent de répondre à vos besoins et les besoins des utilisateurs de votre site.

y a-t-il des limitations ou des défis avec l'utilisation des dérivés du plugin Drupal 8?

Bien que les dérivés du plugin Drupal 8 soient un outil puissant, ils viennent avec des défis. L'un des principaux défis est qu'ils peuvent être complexes à installer et à gérer, en particulier pour les développeurs qui sont nouveaux dans Drupal ou qui ne connaissent pas son système de plugin. De plus, comme chaque dérivé est une variation d'un seul plugin de base, les modifications du plugin de base peuvent potentiellement avoir un impact sur toutes ses dérivés, donc une gestion et des tests minutieux sont nécessaires.

Puis-je utiliser les dérivés du plugin Drupal 8 avec troisième- Plugins de fête?

Oui, les dérivés de plugin Drupal 8 peuvent être utilisés avec des plugins tiers. Cependant, il est important de noter que tous les plugins tiers ne sont pas conçus pour prendre en charge les dérivés, vous devrez donc peut-être faire des travaux supplémentaires pour les rendre compatibles. Vérifiez toujours la documentation du plugin spécifique que vous utilisez pour voir s'il prend en charge les dérivés et comment les implémenter.

Comment les dérivés du plugin Drupal 8 améliorent-ils les performances du site?

DRUPAL 8 Les dérivés du plugin Drupal 8 Peut améliorer les performances du site en réduisant la quantité de code qui doit être exécutée pour chaque tâche. En créant un plugin de base unique puis en générant plusieurs dérivés, vous pouvez éviter d'avoir à écrire et à exécuter un code séparé pour chaque tâche. Cela peut entraîner une augmentation significative des performances, en particulier pour les sites avec un grand nombre de tâches similaires.

Comment déboguer les problèmes avec les dérivés du plugin Drupal 8?

Problèmes de débogage avec les dérivés du plugin Drupal 8 Drupal 8 peut être difficile en raison de leur nature dynamique. Cependant, Drupal fournit plusieurs outils et techniques pour y aider. L'un des plus utiles est le module de développement, qui fournit une gamme d'outils de débogage et de développement. De plus, les fonctionnalités de journalisation et de rapport d'erreur de Drupal peuvent fournir des informations précieuses sur tous les problèmes qui se posent.

où puis-je trouver plus de ressources sur l'utilisation efficace des dérivés du plugin Drupal 8?

Il existe de nombreuses ressources disponibles en ligne en ligne Pour en savoir plus sur les dérivés du plugin Drupal 8. La documentation officielle de Drupal est un excellent point de départ, car elle fournit des informations complètes sur tous les aspects du développement de Drupal, y compris les dérivés du plugin. De plus, il existe de nombreux tutoriels, articles de blog et discussions de forum qui couvrent ce sujet en profondeur.

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!