Hooks Implementation in Drupal 11.1: A New OOP Approach

In this blog post, we'll explore how to implement a hook using this new attribute-based approach, specifically focusing on altering a node article form (node_article_form) in Drupal 11.1. We'll walk through the steps and provide an example code implementation.

Introduction

Starting from Drupal 11.1, a new method for implementing hooks has been introduced, allowing developers to use object-oriented programming (OOP) principles. Unlike the traditional procedural approach, this new method enables hooks to be defined as methods within classes, making the code more organized and easier to manage.

Understanding the New Approach

In previous versions of Drupal, hooks were implemented as procedural functions, with function names following a specific pattern. This could make the code challenging to maintain in larger projects. With Drupal 11.1, hooks can now be implemented as methods in a class, and these methods are registered using a #[Hook] attribute.

Example: Altering the Node Article Form

Let's say we want to customize the node_article_form by adding some custom elements or modifying existing ones. Here's how you can implement this using the new approach.

Step 1: Create the Hook Class

Create a PHP class in the src/Hook directory of your module:

<?php

declare(strict_types=1);

namespace Drupal\mymodule\Hook;

use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Hook\Attribute\Hook;

/**
 * Hook implementations for the node module.
 */
class FormHooks {

  /**
   * Implements hook_form_alter().
   *
   * Customizes the node article form.
   */
  #[Hook('form_alter')]
  public function articleFormAlter(array &$form, FormStateInterface $form_state, $form_id) {
    if ($form_id == 'node_article_form') {
      // Add a custom message to the node article form.
      $form['custom_message'] = [
        '#type' => 'markup',
        '#markup' => '<p>This is a custom message added via a form alter hook.</p>',
      ];

      // Example of changing a field's default value.
      if (isset($form['title']['widget'][0]['value'])) {
        $form['title']['widget'][0]['value']['#default_value'] = 'Default Article Title';
      }
    }
  }
}

Step 2: Ensure Your Class is Properly Structured

Make sure your class is in the correct namespace and follows the naming conventions. Drupal 11.1 will automatically register this class as a service, so there’s no need to manually define it in a .services.yml file.

How it Works

In the above example:

#[Hook('form_alter')]: This attribute tells Drupal that the articleFormAlter method should be executed whenever hook_form_alter is triggered.
Method Parameters: The parameters ($form, $form_state, $form_id) are the same as those used in procedural hooks, making it easy to transition your code to the new method.
Form Alter Logic: You can add, remove, or modify form elements just as you would in a procedural hook.

Advantages of the New Approach

OOP and Autowiring: Using classes makes it easier to organize and manage your hook implementations. You can inject services into your classes, making your code cleaner and more maintainable.
Multiple Hooks in One Class: You can implement multiple hooks within a single class. For example, if you want to handle both hook_entity_insert and hook_entity_update for nodes, you can do:
```
#[Hook('entity_insert')]
#[Hook('entity_update')]
public function handleEntityInsertOrUpdate(EntityInterface $entity) {
  if ($entity->getEntityTypeId() === 'node') {
    // Handle both insert and update operations for nodes.
  }
}
```
This example shows how you can centralize logic for similar hooks, reducing code duplication and improving maintainability.
Easier Service Management: Classes are automatically registered as services, which can be altered using service provider classes. This eliminates the need for manual service registration and makes the process more seamless.

Conclusion

The new attribute-based hook system in Drupal 11.1 brings several benefits, including improved code organization, better service management, and ease of maintenance. Migrating to this new system is straightforward, especially for developers already familiar with procedural hooks. This approach modernizes how hooks are handled, paving the way for future improvements and making Drupal development more consistent.

By following the steps in this guide, you can start converting your old procedural hooks to the new class-based system and take advantage of the improved structure and flexibility offered by Drupal 11.1.