Learn how to Interact and Extend Drupal 11 Using Core API with six powerful methods, including hooks, routing, entity API, plugins, services, events, and theme hooks.
Drupal, one of the most powerful content management systems (CMS), provides a rich set of core APIs that allow developers to extend and interact with the platform seamlessly.
Whether you want to modify existing functionality, create custom features, or integrate third-party services, Drupal’s core APIs offer flexible solutions.
In this blog post, we will explore six essential ways to leverage Drupal's core APIs in your custom module.
1. Hook System for Extending Drupal Functionality
Drupal’s hook system enables developers to alter or extend core functionality without modifying core files. Hooks are PHP functions named in a specific pattern that Drupal invokes at various stages of execution.
Example: Altering a Form
<?php
namespace Drupal\mymodule\Hook;
use \Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Hook\Attribute\Hook;
class FormHook {
#[Hook('form_alter')]
public function formHookAlter(&$form, $form_state, $form_id) {
if ($form_id == 'user_login_form') {
$form['name']['#title'] = t('Enter Your Username');
}
}
}This hook modifies the user login form’s label dynamically. You can alter other fields and their attributes.
2. Creating Custom Routes with the Routing API
Drupal 8 and later (9, 10, & 11) use Symfony-based routing for defining custom URLs and linking them to controllers.
Controller act as a mediator between request and response cycle. A route loads a method of controller class and that method define the logic how data should be processed before returning the data to the presentation layer.
Example: Defining a Route in mymodule.routing.yml
mymodule.route_example:
path: '/route-example'
defaults:
_controller: '\Drupal\mymodule\Controller\CustomController::content'
_title: 'My Custom Page'
requirements:
_permission: 'access content'Above route defines a path example.com/route-example path in the website. When a user visit this URL, it will open the page and content method of the CustomController will be invoked.
3. Creating and Managing Entities with the Entity API
Drupal’s Entity API allows developers to create, modify, and manage content programmatically. These entities can store, operate and retrieve the data based on user activities.
Example: Creating a node Entity
$node = \Drupal::entityTypeManager()->getStorage('node')->create([
'type' => 'article',
'title' => 'My Custom Article',
]);
$node->save();Using EntityTypeManager service we can create, update any core or custom entities. Here we are creating a article node programmatically.
4. Using the Plugin API for Extensible Functionality
The Plugin API enables developers to create reusable, pluggable components those can be enabled or disabled at runtime.
Example: Creating a Custom Block Plugin
namespace Drupal\bhimmu_styles\Plugin\Block;
use Drupal\Core\Block\Attribute\Block;
use Drupal\Core\Block\BlockBase;
use Drupal\Core\StringTranslation\TranslatableMarkup;
/**
* Provides an example block block.
*/
#[Block(
id: 'bhimmu_styles_example_block',
admin_label: new TranslatableMarkup('Example Block'),
category: new TranslatableMarkup('Custom'),
)]
final class ExampleBlockBlock extends BlockBase {
/**
* {@inheritdoc}
*/
public function build(): array {
$build['content'] = [
'#markup' => $this->t('It works!'),
];
return $build;
}
}We have created a custom block and now it is ready to be displayed at specific region on a page.
5. Leveraging the Services and Dependency Injection
The Services and Dependency Injection Container concepts have been adopted by Drupal from the Symfony DependencyInjection component.
Example: Injecting a Service into a Controller Class
<?php
namespace Drupal\bhimmu_styles\Plugin\Block;
use Drupal\Core\Block\Attribute\Block;
use Drupal\Core\Block\BlockBase;
use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Drupal\Core\Entity\EntityTypeManagerInterface;
use Drupal\Core\File\FileUrlGenerator;
use Drupal\Core\StringTranslation\TranslatableMarkup;
/**
* Provides a 'LatestBlogBlock' block.
*/
#[Block(
id: 'latest_blog_block',
admin_label: new TranslatableMarkup('Latest blog block'),
category: new TranslatableMarkup('Custom'),
)]
class LatestBlogBlock extends BlockBase implements ContainerFactoryPluginInterface {
/**
* Drupal\Core\Entity\EntityTypeManagerInterface definition.
*
* @var \Drupal\Core\Entity\EntityTypeManager
*/
protected $entityTypeManager;
/**
* Drupal\Core\File\FileUrlGeneratorInterface definition.
*
* @var \Drupal\Core\File\FileUrlGenerator
*/
protected $fileUrlGenerator;
/**
* Constructs a new LatestBlogBlock object.
*
* @param array $configuration
* A configuration array containing information about the plugin instance.
* @param string $plugin_id
* The plugin_id for the plugin instance.
* @param string $plugin_definition
* The plugin implementation definition.
* @param \Drupal\Core\Entity\EntityTypeManager $entity_type_manager
* Entity type manager service.
* @param \Drupal\Core\File\FileUrlGenerator $file_url_generator
* File url generator service.
*/
public function __construct(
array $configuration,
$plugin_id,
$plugin_definition,
EntityTypeManagerInterface $entity_type_manager,
FileUrlGenerator $file_url_generator
) {
parent::__construct($configuration, $plugin_id, $plugin_definition);
$this->entityTypeManager = $entity_type_manager;
$this->fileUrlGenerator = $file_url_generator;
}
/**
* {@inheritdoc}
*/
public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
return new static(
$configuration,
$plugin_id,
$plugin_definition,
$container->get('entity_type.manager'),
$container->get('file_url_generator')
);
}
/**
* {@inheritdoc}
*/
public function build() {
$build = ['#markup' => 'No Result Found!'];
$data = [];
$entity_storage = $this->entityTypeManager->getStorage('node');
return $build;
}
}
6. Working with Events and Event Subscribers
Drupal follows an event-driven architecture that allows modules to listen for and respond to system events.
Example: Subscribing to an Event
namespace Drupal\mymodule\EventSubscriber;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Drupal\Core\Event\KernelEvents;
use Symfony\Component\HttpKernel\Event\RequestEvent;
class MyEventSubscriber implements EventSubscriberInterface {
public static function getSubscribedEvents() {
return [KernelEvents::REQUEST => ['onRequest', 100]];
}
public function onRequest(RequestEvent $event) {
\Drupal::messenger()->addMessage('Request event triggered!');
}
}This event subscriber displays a message whenever a request is made.
Conclusion
Developers are able to create robust and adaptable modules by utilizing core APIs to interact with and modify Drupal. Drupal offers a great deal of customization options, whether through hooks, routing, entities, plugins, services, or event subscribers.
You can improve the functionality of your Drupal website without depending on superfluous contributed modules by utilizing these core APIs.
