Points de base
ConfigFormBase et en apportant les modifications nécessaires dans le formulaire. La configuration de Drupal 8 est stockée dans un fichier YAML et peut être modifiée via l'interface utilisateur pour le déploiement sur différents sites. ConfigFormBase
demo.services.yml
ControllerBase. Vous pouvez également utiliser la classe ContainerInjectionInterface pour accéder au service à l'échelle mondiale. Drupal
Notez que certaines pièces de code peuvent être obsolètes car Drupal 8 est en développement au moment de la rédaction. Veuillez consulter ce référentiel, j'ai essayé de mettre à jour l'exemple de code et de le rendre compatible avec la dernière version Drupal 8.
Dans les articles précédents sur le développement du module Drupal 8, nous avons examiné la création de types de blocs et de formulaires. Nous avons vu que les blocs sont désormais réutilisables et que tout ce qui est nécessaire pour définir les types de blocs est effectué dans une classe. De même, les fonctions de génération de formulaires sont également regroupées dans une classe où les tâches effectuées par une méthode particulière sont similaires à celles pour lesquelles nous sommes habitués dans Drupal 7.Dans ce tutoriel, je continuerai d'où nous avons terminé la dernière fois. Je vais expliquer comment convertir notre
en un formulaire utilisé pour stocker les valeurs via le système de configuration Drupal 8. Après cela, nous illustrons les conteneurs de service et l'injection de dépendance avec des exemples. DemoForm
Formulaire de configuration
Lorsque nous avons défini pour la première fois, nous avons étendu la classe DemoForm, qui est l'implémentation la plus simple de FormBase. Cependant, Drupal 8 est également livré avec un FormInterface, qui fournit des fonctionnalités supplémentaires qui facilitent l'interaction avec le système de configuration. ConfigFormBase
en un formulaire qui stocke l'adresse e-mail saisie par l'utilisateur. La première chose que nous devrions faire est de remplacer la classe d'extension par DemoForm (et bien sûr ConfigFormBase it): use
use Drupal\Core\Form\ConfigFormBase;
class DemoForm extends ConfigFormBase {Avant de continuer à changer le reste du formulaire, jetons un coup d'œil à la façon dont les configurations simples dans Drupal 8 fonctionnent. J'ai dit "simple" car il y a des entités de configuration plus complexes, que nous ne présenterons pas aujourd'hui. Pour l'instant, la configuration fournie par le module (core ou contrib) est stockée dans le fichier YAML. Lorsque le module est activé, ces données sont importées dans la base de données (pour améliorer les performances lorsqu'elles sont utilisées). Avec l'interface utilisateur, nous pouvons modifier cette configuration, puis l'exporter facilement vers un fichier YAML pour le déploiement sur différents sites.
Le module peut fournir une configuration par défaut dans le fichier YAML dans le dossier config/install dans le répertoire racine du module. La convention de dénomination de ce fichier est de préfixer le nom du module. Créons donc un fichier appelé demo.settings.yml. Dans ce fichier, collez ce qui suit:
demo: email_address: demo@demo.com
Il s'agit d'une structure imbriquée (comme un tableau associatif en PHP). Sous la touche demo, nous avons une autre paire de valeurs clés. En règle générale, pour accéder à ces valeurs imbriquées, nous utilisons des points (.). Dans notre cas, c'est demo.email_address.
Une fois que nous avons ce fichier, une chose importante dont vous devez vous souvenir est que ce fichier ne sera importé que lorsque le module est installé. Alors, continuez à le réinstaller. Maintenant, nous pouvons revenir à notre formulaire et voir un par un les méthodes qui doivent être ajustées.
C'est à quoi ressemble maintenant buildForm()
public function buildForm(array $form, array &$form_state) {
$form = parent::buildForm($form, $form_state);
$config = $this->config('demo.settings');
$form['email'] = array(
'#type' => 'email',
'#title' => $this->t('Your .com email address.'),
'#default_value' => $config->get('demo.email_address')
);
return $form;
}, la classe FormBase implémente également cette méthode afin d'ajouter des éléments au tableau de formulaire (bouton Soumettre). Donc, avant d'ajouter nos propres éléments, nous pouvons utiliser ce que nous avons fait avant la classe parent. ConfigFormBase
que nous pouvons utiliser pour interagir avec la configuration. Certaines classes l'ont obtenue par injection de dépendance. Config C'est une telle classe. ConfigFormBase
de la classe parent pour récupérer un objet config() qui a été rempli avec notre configuration simple. Ensuite, pour le Config de l'élément de formulaire de messagerie, nous utilisons la méthode demo.settings de l'objet #default_value pour récupérer la valeur de l'adresse e-mail. Config
get() Ensuite, nous devons simplement changer le gestionnaire de validation, car la méthode
validateForm()
public function submitForm(array &$form, array &$form_state) {
$config = $this->config('demo.settings');
$config->set('demo.email_address', $form_state['values']['email']);
$config->save();
return parent::submitForm($form, $form_state);
} pour modifier la valeur de Config en valeur soumise par l'utilisateur. Ensuite, nous utilisons la méthode set() pour enregistrer la configuration. Enfin, nous étendons le gestionnaire de validation des parents car il inclut certaines fonctionnalités (dans ce cas, il définit le message Drupal à l'écran). email_address
c'est tout. Vous pouvez effacer le cache et essayer. En soumettant une nouvelle adresse e-mail, vous la stockez dans la configuration. Le fichier demo.settings.yml ne changera certainement pas, mais vous pouvez exporter la configuration demo.settings et l'importer sur un autre site.
Contatrice de service et injection de dépendance
La prochaine chose que nous voulons examiner est le conteneur de service. La philosophie derrière le service est de décomposer la fonctionnalité en composants réutilisables. Par conséquent, un service est une classe PHP qui effectue certaines opérations mondiales et enregistre dans le conteneur de service pour l'accès.
L'injection de dépendance est la façon dont nous passons des objets pour assurer le découplage. Chaque service doit gérer une chose, et s'il a besoin d'un autre service, ce dernier peut être injecté dans le premier. Mais nous verrons comment le faire tout de suite.
Ensuite, nous créerons un service très simple et l'enregistrerons dans le conteneur. Il n'a qu'un seul moyen de retourner des valeurs simples. Nous injectons ensuite le service en tant que dépendance dans notre DemoController et utilisons la valeur fournie par le service.
Afin d'enregistrer un service, nous devons créer un fichier demo.services.yml situé dans le répertoire racine du module, avec le contenu suivant:
use Drupal\Core\Form\ConfigFormBase;
class DemoForm extends ConfigFormBase { La convention de dénomination des fichiers est module_name.services.yml.
La première ligne crée un éventail de services. La deuxième ligne définit le premier service (appelé demo_service, préfixé par le nom du module). La troisième ligne spécifie la classe qui sera instanciée pour ce service. Vient ensuite pour créer le fichier de classe src/ dans le dossier DemoService.php de notre module. C'est ce que fait mon service (en fait rien, juste pour illustrer comment l'utiliser):
demo: email_address: demo@demo.com
Rien ne doit être expliqué ici, car il est très basique. Ensuite, tournons-nous vers notre DemoController et utilisons ce service. Nous pouvons le faire de deux manières: accéder au conteneur à l'échelle mondiale via la classe Drupal ou transmettre un objet de cette classe à notre contrôleur en utilisant l'injection de dépendance. La meilleure pratique suggère que nous devrions adopter la deuxième approche, c'est donc ce que nous allons faire. Mais parfois, vous avez besoin d'un accès global au service. Pour ce faire, vous pouvez effectuer ce qui suit:
public function buildForm(array $form, array &$form_state) {
$form = parent::buildForm($form, $form_state);
$config = $this->config('demo.settings');
$form['email'] = array(
'#type' => 'email',
'#title' => $this->t('Your .com email address.'),
'#default_value' => $config->get('demo.email_address')
);
return $form;
} maintenant $service est l'objet de la classe DemoService que nous venons de créer. Mais voyons comment injecter notre service comme une dépendance dans la classe DemoController. Je vais expliquer ce qui doit être fait en premier, puis vous verrez un contrôleur complet avec toutes les modifications apportées.
Tout d'abord, nous devons accéder au conteneur de service. Ceci est très facile pour le contrôleur. Nous pouvons étendre la classe ControllerBase, qui nous fournit cela en plus de certains autres programmes d'assistance. Alternativement, notre contrôleur peut implémenter ContainerInjectionInterface, ce qui nous permet également d'accéder au conteneur. Mais nous nous en tiendrons à ControllerBase, nous avons donc besoin de use la classe.
Ensuite, nous avons besoin de use Symfony 2 ContainerInterface comme exigence de la méthode create(), qui instancie un autre objet du contrôleur et transmet le service que nous voulons.
Enfin, nous aurons besoin d'un constructeur pour obtenir les objets de service passés (l'objet retourné de create()) et les attribuer à des propriétés pour une utilisation ultérieure. create() L'ordre dans lequel la méthode renvoie les objets doit refléter l'ordre dans lequel ils sont transmis au constructeur.
Alors, regardons notre DemoController:
use Drupal\Core\Form\ConfigFormBase;
class DemoForm extends ConfigFormBase { Comme vous pouvez le voir, toutes les étapes sont ici. La méthode create() crée une nouvelle instance de notre classe de contrôleur et transmet le service récupéré du conteneur. Enfin, une instance de la classe DemoService est stockée dans la propriété $demoService, que nous pouvons utiliser pour appeler sa méthode getDemoValue(). Cette valeur sera ensuite utilisée dans le message "Hello". Effacez le cache et essayez-le. Allez sur le chemin demo/ et vous devriez voir le "Hello Upchuk!"
Je crois que vous pouvez voir la puissance du conteneur de service, car nous pouvons maintenant écrire des fonctions découplées et les passer si nécessaire. Je ne vous montre pas comment le faire, mais vous pouvez déclarer des dépendances lors de votre inscription à un service. Cela signifie que lorsque Drupal instancie un objet de service, il le fera pour toutes ses dépendances et les transmettra à son constructeur. Vous pouvez en savoir plus sur la façon de procéder sur cette page de document.
Conclusion
Dans cet article, nous avons regardé beaucoup de choses sympas. Nous avons vu comment le système de configuration gère des configurations simples et quelles fonctionnalités "formulaire" sont fournies pour cela. Je vous encourage à explorer comment ConfigFormBase est mis en œuvre et quelles fonctionnalités sont disponibles lors de l'étendue. De plus, vous devez vous entraîner à utiliser des configurations d'importation / exportation entre les sites de l'interface utilisateur. À partir de maintenant, ce sera une grande amélioration du processus de déploiement.
Nous avons ensuite regardé les services, ce qu'ils sont et comment ils fonctionnent. Un excellent moyen de maintenir des blocs fonctionnels réutilisables et découplés accessibles de n'importe où. J'espère que le concept d'injection de dépendance n'est plus aussi effrayant (si c'est pour vous). Il est essentiellement la même que de passer des paramètres aux fonctions procédurales, mais se fait dans les coulisses par Symfony et ses puissants conteneurs de service en utilisant des méthodes de constructeur (ou des setters).
Questions fréquemment posées sur la construction de modules Drupal 8: gestion de la configuration et conteneurs de service
Le conteneur de service dans Drupal 8 est un composant clé qui gère la création de services, objets utilisés à l'échelle mondiale dans les applications Drupal. Il garantit que chaque service n'est instancié qu'une seule fois, en enregistrant la mémoire et en améliorant les performances. Le conteneur de service gère également l'injection de dépendance, un modèle de conception qui permet à un objet de fournir des dépendances pour un autre objet. Cela rend le code plus modulaire, plus facile à tester et favorise une meilleure organisation.
Pour définir un nouveau service dans Drupal 8, vous devez créer un fichier services.yml dans le répertoire racine du module. Ce fichier doit contenir le nom, la classe et les paramètres du service. Cette classe doit être le nom entièrement qualifié de la classe qui implémente le service, et les paramètres doivent être tout service ou paramètre sur lequel le service dépend.
La gestion de la configuration dans Drupal 8 est un système qui vous permet de gérer les données de configuration du site de manière cohérente. Il vous permet d'importer, d'exporter et de synchroniser les données de configuration, ce qui est utile lorsque le déplacement de la configuration passe de l'environnement de développement vers le site de production. Il fournit également un moyen de suivre et de gérer les modifications de configuration du site au fil du temps.
Pour exporter des données de configuration dans Drupal 8, vous pouvez utiliser l'interface de gestion de la configuration dans le panneau d'administration ou utiliser la commande DRUSH. Les données exportées seront au format YAML et peuvent être lues et modifiées facilement. Pour importer des données de configuration, vous pouvez télécharger le fichier YAML exporté via l'interface de gestion de configuration ou utiliser la commande DRUSH. N'oubliez pas de sauvegarder votre site avant d'importer des données de configuration pour éviter toute perte de données potentielle.
L'injection de dépendance est un modèle de conception qui permet à un objet de fournir des dépendances pour un autre objet. Dans Drupal 8, il est utilisé pour rendre les services et les contrôleurs plus modulaires et plus faciles à tester. Au lieu de créer des dépendances à l'intérieur d'un objet, ils sont passés (injectés) via un constructeur ou une méthode de setter. Cela rend le code plus facile à tester, plus flexible et moins couplé.
Pour injecter des dépendances dans les services dans Drupal 8, vous devez les définir dans la définition des services dans le fichier services.yml. Les dépendances doivent être répertoriées sous la clé arguments. Lorsqu'un service est créé, le conteneur de service transmettra automatiquement ces dépendances au constructeur du service.
Dans Drupal 8, un service est un objet qui effectue des tâches globales dans une application, tandis qu'un plug-in est un objet qui effectue des tâches spécifiques de manière enfichable. Les services sont définis dans le fichier services.yml et gérés par le conteneur de service, tandis que les plug-ins sont découverts et instanciés par le gestionnaire de plug-in.
Pour écraser un service dans Drupal 8, vous devez définir un service avec le même nom que le service que vous souhaitez écraser dans le fichier services.yml du module. Votre nouveau service doit étendre la classe du service d'origine et remplacer la méthode que vous souhaitez modifier.
Le système de gestion de la configuration dans Drupal 8 fournit un moyen de suivre les modifications de configuration du site via un système d'instantané de configuration. Ce système prend un instantané de la configuration active du site chaque fois que vous importez ou synchronisez des données de configuration. Vous pouvez ensuite comparer ces instantanés pour voir quels changements ont été apportés.
services.yml Que fait un fichier dans Drupal 8? Le fichier services.yml dans Drupal 8 est l'endroit où les services de module sont définis. Chaque service est défini à l'aide d'un nom unique, d'un nom entièrement qualifié de la classe qui implémente le service et de tout service ou paramètres sur lequel dépend du service. services.yml Les fichiers sont lus par le conteneur de service et le conteneur de service gère la création et l'injection du service.
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!
Algorithme de planification de disque
Comment gérer le ralentissement de l'ordinateur et la lenteur des réponses
Tutoriel PHP
Quels sont les frameworks front-end mvvm ?
Introduction aux caractères de retour chariot et de saut de ligne en Java
commutateur proxy
utilisation de hdtunepro
Comment utiliser le retour en langage C
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
