Drupal 8 Services And Dependency Injection

Drupal 8 Services
And
Dependency Injection.
Phil Norton

Phil Norton
Technical Lead at
Help run NWDUG
Blog at #! code (www.hashbangcode.com)
@philipnorton42 on Twitter

NWDUGNORTH WEST DRUPAL USER GROUP
2ND TUESDAY / MONTH
STREAM ON YOUTUBE
3RD UNCONFERENCE IN
NOVEMBER
FOLLOW @NWDUG

What Are Drupal
Services?
• Allow access to lots of things in Drupal 8.
• Wrap objects and deﬁne a common interface.
• Automatic Dependency Injection.
• Powerful
• Certiﬁed awesome

conﬁg
cron
renderer
path
route
ﬁle_system
plugin
cache
date
access_manager
event_dispatcher
menu
translation
entity

$object = Drupal::service('thing');
$object->method();

$pathManager = Drupal::service('path.alias_manager');
$path = 'somepath';
$normalPath = $pathManager->getPathByAlias($path);

$path = 'somepath';
$normalPath = $pathManager->getPathByAlias($path);
Instantiated AliasManager object

$normalPath = Drupal::service('path.alias_manager')
->getPathByAlias('somepath');

/* @var DrupalCorePathAliasManager $pathManager */

Services are deﬁned in yml ﬁles.
<module>.services.yml

core.services.yml
path.alias_whitelist:
class: DrupalCorePathAliasWhitelist
tags:
- { name: needs_destruction }
arguments: [path_alias_whitelist, '@cache.bootstrap', '@lock', '@state',
'@path.alias_storage']
path.alias_manager:
class: DrupalCorePathAliasManager
arguments: ['@path.alias_storage', '@path.alias_whitelist', '@language_manager',
'@cache.data']
path.current:
class: DrupalCorePathCurrentPathStack
arguments: ['@request_stack']

/** 
* The default alias manager implementation. 
*/ 
class AliasManager implements AliasManagerInterface, CacheDecoratorInterface
{ 
 
/** 
  * Constructs an AliasManager. 
  * 
  * @param DrupalCorePathAliasStorageInterface $storage 
  *   The alias storage service. 
  * @param DrupalCorePathAliasWhitelistInterface $whitelist 
  *   The whitelist implementation to use. 
  * @param DrupalCoreLanguageLanguageManagerInterface $language_manager 
  *   The language manager. 
  * @param DrupalCoreCacheCacheBackendInterface $cache 
  *   Cache backend. 
  */ 
public function __construct(AliasStorageInterface $storage,
AliasWhitelistInterface $whitelist, LanguageManagerInterface
$language_manager, CacheBackendInterface $cache) { 
   $this->storage = $storage; 
   $this->languageManager = $language_manager; 
   $this->whitelist = $whitelist; 
   $this->cache = $cache; 
}

path.alias_manager:
class:
DrupalCorePathAliasManager
arguments: [ 
'@path.alias_storage',
 
'@path.alias_whitelist',  
 
'@language_manager',  
 
'@cache.data' 
 
]
public function __construct(
AliasStorageInterface $storage,
AliasWhitelistInterface $whitelist,
LanguageManagerInterface
$language_manager,
CacheBackendInterface $cache
) {

Service Argument
Types.
'@config.factory' == Another service.
'%container.modules%' == A configuration item.
'config' or true == A variable.

/** 
* The default alias manager implementation. 
*/ 
class AliasManager implements AliasManagerInterface,
CacheDecoratorInterface { 
 
/** 
  * Constructs an AliasManager. 
  * 
  * @param DrupalCorePathAliasStorageInterface $storage 
  *   The alias storage service. 
  * @param DrupalCorePathAliasWhitelistInterface $whitelist 
  *   The whitelist implementation to use. 
  * @param DrupalCoreLanguageLanguageManagerInterface
$language_manager 
  *   The language manager. 
  * @param DrupalCoreCacheCacheBackendInterface $cache 
  *   Cache backend. 
  */ 
public function __construct(AliasStorageInterface $storage,
AliasWhitelistInterface $whitelist, LanguageManagerInterface
$language_manager, CacheBackendInterface $cache) { 
   $this->storage = $storage; 
   $this->languageManager = $language_manager; 
   $this->whitelist = $whitelist; 
   $this->cache = $cache; 
}

• Instantiate the object you want without having to
worry about dependencies.
• Symfony DependencyInjection Component
manages these dependencies.

path.alias_manager 
Without Using

use DrupalCorePathAliasManager;
$pathManager = new AliasManager($storage, $whitelist,
$language_manager, $cache);

use DrupalCoreAliasStorage;
$storage = new AliasStorage($database, $moduleHandler);
$languageManager, $cache);

use DrupalCoreDatabaseDatabase;
use DrupalCoreExtensionModuleHandler;
$database = Database::getConnection();
$moduleHandler = new ModuleHandler($root, $moduleList,
$cacheBackend);

use DrupalCoreCacheCacheBackendInterface;
use DrupalCoreAppRootFactory;
use DrupalCoreCacheDatabaseBackend;
$root = new AppRootFactory($drupalKernel);
$moduleList = Drupal::getContainer()
->getParameter('container.modules');
$cacheBackend = new DatabaseBackend($connection,
$checksumProvider, $bin);
$cacheBackend);

use DrupalCoreCacheCacheBackendInterface;
use DrupalCoreAppRootFactory;
use DrupalCoreCacheDatabaseBackend;
$drupalKernel = ???
$connection = $database;
$checksumProvider = ???
$bin = ???
$root = new AppRootFactory($drupalKernel);
$moduleList = Drupal::getContainer()
->getParameter('container.modules');
$cacheBackend = new DatabaseBackend($connection,
$checksumProvider, $bin);
$cacheBackend);

Dependency Injection
Interface.
• Controllers and Forms implement the interface:
DrupalCoreDependencyInjection 
ContainerInjectionInterface
• Which means they can be injected with Drupal
services.
• A static create() method deﬁnes the services you
need in the controller or form.

class ExampleController extends ControllerBase {
protected $configFactory;
protected $pathAliasManager;
public static function create(ContainerInterface $container) {
return new static(
$container->get('config.factory'),
$container->get('path.alias_manager')
);
}
public function __construct(ConfigFactoryInterface
$configFactory, AliasManager $pathAliasManager) {
$this->configFactory = $configFactory;
$this->pathAliasManager = $pathAliasManager;
}
}

public function someAction() {
...
...
}

public function someAction() {
...
$normalPath = $this->pathAliasManager
...
}

Quick Recap.
• Services and their dependencies are deﬁned in
*.services.yml ﬁles.
• Dependency injection makes life easier.
• Controllers and Forms can have dependencies
injected into them.
• So how do we build our own?

Create a services
deﬁnition ﬁle.

services:
<service name>:
class: Drupal<full namespace of class>
arguments: ['@config.factory', ...]

my_module.services.yml
services:
my_module.myservice:
class: Drupalmy_moduleServiceNameModuleService
arguments: ['@config.factory']

Create Service Interface.
namespace Drupalmy_moduleServiceName;
use DrupalCoreConfigConfigFactoryInterface;
interface ModuleServiceInterface {
public function doSomething();
}

Create Service Class.
namespace Drupalmy_moduleServiceName;
class ModuleService implements ModuleServiceInterface {
protected $moduleConfigThing;
$config_factory) {
$this->moduleConfigThing = $config_factory
->get('module.config')
->get('config_thing');
}
public function doSomething() {
}
}

Start Using It.
Drupal::service('my_module.myservice')->doSomething();

PCA Predict.
A real example of Drupal services in action

PCA Predict Module.
• Used for address matching and auto complete in
forms.
• Integrate with PCA Predict web services.
• Drupal service created to wrap the web service.

pcapredict.services.yml
services:
pcapredict:
class: Drupalpcapredict_integrationPcaPredictPcaPredict
arguments: ['@config.factory']

namespace Drupalpcapredict_integrationPcaPredict;
use Drupalpcapredict_integrationPcaPredictPcaPredictInterface;
interface PcaPredictInterface {
public function find(array $values, $type = ‘json');
public function retrieve(array $values, $type = ‘json');
}

class PcaPredict implements PcaPredictInterface {
protected $pcaPredictKey;
$config_factory) {
$this->pcaPredictKey = $config_factory
->get('pcapredict.settings')
->get('pcapredict_apikey');
}
public function find(array $values, $type = 'json') {
// Load data from the API.
}
public function retrieve(array $values, $type = 'json') {
}
}

class PcaPredict implements PcaPredictInterface {
$config_factory) {
}
}
}
}
Implements our
interface
Store the
API key
in a
property

$results = Drupal::service('pcapredict')
->find(['postcode' => 'M32 0RS']);

Altering Services.
• All services can be overridden or altered.
• A service provider class allows this.
• These are automatically detected by Drupal.
• Camel case version of the module name. Sufﬁxed
by the words “ServiceProvider” in the src directory.
• Some examples of this in action.

Problem:
Shield module prevents
testing of API service on
staging website.
Solution:
Poke a hole in the shield!

Module shield_override.
• Convert module name to camel case.
• shield_override becomes ShieldOverride.
• Sufﬁxed by the words “ServiceProvider”. 
 
ShieldOverrideServiceProvider

Module shield_override.
shield_override.info.yml
src/ShieldOverrideServiceProvider.php
src/ShieldOverride.php

namespace Drupalshield_override;
use DrupalCoreDependencyInjectionContainerBuilder;
use DrupalCoreDependencyInjectionServiceProviderBase;
class ShieldOverrideServiceProvider extends ServiceProviderBase {
public function alter(ContainerBuilder $container) {
// Decorate the shield module to prevent it from
// triggering on certain routes.
$definition = $container->getDefinition('shield.middleware');
$definition->setClass('Drupalshield_overrideShieldOverride');
}
}
ShieldOverrideServiceProvider.php

use DrupalshieldShieldMiddleware;
use SymfonyComponentHttpFoundationRequest;
class ShieldOverride extends ShieldMiddleware {
public function handle(Request $request, $type =
self::MASTER_REQUEST, $catch = TRUE) {
// Get the current request URI.
$currentPath = $request->getRequestUri();
// Get the current method (e.g. GET or POST).
$currentMethod = $request->getMethod();
if (($currentMethod == 'POST' || $currentMethod == 'GET')
&& strstr($currentPath, '/the/soap/service/path') !== FALSE) {
// If we are attempting to access the soap service via
// a POST or GET HTTP method then handle the request
// without invoking the Shield module.
return $this->httpKernel->handle($request, $type, $catch);
}
// Always handle the request using the default
// Shield behaviour.
return parent::handle($request, $type, $catch);
}
}

use DrupalshieldShieldMiddleware;
use SymfonyComponentHttpFoundationRequest;
class ShieldOverride extends ShieldMiddleware {
public function handle(Request $request, $type =
self::MASTER_REQUEST, $catch = TRUE) {
$currentPath = $request->getRequestUri();
if (($currentMethod == 'POST' || $currentMethod == 'GET')
&& strstr($currentPath, '/the/soap/service/path') !== FALSE) {
// If we are attempting to access the soap service via
// a POST or GET HTTP method then handle the request
// without invoking the Shield module.
return $this->httpKernel->handle($request, $type, $catch);
}
// Always handle the request using the default
// Shield behaviour.
return parent::handle($request, $type, $catch);
}
}
Extends the original
Shield module class
Runs the original
Shield code.

Problem:
Testing PCA Predict needs an
API account and costs money
per transaction.
Solution:
Create a ‘stub’ service override
that doesn’t use the API.

Module pcapredict_stub.
• Convert module name to camel case.
• pcapredict_stub becomes PcapredictStub.
• Sufﬁxed by the words “ServiceProvider”. 
 
PcapredictStubServiceProvider

PCA Predict Stub
Module.
pcapredict_stub.info.yml
src/PcapredictStubServiceProvider.php
src/PcaPredict/PcaPredictStub.php

namespace Drupalpcapredict_stub;
class PcapredictStubServiceProvider extends ServiceProviderBase {
// Override the PcaPredict class with a new class.
$definition = $container->getDefinition('pcapredict');
$definition->setClass('Drupalpcapredict_stubPcaPredictPcaPredictStub');
}
}
PcapredictStubServiceProvider.php

namespace Drupalpcapredict_stubPcaPredict;
use DrupalpcapredictPcaPredictPcaPredictInterface;
class PcaPredictStub implements PcaPredictInterface {
public function __construct(ConfigFactoryInterface $config_factory) {
}
// Load data from a CSV file.
}
}
}

namespace Drupalpcapredict_stubPcaPredict;
use DrupalpcapredictPcaPredictPcaPredictInterface;
class PcaPredictStub implements PcaPredictInterface {
public function __construct(ConfigFactoryInterface $config_factory) {
}
}
}
}
Implements
PcaPredictInterface

ﬁnd() /
retrieve()API
Address
ﬁnder

ﬁnd() /
retrieve()
Address
ﬁnder

Stub Modules.
• Stub modules are useful for:
• Prevent analytics being sent.
• Bypass complex setups / ﬁrewalls.
• Testing without using the API.

Problem:
Filtering a AJAX View with
Group context results in
access error.
Solution:
Create our own access rule.

Group View.
• Group module used to manage members.
• Created a View to show all group members and
some information about them.
• Added AJAX filters to allow the user list to be
filtered.
• Group context was loaded into the View using a
contextual filter and the path:  
/account/%group/members

https://www.example.com/account/123/members

https://www.example.com/account/123/members
https://www.example.com/views/ajax?_wrapper_format=drupal_ajax
(+ POST data)

namespace DrupalgroupContext;
use DrupalCoreCacheCacheableMetadata;
use DrupalCorePluginContextContext;
use DrupalCorePluginContextContextDefinition;
use DrupalCorePluginContextContextProviderInterface;
use DrupalCoreRoutingRouteMatchInterface;
use DrupalCoreStringTranslationStringTranslationTrait;
/**
* Sets the current group as a context on group routes.
*/
class GroupRouteContext implements ContextProviderInterface {
use GroupRouteContextTrait;
// ... snip ...
/**
* {@inheritdoc}
*/
public function getRuntimeContexts(array $unqualified_context_ids) {
// Create an optional context definition for group entities.
$context_definition = new ContextDefinition('entity:group', NULL, FALSE);
// Cache this context on the route.
$cacheability = new CacheableMetadata();
$cacheability->setCacheContexts(['route']);
// Create a context from the definition and retrieved or created group.
$context = new Context($context_definition, $this->getGroupFromRoute());
$context->addCacheableDependency($cacheability);
return ['group' => $context];
}
// ... snip ...
}

namespace DrupalgroupContext;
use DrupalCorePluginContextContextProviderInterface;
use DrupalCoreRoutingRouteMatchInterface;
use DrupalCoreStringTranslationStringTranslationTrait;
/**
* Sets the current group as a context on group routes.
*/
class GroupRouteContext implements ContextProviderInterface {
use GroupRouteContextTrait;
// ... snip ...
/**
* {@inheritdoc}
*/
// Create an optional context definition for group entities.
$context = new Context($context_definition, $this->getGroupFromRoute());
}
// ... snip ...
}
No Group in route
when in AJAX mode

group.services.yml
group.group_route_context: 
class: 'DrupalgroupContextGroupRouteContext' 
arguments: ['@current_route_match'] 
tags: 
- { name: 'context_provider' }

GroupViewsServiceProvider.php
namespace Drupalgroup_views;
class GroupViewsServiceProvider extends ServiceProviderBase {
// Decorate the group_route_context service to inject our own objects on
// certain routes.
$definition = $container->getDefinition('group.group_route_context');
$definition->setClass('Drupalgroup_subscriptionsGroupViewsAccessOverride');
}
}

use DrupalgroupContextGroupRouteContext;
class GroupViewsAccessOverride extends GroupRouteContext {
$request = Drupal::request();
$currentPathInfo = $request->getPathInfo();
// Extract the parameters out of the post arguments.
parse_str($request->getContent(), $postArgs);
if ($currentMethod == 'POST'
&& $currentPathInfo == '/views/ajax'
&& isset($postArgs['view_name'])
&& isset($postArgs['view_args'])
&& isset($postArgs['_drupal_ajax'])
&& $postArgs['view_name'] == 'group_members'
&& is_numeric($postArgs['view_args'])
&& $postArgs['_drupal_ajax'] == '1'
) {
// This is our view.
$groupEntity = Drupal::service('entity_type.manager')->getStorage('group')->load($postArgs['view_args']);
if ($groupEntity) {
// We have loaded a group.
$context = new Context($context_definition, $groupEntity);
}
}
// Always handle the request using the default GroupRouteContext behaviour.
return parent::getRuntimeContexts($unqualified_context_ids);
}
}

use DrupalgroupContextGroupRouteContext;
class GroupViewsAccessOverride extends GroupRouteContext {
$request = Drupal::request();
$currentPathInfo = $request->getPathInfo();
// Extract the parameters out of the post arguments.
parse_str($request->getContent(), $postArgs);
if ($currentMethod == 'POST'
&& $currentPathInfo == '/views/ajax'
&& isset($postArgs['view_name'])
&& isset($postArgs['view_args'])
&& isset($postArgs['_drupal_ajax'])
&& $postArgs['view_name'] == 'group_members'
&& is_numeric($postArgs['view_args'])
&& $postArgs['_drupal_ajax'] == '1'
) {
// This is our view.
$groupEntity = Drupal::service('entity_type.manager')->getStorage('group')->load($postArgs['view_args']);
if ($groupEntity) {
// We have loaded a group.
$context = new Context($context_definition, $groupEntity);
}
}
// Always handle the request using the default GroupRouteContext behaviour.
return parent::getRuntimeContexts($unqualified_context_ids);
}
}
Extends the original
Group module class
Checking to ensure
that this is the
correct context.
Continue on as
normal.
Load Group object
and add it to a
context.

Resources.
• Services and Dependency Injection Container 
https://api.drupal.org/api/drupal/core!core.api.php/
group/container/
• List of all services 
https://api.drupal.org/api/drupal/services
• Services And Dependency Injection 
https://www.drupal.org/docs/8/api/services-and-
dependency-injection

Drupal 8 Services And Dependency Injection

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Drupal 8 Services And Dependency Injection

Similar to Drupal 8 Services And Dependency Injection (20)

More from Philip Norton

More from Philip Norton (12)

Recently uploaded

Recently uploaded (20)

Drupal 8 Services And Dependency Injection