Types de plugins personnalisés de Drupal 8

Le système de plugin robuste de Drupal 8 permet aux développeurs backend avec des fonctionnalités réutilisables. Cet article (partie la première des deux) détaille la création d'une fonction permettant des formulaires personnalisés avec des entités de nœud, permettant à la configuration des faisceaux de nœuds d'utiliser divers types de formulaires aux côtés des affichages de nœuds. Les nouveaux types de formulaires sont facilement définis en étendant une classe de base fournie. (Pour un exemple de code complet, reportez-vous à ce référentiel ).

Ce tutoriel évite les mécanismes de plugin approfondis, en supposant une familiarité avec la théorie sous-jacente. Nous allons construire notre type de plugin personnalisé à l'aide de deux interfaces et de six classes - un nombre apparemment grand, mais surtout un code de chauffeur. La deuxième partie démontrera l'attachement ces formes réutilisables aux nœuds.

Concepts clés:

• Le système de plugin de Drupal 8 facilite les fonctionnalités réutilisables, permettant des formulaires personnalisés pour les entités de nœud. Les bundles de nœud peuvent être configurés pour utiliser plusieurs types de formulaires dans les affichages de nœud.
• Le gestionnaire de plugin, essentiel pour la découverte et le chargement du plugin, exploite la classe de base par défaut de Drupal pour une extension facile. Tous les plugins doivent implémenter une interface définie.
• Les définitions des plugins utilisent des annotations contenant des informations cruciales: le sous-répertoire du plugin, l'interface requise et la classe d'annotation définissant les propriétés du plugin.
• Un type de plugin personnalisé nécessite une classe de base extensible par tous les plugins. Cette classe met en œuvre l'interface et utilise l'injection de dépendance pour le service form_builder, essentiel pour la construction de formulaires. Le plugin interagit avec les classes de formulaire; L'étape suivante consiste à intégrer ces formulaires avec des affichages de nœuds.

Gestionnaire de plugin:

Le gestionnaire de plugin, crucial pour découvrir et charger les plugins, étend Drupal's DefaultPluginManager. Dans le répertoire /src du module, ReusableFormManager.php contient:

<code class="language-php"><?php namespace Drupal\reusable_forms;

use Drupal\Core\Plugin\DefaultPluginManager;
use Drupal\Core\Cache\CacheBackendInterface;
use Drupal\Core\Extension\ModuleHandlerInterface;

class ReusableFormsManager extends DefaultPluginManager {

  public function __construct(\Traversable $namespaces, CacheBackendInterface $cache_backend, ModuleHandlerInterface $module_handler) {
    parent::__construct('Plugin/ReusableForm', $namespaces, $module_handler, 'Drupal\reusable_forms\ReusableFormPluginInterface', 'Drupal\reusable_forms\Annotation\ReusableForm');
    $this->alterInfo('reusable_forms_info');
    $this->setCacheBackend($cache_backend, 'reusable_forms');
  }
}</code>

Cela étend DefaultPluginManager, en remplaçant le constructeur. Paramètres clés Définissez:

• Plugin/ReusableForm: sous-répertoire du plugin.
• Drupalreusable_formsReusableFormPluginInterface: interface de plugin requise.
• Drupalreusable_formsAnnotationReusableForm: classe d'annotation définissant les propriétés du plugin.

Un alter hook (reusable_forms_info) permet aux modules de modifier les définitions du plugin, et le backend de cache est configuré.

Interface du plugin:

L'interface (ReusableFormPluginInterface.php dans /src) définit les méthodes que tous les plugins doivent implémenter:

<code class="language-php"><?php namespace Drupal\reusable_forms;

use Drupal\Core\Plugin\DefaultPluginManager;
use Drupal\Core\Cache\CacheBackendInterface;
use Drupal\Core\Extension\ModuleHandlerInterface;

class ReusableFormsManager extends DefaultPluginManager {

  public function __construct(\Traversable $namespaces, CacheBackendInterface $cache_backend, ModuleHandlerInterface $module_handler) {
    parent::__construct('Plugin/ReusableForm', $namespaces, $module_handler, 'Drupal\reusable_forms\ReusableFormPluginInterface', 'Drupal\reusable_forms\Annotation\ReusableForm');
    $this->alterInfo('reusable_forms_info');
    $this->setCacheBackend($cache_backend, 'reusable_forms');
  }
}</code>

getName() Renvoie le nom du plugin; buildForm() accepte une entité et renvoie un tableau de rendu pour un formulaire implémentant Drupalreusable_formsFormReusableFormInterface. Il étend PluginInspectionInterface et ContainerFactoryPluginInterface pour plus de fonctionnalités et d'injection de dépendance.

Annotation du plugin:

La classe d'annotation (ReusableForm.php dans /src/Annotation) définit les propriétés du plugin:

<code class="language-php"><?php
namespace Drupal\reusable_forms;

use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
use Drupal\Component\Plugin\PluginInspectionInterface;

interface ReusableFormPluginInterface extends PluginInspectionInterface, ContainerFactoryPluginInterface {

  public function getName();

  public function buildForm($entity);
}</code>

id, name, et form (le nom de classe de formulaire entièrement qualifié) sont définis ici.

Classe de base du plugin:

La classe de base du plugin (ReusableFormPluginBase.php dans /src) fournit des défauts:

<code class="language-php"><?php
namespace Drupal\reusable_forms\Annotation;

use Drupal\Component\Annotation\Plugin;

/**
 * @Annotation
 */
class ReusableForm extends Plugin {

  public $id;
  public $name;
  public $form;
}</code>

Cela étend PluginBase, implémente ReusableFormPluginInterface et utilise l'injection de dépendance pour form_builder. getName() et buildForm() sont implémentés, en utilisant la classe de formulaire spécifiée dans l'annotation.

Interface de forme et classe de base:

Une interface de formulaire simple (ReusableFormInterface.php dans /src/Form) et la classe de base (ReusableFormBase.php dans /src/Form) sont créées pour la cohérence: (celles-ci sont indiquées dans la réponse originale et ne sont pas répétées ici pour brièveté) .

Conclusion (partie 1):

Cette première partie met en place le type de plugin personnalisé, en le préparant pour l'intégration avec les classes de formulaires. La deuxième partie couvrira l'affichage de ces formulaires avec des nœuds, impliquant la configuration du type de nœud et le rendu de formulaire dans les modes de vue de contenu.

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!