Un guide étape par étape / Blogs / Perficient

décembre 20, 2023

Un guide étape par étape / Blogs / Perficient

Service:

Un service est tout objet géré par le conteneur de services.

Les services de Drupal aident à découpler les fonctionnalités réutilisables, les rendant connectables et remplaçables en les enregistrant auprès d’un conteneur de services. Les services agissent comme des héros méconnus, jouant un rôle crucial dans le maintien du bon fonctionnement du système Drupal.

Des services de base sont disponibles dans Drupal. Tous les services sont définis dans les fichiers « CoreServiceProvider.php » et « core.services.yml » dans Drupal. Pour obtenir la liste des services, vous pouvez suivre le liste de services.
Utilisez l’injection de dépendances comme approche privilégiée pour accéder et exploiter les services dans Drupal et déployez-la chaque fois que cela est possible.

Étapes pour définir un service personnalisé dans Drupal :

Configurer un module personnalisé:

Définissez les informations de base sur le module personnalisé dans le fichier *.info.yml.
```
name: General
description: All general activities.
type: module
core_version_requirement: ^9 || ^10
```

Création de la classe de service:

Séparez tous les fichiers de service en créant un dossier « Services » dans le répertoire « src ». Créez un fichier PHP dans le répertoire ‘Services’ contenant votre classe de service, par exemple YourService.php.

<?php

namespace Drupal\general\Services;

use Drupal\Core\Session\AccountProxy;

/**
 * This is a custom service class.
 */
class CustomService {

  /**
   * The custom service for additional logic.
   *
   * @var \Drupal\general\Services\CustomService
   */
  protected $additionalLogicService;

  /**
   * The current user service.
   *
   * @var \Drupal\Core\Session\AccountProxy
   */
  protected $currentUser;

  /**
   * Constructor for the CustomService class.
   *
   * @param \Drupal\Core\Session\AccountProxy $currentUser
   *   The current user service.
   */
  public function __construct(AccountProxy $currentUser) {
    $this->currentUser = $currentUser;
  }

  /**
   * Provides custom logic information.
   *
   * @return string
   *   A message indicating custom logic information.
   */
  public function provideCustomLogicInfo() {
    return "Custom logic information: ";
  }

  /**
   * Retrieves the display name of the current user.
   *
   * @return string
   *   The display name of the current user.
   */
  public function getCurrentUserName() {
    return $this->currentUser->getDisplayName();
  }

}

Définit une classe « CustomService » et deux propriétés protégées : « $additionalLogicService » et « $currentUser ». La propriété ‘$currentUser’ stocke les instances d’autres classes avec lesquelles la classe CustomService interagit.

Le constructeur de cette classe prend un argument de type « Drupal\Core\Session\AccountProxy ». Cet argument représente généralement l’utilisateur actuel et est affecté à la propriété « $currentUser ». Ceci est un exemple d’injection de dépendances, où le constructeur fournit les dépendances requises à la classe.

/**
 * Provides custom logic information.
 *
 * @return string
 *   A message indicating custom logic information.
 */
public function provideCustomLogicInfo() {
  return "Custom logic information: ";
}

/**
 * Retrieves the display name of the current user.
 *
 * @return string
 *   The display name of the current user.
 */
public function getCurrentUserName() {
  return $this->currentUser->getDisplayName();
}

La fonction ‘provideCustomLogicInfo()’ génère une chaîne de texte fondamentale, tandis que ‘getCurrentUserName()’ récupère activement le nom d’affichage de l’utilisateur actuellement connecté via l’objet ‘$currentUser’. Ces étapes démontrent la structure d’une classe de service dans Drupal, qui comprend des propriétés, des constructeurs et des méthodes. Pour utiliser cette classe en tant que service dans Drupal, assurez-vous de son enregistrement dans le fichier ‘general.services.yml’ et spécifiez explicitement à la fois la classe et ses dépendances.

Création d’une définition de service:

Créez un fichier ‘*.services.yml’ dans le répertoire du module. Le nom du fichier doit être « nom_module.services.yml ». Par exemple, « général.services.yml ». Ce fichier définit les services et leurs classes correspondantes pour le module Drupal.
```
services:
  general.custom_service:
    class: Drupal\general\Services\CustomService
    arguments: ['@current_user']
```
1. Général.custom_service : Le nom unique de la machine pour le service. Modèle ‘nom_module.nom_unique’.
2. Classe: L’espace de noms complet de votre classe de service.
3. Arguments: Passage d’arguments au constructeur de service. Dans ce cas, utilisez le service principal « @current_user » pour obtenir le nom d’affichage de l’utilisateur.

Utilisez des services personnalisés via l’injection de dépendances :

Désormais, utilisez le service personnalisé dans d’autres parties ou même dans d’autres modules. Par exemple, dans un contrôleur ou un autre service, utilisez l’injection de dépendances pour accéder à un service personnalisé. À titre d’exemple, l’accès au service via le Contrôleur

<?php

namespace Drupal\general\Controller;

use Drupal\Core\Controller\ControllerBase;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Drupal\general\Services\CustomService;

class UsernameController extends ControllerBase {

  /**
   * The custom service for handling user information.
   *
   * @var \Drupal\general\Services\CustomService
   */
  protected $customService;

  /**
   * Constructs a new UsernameController object.
   *
   * @param \Drupal\general\Services\CustomService $customService
   *   The custom service for handling user information.
   */
  public function __construct(CustomService $customService) {
    $this->customService = $customService;
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container) {
    return new static(
      $container->get('general.custom_service'),
    );
  }

  /**
   * Render the user information using the custom service.
   *
   * @return array
   *   A render array.
   */
  public function renderUserInfo() {
    return [
      '#type' => 'markup',
      '#markup' => $this->customService->provideCustomLogicInfo() . $this->customService->getCurrentUserName(),
    ];
  }

}

Dans Controller, nous devons importer les classes nécessaires. N’oubliez pas non plus d’importer le service personnalisé. Propriété protégée $customService pour stocker une instance du ‘Service personnalisé’ classe.

/**
 * Constructs a new UsernameController object.
 *
 * @param \Drupal\general\Services\CustomService $customService
 *   The custom service for handling user information.
 */
public function __construct(CustomService $customService) {
  $this->customService = $customService;
}

Le constructeur est responsable de l’initialisation de l’objet contrôleur. Il prend une instance de « CustomService » comme argument et l’injecte dans le contrôleur. Il s’agit d’un exemple d’injection de dépendances, où la dépendance requise (CustomService) est fournie via le constructeur.

/**
 * {@inheritdoc}
 */
public static function create(ContainerInterface $container) {
  return new static(
    $container->get('general.custom_service'),
  );
}

La méthode create est une méthode d’usine utilisée par le conteneur d’injection de dépendances de Drupal. Il crée une nouvelle instance de la classe ‘UsernameController’ et injecte les dépendances requises. Dans ce cas, il récupère l’instance CustomService du conteneur en utilisant ‘$container->get(‘general.custom_service’)’.

/**
 * Render the user information using the custom service.
 *
 * @return array
 *   A render array.
 */
public function renderUserInfo() {
  return [
    '#type' => 'markup',
    '#markup' => $this->customService->provideCustomLogicInfo() . $this->customService->getCurrentUserName(),
  ];
}

Cette méthode, « renderUserInfo() », est chargée de restituer les informations utilisateur à l’aide des méthodes fournies par le CustomService injecté. Il renvoie un tableau de rendu, qui pourrait être utilisé pour afficher du contenu sur une page Drupal.

L’injection de dépendances ici, en particulier dans le constructeur et la méthode create, garantit que la classe UsernameController n’est pas étroitement couplée à l’implémentation concrète de CustomService, ce qui la rend plus flexible et accessible aux tests. Il suit également les meilleures pratiques de Drupal en matière d’instanciation et d’utilisation des services.

Vider le cache:

Après avoir créé ou modifié votre service et sa définition, videz le cache de Drupal à l’aide de Drush (raisin cr) ou l’interface d’administration.

C’est ça! Création réussie d’un service personnalisé dans Drupal. Ajustez la classe de service et la définition en fonction de vos fonctionnalités spécifiques.

Source link

Un guide étape par étape / Blogs / Perficient

Service:

Étapes pour définir un service personnalisé dans Drupal :

Configurer un module personnalisé:

Création de la classe de service:

Création d’une définition de service:

Utilisez des services personnalisés via l’injection de dépendances :

Vider le cache:

Service:

Étapes pour définir un service personnalisé dans Drupal :

Configurer un module personnalisé:

Création de la classe de service:

Création d’une définition de service:

Utilisez des services personnalisés via l’injection de dépendances :

Vider le cache:

Partager :