The biggest thing that got me excited with Drupal 8 is the first-class use of services & dependency-injection throughout the entire system. From aspects like routing, templating, managing configuration, querying and persisting data, you name it – everything is done with services. This is a great thing, because it grants developers a level of flexibility in extending Drupal that is far greater than what Drupal 7 was able to.

I’ll walk you through a few strategies of extending existing functionality, leveraging the power of Symfony’s DependencyInjection component.

Example 1: Inheritance

Since everything in Drupal 8 can be traced back to a method call on an object within the service container, using inheritance to modify core behavior is a valid strategy.

For example, say we want to add the ability to specify the hostname when generating absolute URLs using Drupal\Core\Url::fromRoute. A quick look at this method will tell you that all the work is actually done by the @url_generator service (a lot of Drupal 8’s API is set up like this – a static method that simply delegates work to a service from the container somehow).

drupal/core/core.services.yml can tell us a lot about what makes up the @url_generator service:

services:
  ...
  url_generator:
    class: 'Drupal\Core\Render\MetadataBubblingUrlGenerator'
    arguments: ['@url_generator.non_bubbling', '@renderer']
    calls:
      - [setContext, ['@?router.request_context']]
  
  url_generator.non_bubbling:
    class: 'Drupal\Core\Routing\UrlGenerator'
    arguments: ['@router.route_provider', '@path_processor_manager', '@route_processor_manager', '@request_stack', '%filter_protocols%']
    public: false
    calls:
      - [setContext, ['@?router.request_context']]
  ...

A peek at Drupal\Core\Render\MetadataBubblingUrlGenerator will actually show that it just delegates the core work of constructing a URL to the @url_generator.non_bubbling service.

To add the desired ability to the URL generator, we will have to write a new class that handles the extra logic:

<?php

namespace Drupal\foo\Routing;

use Drupal\Core\Routing\UrlGenerator;

class HostOverridingUrlGenerator extends UrlGenerator
{
    public function generateFromRoute(
      $name, 
      $parameters = array(), 
      $options = array(), 
      $collected_bubbleable_metadata = NULL
    ) {
      
        // Check if the `host` option is present and is not empty.
        $hasHostOverride = array_key_exists('host', $options) && $options['host'];
      
        if ($hasHostOverride) {
            /* 
             * Override the host value in the router's request context, which is used
             * to construct absolute URLs.
             * 
             * We need to store the original value because we will need to put it back later.
             */
            $originalHost = $this->context->getHost();
            $this->context->setHost((string) $options['host']);
            $options['absolute'] = true;
        }
      
        $result = parent::generateFromRoute($name, $parameters, $options, $collected_bubbleable_metadata);
      
        if ($hasHostOverride) {
            // If we did a host override, put back the original host value.
            $this->context->setHost($originalHost);
        }
      
        return $result;
    }
}

We now have a new type that is capable of overriding the hosts in absolute URLs that are generated. The next step is to tell Drupal use this in favor of the original. We can do that by manipulating the existing definition through a service provider.

Service Providers

Drupal will look for a service provider in your module directory and will hand it the container-builder for it to be manipulated. Telling Drupal to use our new class is not done by editing drupal/core/core.services.yml but by modifying the definition through the service provider:

<?php

/* @file modules/custom/foo/FooServiceProvider.php */

namespace Drupal\foo;

use Drupal\Core\DependencyInjection\ServiceProviderInterface;
use Drupal\Core\DependencyInjection\ContainerBuilder;

class FooServiceProvider  implements ServiceProviderInterface
{
    public function register(ContainerBuilder $container)
    {
        $urlGenerator = $container->getDefinition('url_generator.non_bubbling');
        $urlGenerator->setClass(__NAMESPACE__ . '\Routing\HostOverridingUrlGenerator');
    }
}

Done! Once the foo module is installed, your service provider will now have the chance to modify the service container as it see fit.

Example 2: Decorators

In a nutshell, a decorator modifies the functionality of an existing object not by extending its type but by wrapping the object and putting logic around the existing functionality.

This distinction between extending the object’s type versus wrapping it seems trivial, but in practice it can be very powerful. It means you can change an object’s behavior at run-time, with the added benefit of not having to care what the object’s type is. An update to Drupal core could change the type (a.k.a. the class) of a service at any point, as long as the substitute object still respect the agreed contract imposed by an interface, then the decorator would still work.

Say another module declared a service named @twitter_feed and we want to cache the result of some expensive method call:

<?php

use Drupal\foo\Twitter;

use Drupal\some_twitter_module\Api\TwitterFeedInterface;
use Drupal\Core\Cache\CacheBackendInterface;

class CachingTwitterFeed implements TwitterFeedInterface
{
      public function __construct(TwitterFeedInterface $feed, CacheBackendInterface $cache)
      {
          $this->feed = $feed;
          $this->cache = $cache;
      }
      
      public function getLatestTweet($handle)
      {
      
          // Check if we already have it in cache. If so, return it.
          if ($this->cache->has($handle)) {
            return $this->cache->get($handle);
          }
          
          // Otherwise, retrieve it from the inner TwitterFeedInterface object
          // and cache it for future use.
          $tweet = $this->feed->getLatestTweet($handle);
          $this->cache->set($handle, $tweet, 60 * 60 * 5); // Cache it for 5 minutes.
          
          return $tweet;
      }
      
      public function setAuthenticationToken($token)
      {
          // There is no point caching this.
          return $this->feed->setAuthenticationToken($token);
      }
}

To tell Drupal to decorate a service, you can do so in YAML notation:

# foo.service.yml
services:
  cached.twitter_feed:
    class: 'Drupal\foo\Twitter\CachingTwitterFeed'
    decorates: 'twitter_feed'
    arguments: ['@twitter_feed.inner', '@cache.twittter_feed']

With this in place, all references and services requiring @twitter_feed will get our instance that does caching instead.

The original @twitter_feed service will be renamed to @twitter_feed.inner by convention.

Decorators vs sub-classes

Decorators are perfect for when you need to add logic around existing ones. One beauty behind decorators is that it doesn’t need to know the actual type of the object it tries to change. It only needs to know what methods it responds to i.e. it only cares about the objects interface, and not much else.

Another beautiful thing is that you can effectively modify the object’s behavior at run-time:

<?php
 
$feed = new TwitterFeed();
$feed->setAuthenticationToken($token);

if ($isProduction) { //Change behavior during run-time.
  $feed = new CachingTwitterFeed($feed, $cache);
}

$feed->getLastTweet(...);

or:

<?php

$feed = new TwitterFeed();
$cachedFeed = new CachingTwitterFeed($feed, $cache);

$feed->setAuthenticationToken($token);

$feed->getLastTweet(...) // Use this if you really need a fresh tweet.
$cachedFeed->getLastTweet(...) // Use this if you don't mind a cached, potentially outdated tweet.

$feed->setAuthenticateToken($newToken); // Affects both!

Compare that to if you have the caching version as a sub-class, then you’ll need to instantiate two objects, and (re)authenticate both.

And lastly, one cool thing about decorators is you can layer them with greater flexibility:

<?php

$feed = new TwitterFeed();

$feed = new CachingTwitterFeed($feed, $cache); // Caches calls to Twitter.
$feed = new LoggingTwitterFeed($feed); // Logs all API calls to Twitter.
$feed = new CachingTwitterFeed(new LoggingTwitterFeed($feed), $cache); // Caches AND logs calls to Twitter!

These are contrived examples but I hope you get the gist.

However there are cases where using decorators just wouldn’t cut it (for example, if you need to access a protected property or method, which you can’t do with decorators). I’d say that if you can accomplish the necessary modifications using only an object’s public API, think about achieving it using decorator(s) instead and see if it’s advantageous.

The HostOverridingUrlGenerator can actually be written as a decorator, as we can achieve the required operations using the objects public API only – instead of using $this->context, we can use $this->inner->getContext() instead, etc.

In fact, the @url_generator service, an instance of Drupal\Core\Render\MetadataBubblingUrlGenerator is a decorator in itself. The host override behavior can be modelled as:

new MetadataBubblingUrlGenerator(new HostOverridingUrlGenerator(new UrlGenerator(...)), ...)

One down-side of using decorators is you will end up with a bunch of boilerplate logic of simply passing parameters to the inner object without doing much else. It will also break if there are any changes to the interface, although this shouldn’t happen until a next major version bump.

Composites

You might want to create a new service whose functionality (or part thereof) involves the application of multiple objects that it manages.

For example:

<?php

use Drupal\foo\Processor;

class CompositeProcessor implements ProcessorInterface
{
    /**
     * Array of varying processors.
     *
     * @var ProcessorInterface[]
     */
    protected $processors = array();
  
    public function process($value)
    {
        // Apply all known processors on the value, and return the accumulated result.
        foreach ($this->processors as $processor) {
            $value = $processor->process($value);
        }
      
        return $value;
    }
    
    public function addProcessor(ProcessorInterface $processor)
    {
        $this->processors[] = $processor;
    }
}

Composite objects like this are quite common, and there are a bunch of them in Drupal 8 as well. Traditionally, an object that wants to be added to the collection must be declared as tagged service. They are then gathered together during a compiler pass and added to the composite object’s definition.

In Drupal 8, you don’t need to code the compiler pass logic anymore. You can just tag your composite service as a service_collector, like so:

# foo.services.yml

services:
    the_processor:
      class: 'Drupal\foo\Processor\CompositeProcessor'
      tags:
        - { name: 'service_collector', tag: 'awesome_processor', call: 'addProcessor' }

    bar_processor:
      class: 'Drupal\foo\Processor\BarProcessor'
      arguments: [ '@bar' ]
      tags:
        - { name: 'awesome_processor' }

    foo_processor:
      class: 'Drupal\foo\Processor\FooProcessor'
      arguments: [ '@foo' ]
      tags:
        - { name: 'awesome_processor' }

With this configuration, the service container will make sure that @bar_processor and @foo_processor are injected into the @the_processor service whenever you ask for it. This also allows other modules to hook into your service by tagging their service with awesome_processor, which is great.

Conclusion

These are just a few OOP techniques that the addition of a dependency injection component has opened up to Drupal 8 development. These are things that PHP developers using Symfony2, Laravel, ZF2 (using its own DI component, Zend\Di), and many others have enjoyed in the recent years, and they are now ripe for the taking by the Drupal community.

For more info on Symfony’s DependencyInjection component, head to http://symfony.com/doc/2.7/components/dependency_injection/index.html. I urge you to read up on manipulating the container-builder in code as there are a bunch of things you can do in service providers that you can’t achieve by using the YAML notation.

If you have any questions, comments, criticisms, or some insights to share, feel free to leave a comment! Happy coding!f you have any questions, comments, criticisms, etc feel free to leave a comment! Happy coding!