{"id":55745,"date":"2022-11-05T17:08:58","date_gmt":"2022-11-05T11:38:58","guid":{"rendered":"https:\/\/2thenew.xyz\/blog\/?p=55745"},"modified":"2026-03-26T15:37:51","modified_gmt":"2026-03-26T10:07:51","slug":"services-and-dependency-injection-in-drupal","status":"publish","type":"post","link":"https:\/\/2thenew.xyz\/blog\/services-and-dependency-injection-in-drupal\/","title":{"rendered":"Services and Dependency Injection in Drupal"},"content":{"rendered":"

Drupal 8+ is built upon Services, forming the backbone of modern Drupal development services<\/strong>, where much of the system functionality is powered through dependency injection.<\/p>\n

Services :<\/strong> Services: A service is any object managed by the services container, and understanding this concept is fundamental for teams offering scalable Drupal services<\/strong>, or we can say that services is a simple PHP class with some methods. we can access these services and methods in anywhere in the application with the help of service container.<\/p>\n

The service can be used the in following way. We use the \\Drupal::service() method to get an instantiated AliasManager object and then use a function in that object to translate the path to the alias.<\/p>\n

$aliasManager = \\Drupal::service(‘path_alias.manager’);
\n$path = ‘\/node\/123’;
\n$alias = $aliasManager->getAliasByPath($path);<\/p>\n

Such implementations are commonly leveraged in enterprise-grade Drupal development services<\/strong><\/a> to ensure modular and reusable architecture.<\/p>\n

Accessing Services:<\/strong> Services are all defined in YML files within Drupal. Every module that wants to define a service needs to create a file with the name of\u00a0[module name].services.yml , forming a structured Drupal services<\/strong> list that helps developers identify and reuse functionalities efficiently. In order to find all the available services in Drupal you can follow the Drupal services list<\/a> which acts as a reference for available core and custom services.<\/em><\/p>\n

So best practice for accessing the services is dependency injection instead of direct calling the global Drupal service container.<\/em><\/p>\n

Dependency Injection :\u00a0<\/strong> Dependency injection is a design pattern in which an object or function receives the dependencies it needs, a core practice widely adopted in modern Drupal as a service<\/strong> architectures for building scalable and decoupled systems. It means we can directly inject the services to the class __construct method, and it will load the dependency runtime when instantiate the class.<\/em><\/p>\n

Why use DI in Drupal :\u00a0<\/strong><\/p>\n

    \n
  1. Decoupled functionality<\/li>\n
  2. Eases unit testing<\/li>\n
  3. Reusable & flexible code<\/li>\n
  4. Cleaner code<\/li>\n
  5. Retrieving dependencies from the container is better for performance.<\/li>\n<\/ol>\n

    How to Inject Dependency :\u00a0<\/strong><\/p>\n

    Before implementing the DI let\u2019s have a look the code without DI. So i am just displaying the current user name in the render function. In the below code line no 13 and 14 i am using the Drupal function to get the username,<\/p>\n

    Example code without DI.\u00a0<\/strong><\/p>\n

    \"Blog<\/p>\n

    its also working fine but Drupal recommend to use Dependency Injection everywhere. So let\u2019s start to inject the Dependency Injection on same code base.<\/p>\n

    Example <\/strong>code With DI : <\/strong><\/p>\n

    Example 1: <\/strong>DI with in Controller<\/strong><\/p>\n

    I have created the simple render function within the controller , Here I am using the Dependency Injection to get the current user details based on the current_user services.<\/p>\n

    There is 2 main function to execute the DI in Drupal __construct() & create().<\/p>\n

    __<\/strong>Construct Method : <\/strong>With in the construct method we define all the services which we need as a DI.<\/p>\n

    Create Method : <\/b><\/strong>Create() method is a factory method based on the factory design Pattern.<\/p>\n

    create() method help us to create the instance of the all the services which we pass in the create() method. Return new static() means \u201cReturn a new instance of the current class, using the passed arguments in the class\u2019s constructor\u201d<\/p>\n

    So technically all the arguments and order of the arguments would be the same in both the create() and construct() function.<\/p>\n

    \"DI<\/p>\n

    Same as above we can define the DI in FormBase, configFormBase etc<\/p>\n

    Example 2 : D<\/strong>ependency Injection<\/strong> in<\/strong> s<\/strong>ervices <\/strong>class<\/strong><\/p>\n

    For services DI we are taking the example of core node.service.yml<\/a><\/p>\n

    \"services<\/p>\n

    That is saying that for the <\/span>node.grant_storage
    \n<\/code>service, <\/span><\/p>\n

    the <\/span>Drupal\\node\\NodeGrantDatabaseStorage
    \n<\/code>class will be used, and three arguments will be passed to it when creating an instance of it. <\/span><\/p>\n

    The <\/span>@ <\/code>symbol means that these are instances of other services. An instance of a <\/span>database <\/code>service, a <\/span>module_handler <\/code>service, and a <\/span>language_manager <\/code>service will be provided to this node.grant_storage service. These services are just objects of designated types.<\/span><\/p>\n

    Here’s the relevant portion of the <\/span>NodeGrantDatabaseStorge<\/a> <\/span><\/span>class. I’ve added line breaks to this and other code samples for readability.<\/span><\/p>\n

    \"services<\/p>\n

    The three arguments used in the constructor match the three arguments defined in the services file. The passed Object are then stored as properties of the class. <\/span>In other word, the three objects (dependencies) were injected into the client class (NodeGrantDatabaseStorage) by the services system.<\/span><\/a>Example 3: <\/span>Dependency Injection Inside Block (Plugin)<\/span><\/strong><\/p>\n

    Example 3: <\/span>Dependency Injection Inside Block (Plugin)<\/span><\/strong><\/p>\n

    We can inject our custom\/core service inside our custom block plugin for that we have to use.<\/span><\/p>\n

    use Drupal\\Core\\Plugin\\ContainerFactoryPluginInterface;<\/code> Suppose you have a custom block with the name <\/span>'drupalise'<\/span> then you inject your custom service<\/span> 'drupalise'<\/span> inside your custom block code as follows: \"Plugin<\/span><\/pre>\n
    Here drupalise is my custom service which has the function Drupalise().<\/span><\/p>\n
    That’s All in Drupal Dependency Injection. Happy Drupaling.<\/p>\n
     <\/p>\n
    \u00a0<\/span><\/pre>\n
    <\/div>","protected":false},"excerpt":{"rendered":"
    Drupal 8+ is built upon Services, forming the backbone of modern Drupal development services, where much of the system functionality is powered through dependency injection. Services : Services: A service is any object managed by the services container, and understanding this concept is fundamental for teams offering scalable Drupal services, or we can say that […]<\/p>\n","protected":false},"author":1509,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"iawp_total_views":703,"footnotes":""},"categories":[3602],"tags":[5042,4862],"class_list":["post-55745","post","type-post","status-publish","format-standard","hentry","category-drupal","tag-di","tag-drupal"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t