Dependency Injection
&
Services
in
Drupal 8
GOAL
Understand the driving concepts and reasons for using Dependency Injection
Understand the pattern and its usages in Drupal 8 specifically, via the Service Container and specific methods
implements
INVERSION
OF CONTROL
DEPENDENCY INJECTION
is a
DESIGN
PATTERN
enables
LOOSE
COUPLING
DESIGN PATTERN
Reusable solution for common software design problems.
Examples:
- Singleton
- Dependency Injection
- many many others
LOOSE COUPLING
Less
interconnection
Less
knowledge about each other
Less
coordination
is a PRINCIPLE,
which offers
Example of tight coupling
Example of tight coupling
Example of less tight coupling
What happens if SMS notification is needed?
Example of tight coupling
Example of less tight coupling
Loose Coupling
Who is responsible for instantiating the Notifier class?
Custom Code
- our custom code is responsible for instantiating the Notifier
class and its dependencies - our custom code is responsible for the control of the flow
Framework
- control is passed to a framework, which is designed to discover our implementations
- it is also responsible to instantiate and inject the dependencies for our implementations
VS.
Inversion of Control
-
describes a design in which a re-usable library calls the custom code and not the other way around
- control is passed to a framework, which is designed to discover our implementations
- it is also responsible to instantiate and inject the dependencies for our implementations
Inversion of Control
Inversion of Control
in Drupal
Drupal 7
The hook system
Drupal 8
- Dependency Injection
-
Event Listener/
Observer pattern
Short Recap
implements
INVERSION
OF CONTROL
DEPENDENCY INJECTION
is a
DESIGN
PATTERN
enables
LOOSE
COUPLING
3 types of Dependency Injection
- Constructor injection
- Setter injection
- Interface injection
Constructor injection
Setter Injection
Interface Injection
In real life applications
Dependency injection involves four roles:
- the service object(s) to be used (e.g. Email, Sms classes)
- the client object that is depending on the services it uses (e.g. Notifier class)
- the interfaces that define how the client may use the services (e.g. Notification interface)
- the injector, which is responsible for constructing the services and injecting them into the client (a service container of a Framework, in our case the Drupal 8 service container)
Conclusion
"When you go and get things out of the refrigerator for yourself, you can cause problems. You might leave the door open, you might get something Mommy or Daddy doesn't want you to have. You might even be looking for something we don't even have or which has expired.
What you should be doing is stating a need, "I need something to drink with lunch," and then we will make sure you have something when you sit down to eat."
John Munsch, 28 October 2009.
Questions so far?
DI In Drupal 8
D8 Service Container
public static function create()
The Service Container:
Why and what?
Drupal 7
- Inversion of Control exists
- Loose Coupling is lacking
- Too much interdependency when writing custom modules
Drupal 8
- defines the term "service"
which is reusable functionality - defines its services in configuration
- uses the Service Container to use a defined service
What is a Service?
What is a Service?
- one of the four roles in the Dependency Injection pattern
- in Drupal 8 it's used to decouple reusable functionality and makes these services pluggable and replaceable by registering them with a service container
Service configuration example
services:
http_kernel:
class: Stack\StackedHttpKernel
http_kernel.basic:
class: Symfony\Component\HttpKernel\HttpKernel
arguments: ['@event_dispatcher', '@controller_resolver', '@request_stack']
What is a Service Container?
What is a Service Container?
- it is an array of definitions specified in .services.yml configuration files
- Drupal 8 compiles the definitions in these files into a single object that contains all the service definitions
The service container
Who is responsible for instantiating our services?
public static function create()
- ContainerInjectionInterface
- ContainerFactoryPluginInterface
- ContainerDeriverInterface
Dependency Injection Example in a
Custom Controller
Example
services:
module_name.notifier:
class: Drupal\module_name\Notifier
arguments: ['']
Example
Container::get
Creates an instance of the service with all the necessary dependencies by calling the Container::createService method.
How does it work?
Execution flow in our example
public function getInstanceFromDefinition($definition) {
if ($this->container->has($definition)) {
$instance = $this->container->get($definition);
}
else {
if (!class_exists($definition)) {
throw new \InvalidArgumentException(sprintf('Class "%s" does not exist.', $definition));
}
if (is_subclass_of($definition, 'Drupal\Core\DependencyInjection\ContainerInjectionInterface')) {
$instance = $definition::create($this->container);
}
else {
$instance = new $definition();
}
}
if ($instance instanceof ContainerAwareInterface) {
$instance->setContainer($this->container);
}
return $instance;
}Questions?
Bibliography
Thanks!
Services and Dependency Injection
By benelori
