Top 3 des cas d’utilisation du système de routage Drupal | Drupal10

Introduction

Chaque développeur Drupal doit expérimenter le routage dans Drupal tout en créant un site Web interactif transparent avec une navigation facile. Dans cet article, nous vérifierons les différents scénarios auxquels nous sommes confrontés lors de la phase de développement du site. Je vais vous plonger dans le Top 3 des Use cases intéressants et très utiles autour des systèmes de routage Drupal. Mais avant d’entrer dans les détails, nous aurons un aperçu de l’importance du système de routage Drupal.

Système de routage

Système de routage Drupal

Aperçu

Le système de routage de Drupal est basé sur Le système de routage de Symfony. Il possède toutes les capacités du système de routage Symfony et peut également avoir des fonctionnalités étendues. Le routage Drupal utilise la même syntaxe que celle de Symfony.

Qu’est-ce qu’un itinéraire

Une route dans Drupal n’est pas une URL mais une configuration qui possède son propre ensemble d’instructions pour afficher le contenu d’une URL mentionnée. Vous pouvez postuler vérification d’accès et conversion ascendante des paramètres avec des itinéraires personnalisés. Dans Drupal, vous pouvez définir une route via le fichier .routing.yml, qui doit être conservé dans le dossier racine du module respectif.

Dans cet article, nous allons aborder les 3 principaux cas d’utilisation des systèmes de routage Drupal qui peuvent être bénéfiques tout en développant une fonctionnalité similaire.

1. Upcasting des paramètres d’itinéraire dynamique
2. Qu’est-ce qu’un ‘route_callbacks’ et comment l’utiliser
3. Appeler la classe Service directement depuis l’itinéraire

Comprenons les points ci-dessus un par un en détail :

1. Paramètres de route de diffusion ascendante

Dans Drupal, diffusion ascendante implique de transformer un paramètre de route d’une valeur scalaire de base, comme un identifiant, en un objet plus complexe. Cela permet aux développeurs d’accéder directement à l’objet complet dans le contrôleur, éliminant ainsi le besoin de plusieurs requêtes de base de données. L’utilisation de la conversion ascendante pour les paramètres d’itinéraire améliore à la fois les performances et la maintenabilité des applications Drupal.

Implémentation de la diffusion ascendante dans Drupal 10

Comprenons ce concept avec un exemple. Ici, nous avons créé un itinéraire /exemple/{nœud} et défini le type de paramètre en tant qu’entité de nœud. Ainsi, lorsque l’utilisateur accède à une URL telle que /example/123 dans le navigateur, l’objet nœud pour l’ID de nœud 123 se chargera et accédera à la classe du contrôleur appelant pour effectuer l’action requise.

Étape 1 : Définir l’itinéraire avec des paramètres

Tout d’abord, définissez une route dans le fichier de routage de votre module, en spécifiant le paramètre que vous souhaitez diffuser.

# exemple.routing.yml

example.content:
  path: '/example/{node}'
  defaults:
    _controller: '\Drupal\example\Controller\ExampleController::content'
  requirements:
    _permission: 'access content'
  options:
    parameters:
      node:
        type: entity:node

Étape 2 : Créer le contrôleur

Ensuite, créez le contrôleur qui gérera l’itinéraire. Injectez les services requis et définissez la méthode qui utilisera le paramètre upcasté.

namespace Drupal\example\Controller;

use Drupal\Core\Controller\ControllerBase;
use Drupal\node\NodeInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;

class ExampleController extends ControllerBase {
  public function content(NodeInterface $node) {
    // Your logic here.
    return [
      '#type' => 'markup',
      '#markup' => $this->t('Node title: @title', ['@title' => $node->getTitle()]),
    ];
  }
}

Étape 3 : Comprendre la conversion des paramètres

Dans l’exemple ci-dessus, le {node} Le paramètre de l’itinéraire est automatiquement converti en un NodeInterface objet par Drupal. Cette conversion est rendue possible en spécifiant le type de paramètre dans le fichier de routage.

En suivant les étapes décrites dans cet article, vous pouvez mettre en œuvre efficacement la conversion ascendante et exploiter tout son potentiel pour créer des solutions Drupal robustes et efficaces.

2. Qu’est-ce qu’un « route_callbacks » et comment l’utiliser

Dans Drupal, comme nous définissons des routes via les fichiers module.routing.yml comme des routes statiques, nous pouvons également implémenter des routes dynamiques selon nos besoins.

Qu’est-ce que route_callbacks ?

Le routage dynamique dans Drupal permet aux développeurs de définir dynamiquement leurs propres itinéraires. Ces itinéraires dynamiques sont implémentés via une méthode, qui est ensuite ajoutée en tant que ‘route_callbacks‘ dans le fichier modulename.routing.yml.

Cas d’utilisation :

Supposons que nous ayons une page météo et que sur cette page chaque dimanche (hebdomadaire), un nouvel itinéraire (lien) soit ajouté pour afficher les prévisions météorologiques hebdomadaires.

Pour y parvenir, nous pouvons utiliser le mécanisme de routage dynamique Drupal. nous créons des itinéraires chaque fois que nous voulons ajouter une nouvelle URL avec du code. En définissant une classe de routage dynamique à l’aide de route_callbacks puis en ajoutant le contrôleur correspondant.

2. Comment utiliser route_callbacks dans Drupal

Étape 1 : Définir la route avec route_callbacks

Tout d’abord, définissez les route_callbacks dans le fichier YML de routage du module et spécifiez la fonction de rappel.

# exemple.routing.yml

 route_callbacks:
  - '\Drupal\example\Routing\ExampleRouteCallbacks::routes'

Étape 2 : Créer la fonction de rappel

Ensuite, vous devez créer votre classe de routage et la fonction de rappel chargée de modifier l’itinéraire et d’y implémenter votre logique. La méthode de routage dynamique doit renvoyer soit un tableau de \Symfony\Composant\Routage\Route objets ou un objet \Symfony\Component\Routing\RouteCollection.

Exemple de retour d’un objet Route

Créez la classe de rappel et définissez la méthode pour renvoyer un tableau d’objets Route. Cette classe doit être placée dans le répertoire src/Routing de votre module.

namespace Drupal\example\Routing;

use Symfony\Component\Routing\Route;

class ExampleRouteCallbacks {

  public static function routes() {
    // Create the first route.
    $route1 = new Route(
    '/example/dynamic/route1',
    [
      '_controller' => '\Drupal\example\Controller\ExampleController::dynamic',
      '_title' => 'Dynamic Route 1',
    ],
    [
      '_permission' => 'access content'
    ]
    );

    // Create the second route.
    $route2 = new Route(
      '/example/dynamic/route2',
      [
        '_controller' => '\Drupal\example\Controller\ExampleController::dynamic',
        '_title' => 'Dynamic Route 2',
     ],
     ['
       _permission' => 'access content']
    );

    // Return an array of Route objects.
    return [
      'example.dynamic_route1' => $route1,
      'example.dynamic_route2' => $route2,
    ];
  }
}

Dans l’exemple ci-dessus, la méthode routes crée deux objets Route et les renvoie sous forme de tableau.

Un autre exemple pour vérifier comment implémenter la méthode route pour renvoyer un CollectionRoute objet. Cette classe doit être placée dans le répertoire src/Routing de votre module.

namespace Drupal\example\Routing;

use Symfony\Component\Routing\Route;
use Symfony\Component\Routing\RouteCollection;

class ExampleRouteCallbacks {

  public static function routes() {
    $collection = new RouteCollection();
    // Define a new route.
    $route = new Route(
      '/example/dynamic/{id}',
      [
        '_controller' => '\Drupal\example\Controller\ExampleController::dynamic',
        '_title' => 'Dynamic Route Example',
      ],
      [
        '_permission' => 'access content'
      ]
    );

    // Add the new route to the collection.
    $collection->add('example.dynamic_route_with_id', $route);
  return $collection;
 }
}

Dans l’exemple ci-dessus, la méthode route() crée une nouvelle route et l’ajoute à l’objet RouteCollection. Il modifie également un itinéraire existant en changeant son chemin.

En suivant ces étapes, vous pouvez créer une route dynamique dans Drupal qui utilise route_callbacks pour renvoyer et modifier un objet RouteCollection. Cette approche fournit un mécanisme puissant pour gérer dynamiquement les itinéraires au sein de votre application Drupal, améliorant ainsi la flexibilité et le contrôle.

Saisir et appliquer « route_callbacks » dans Drupal peut grandement améliorer la fonctionnalité et la sécurité de vos applications Drupal. En adhérant aux meilleures pratiques et en utilisant pleinement les capacités des rappels de route, les développeurs peuvent créer des expériences Web plus dynamiques, efficaces et sécurisées.

3. Appeler la classe Service directement depuis la route

Dans Drupal, une classe de service est une classe PHP conçue pour fournir des fonctionnalités particulières. Celles-ci peuvent aller de l’exécution d’opérations de base de données à la gestion de l’authentification des utilisateurs ou à l’exécution d’une logique métier personnalisée. Généralement, les classes de service sont enregistrées dans le conteneur de services de Drupal, ce qui leur permet d’être accessibles dans l’ensemble de l’application.

Étape 1 : Configuration d’une classe de service dans Drupal 10

Tout d’abord, créez une classe qui vous servira de service. Cette classe doit contenir les méthodes que vous souhaitez appeler depuis vos routes. Le fichier de classe de service nommé src/Service/MyCustomService.php réside dans le dossier src.

namespace Drupal\mymodule\Service;

class MyCustomService {
  public function myCustomMethod() {
    // Your custom logic here
    return"Hello, this is my custom service method!";
  }
}

Étape 2 : Enregistrez le service

Ensuite, vous devez enregistrer ce service auprès du conteneur de services de Drupal. Cela se fait dans le mymodule.services.yml fichier dans votre module.

# monmodule.services.yml

services:
  mymodule.my_custom_service:
   class: 'Drupal\mymodule\Service\MyCustomService'

Étape 3 : Définir l’itinéraire

Maintenant, vous devez définir une route qui appellera la méthode de service. Cela se fait dans le mymodule.routing.yml déposer.

# monmodule.routing.yml

mymodule.custom_route:
  path: '/custom-route'
  defaults:
   _controller: 'mymodule.my_custom_service:myCustomMethod'
   _title: 'Custom Route'
  requirements:
   _permission: 'access content'

Cela exécutera myCustomMethod() la méthode dans la classe définie est mymodule.services.yml pour le service mymodule.my_custom_service.

Appeler une classe de service directement depuis la route dans Drupal 10 est une technique puissante qui peut améliorer considérablement l’efficacité et la maintenabilité de votre code.

Conclusion

Le système de routage de Drupal est fondamental pour le développement Drupal contemporain, offrant une flexibilité et un contrôle exceptionnels sur le mappage d’URL et le traitement des requêtes. En maîtrisant les subtilités de ce système, les développeurs peuvent créer des applications Web robustes, efficaces et sécurisées.