In modern Drupal development, understanding core concepts like services and dependency injection is essential for building modular, scalable, and maintainable applications. Think of services as pre-built tools that help you perform certain tasks (error logging, text translations, etc) and Dependency Injections (DI) as a delivery method that hands out to you exactly what services you need.

In this article, we will explore more on why services and DI are crucial and how to use them effectively in Drupal.

What are Services

In Drupal, a service is an object managed by the service container, which acts as a central registry for all services within the application. Since the introduction of Drupal 8, services have been used to separate reusable functionality, making them customizable and interchangeable by registering them in a service container.

Services are typically registered in YAML files and are accessible throughout the Drupal application. Core services are defined in the core.services.yml file, located in Drupal's core directory. A service is a class that provides a specific function, like sending emails, validating data, interacting with users, etc. and is accessed through the service container.

What is a Dependency Injection

Dependency injection (DI) is a software design pattern that involves passing required objects (dependencies) into a class, rather than hard-coding them within the class. This design allows services to be easily replaced and tested.

In Drupal, services can be injected into a class’s __construct method, ensuring dependencies are provided when the class is instantiated.

There are two key methods to handle DI in Drupal:

• __construct Method: This method specifies the services that need to be injected.
• create Method: This method is used to create instances of services, allowing them to be initialized when needed.

Example of Code Without Dependency Injection

The following example shows how code would look without using DI, relying on static calls to access services:

public function validateForm(array &$form, FormStateInterface $form_state) {
    $value = $form_state->getValue('email');

    // Email validation
    if (!\Drupal::service('email.validator')->isValid($value)) {
        $form_state->setErrorByName('email', $this->t('Invalid email.'));
    }
}

public function submitForm(array &$form, FormStateInterface $form_state) {
    $user = \Drupal::currentUser();
    if ($user->isAuthenticated()) {
        \Drupal::messenger()->addMessage('Form Submitted By Logged-in User');
    }
}

In this code, the \Drupal::service('email.validator') and \Drupal::currentUser() methods are used directly, which tightly couples the code to the global service container. This approach reduces testability and flexibility, as it is more difficult to swap out services for testing or future modifications.

Downsides of Static Calls

1. Tight Coupling: The code is tightly linked to the global service container.
2. Difficult to Test: It is challenging to mock or replace services in unit tests.
3. Less Flexibility: Changing services or modifying the logic becomes harder since the class depends on static service calls.

Example with Dependency Injection

Here’s an example of how the same functionality can be written using dependency injection:

public function __construct(EmailValidatorInterface $emailValidator, AccountInterface $userAccount, MessengerInterface $messengerService) {
    $this->emailValidator = $emailValidator;
    $this->account = $userAccount;
    $this->messenger = $messengerService;
}

public function submitForm(array &$form, FormStateInterface $form_state) {
    if ($this->account->isAuthenticated()) {
        $this->messenger->addMessage('Form Submitted By Logged-in User');
    }
}

In this example, services like EmailValidatorInterface, AccountInterface, and MessengerInterface are injected into the constructor. This approach decouples the class from the global service container and promotes modularity. The services can be mocked or replaced easily, making the code easier to test and maintain.

Why is Dependency Injection important

The importance of DI can be summed up in three main points:

1. Modularity: Each class has a single responsibility and remains independent of other components.
2. Testability: It makes testing easier by enabling the use of mock dependencies through dependency injection.
3. Performance: By only loading necessary dependencies, performance is improved.

Best practices for using Dependency Injection

1. Use DI in larger projects: For complex applications, DI is essential for improving maintainability and scalability.
2. Direct service access for simplicity: In smaller projects where simplicity is prioritized, direct service access (without DI) might be acceptable.

Final thoughts

Services and dependency injection play a very important role in Drupal development. By learning and applying these concepts effectively, developers can build applications that are more adaptable, easier to maintain, and scalable. DI ensures your code remains modular and testable, regardless of the size of your project. Let us help you take your Drupal projects further. Check out our Drupal development services today.