Listening to core events (e.g., kernel events)for Drupal 8 , 9 , 10 , and 11

Drupal's event system provides a powerful way to respond to changes within the application lifecycle. By listening to core events, such as those related to the kernel, you can implement responsive functionality that enhances your module's interactivity and responsiveness. This lesson will guide you through the process of adding event listeners to interact with Drupal’s kernel events.

Understanding Drupal Events

Drupal integrates with the Symfony event dispatcher component, which facilitates the listening and triggering of events. Events signify actions or occurrences that components can respond to, allowing modules to be more modular and loosely coupled.

What are Kernel Events?

Kernel events are specific events tied to the HTTP kernel lifecycle. They include important moments such as when a request is received, a response is sent, or an exception is caught. By listening to these events, developers can modify requests and responses, handle errors gracefully, or integrate custom processing logic during these critical points.

Setting Up an Event Listener

Let's create an event listener that logs a message whenever a page request is received in Drupal.

Step 1: Define the Event Subscriber Class

Create a directory in your module for event subscribers, e.g., src/EventSubscriber. Then, create a file named PageRequestSubscriber.php in this directory.

namespace Drupal\your_module\EventSubscriber;

use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpKernel\KernelEvents;
use Symfony\Component\HttpKernel\Event\RequestEvent;
use Psr\Log\LoggerInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;

class PageRequestSubscriber implements EventSubscriberInterface {

    protected $logger;

    /**
     * Constructs a new PageRequestSubscriber.
     *
     * @param \Psr\Log\LoggerInterface $logger
     *   A logger instance.
     */
    public function __construct(LoggerInterface $logger) {
        $this->logger = $logger;
    }

    /**
     * Log a message when a page request is received.
     *
     * @param \Symfony\Component\HttpKernel\Event\RequestEvent $event
     *   The event to process.
     */
    public function onKernelRequest(RequestEvent $event) {
        $this->logger->info('A page request was received.');
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents() {
        return [
            KernelEvents::REQUEST => 'onKernelRequest',
        ];
    }

    /**
     * {@inheritdoc}
     */
    public static function create(ContainerInterface $container) {
        return new static(
            $container->get('logger.factory')->get('your_module')
        );
    }
}

In this example, our PageRequestSubscriber listens for the KernelEvents::REQUEST event and logs a message using the logger service whenever a request is received. Implementing the EventSubscriberInterface is essential, as it mandates defining which events the subscriber cares about.

Step 2: Register the Event Subscriber as a Service

In your_module.services.yml, register the event subscriber:

services:
  your_module.page_request_subscriber:
    class: Drupal\your_module\EventSubscriber\PageRequestSubscriber
    arguments: ['@logger.factory']
    tags:
      - { name: event_subscriber }

This service registration links your subscriber class with the event system, ensuring it's activated by Drupal during relevant events.

Enhancing Functionality with Events

Beyond logging requests, listeners can modify request attributes, halt or redirect responses, authenticate users differently, and many more tasks, depending on your needs.

Modifying Response Headers on Kernel Response

For an extended example, you might also listen to the KernelEvents::RESPONSE event to add custom headers:

use Symfony\Component\HttpKernel\Event\ResponseEvent;

public function onKernelResponse(ResponseEvent $event) {
    $response = $event->getResponse();
    $response->headers->set('X-Custom-Header', 'MyValue');
}

public static function getSubscribedEvents() {
    return [
        KernelEvents::REQUEST => 'onKernelRequest',
        KernelEvents::RESPONSE => 'onKernelResponse',
    ];
}

Such response modifications show the versatility of event-driven programming, as they can dynamically alter behavior without frequent changes to core logic or code.

Conclusion

Integrating event listeners into your Drupal modules unlocks new levels of responsiveness and customization. By responding to core events, particularly kernel-related ones, you can embed functionality directly within Drupal's operational cycle, enhancing both complexity and capability.

Continuing with our exploration of Drupal's event system, the next lesson will introduce "Defining a Custom Event Class," where you'll learn to craft your own events that other developers or modules can listen to, expanding your development toolkit. Continue building powerful, responsive modules with Drupal!