The DependencyInjection Component
Edit this pageWarning: You are browsing the documentation for Symfony 3.1, which is no longer maintained.
Read the updated version of this page for Symfony 6.3 (the current stable version).
The DependencyInjection Component
The DependencyInjection component allows you to standardize and centralize the way objects are constructed in your application.
For an introduction to Dependency Injection and service containers see Service Container.
Installation
You can install the component in 2 different ways:
- Install it via Composer (
symfony/dependency-injection
on Packagist); - Use the official Git repository (https://github.com/symfony/dependency-injection).
Then, require the vendor/autoload.php
file to enable the autoloading mechanism
provided by Composer. Otherwise, your application won't be able to find the classes
of this Symfony component.
Basic Usage
You might have a simple class like the following Mailer
that
you want to make available as a service:
1 2 3 4 5 6 7 8 9 10 11
class Mailer
{
private $transport;
public function __construct()
{
$this->transport = 'sendmail';
}
// ...
}
You can register this in the container as a service:
1 2 3 4
use Symfony\Component\DependencyInjection\ContainerBuilder;
$container = new ContainerBuilder();
$container->register('mailer', 'Mailer');
An improvement to the class to make it more flexible would be to allow
the container to set the transport
used. If you change the class
so this is passed into the constructor:
1 2 3 4 5 6 7 8 9 10 11
class Mailer
{
private $transport;
public function __construct($transport)
{
$this->transport = $transport;
}
// ...
}
Then you can set the choice of transport in the container:
1 2 3 4 5 6
use Symfony\Component\DependencyInjection\ContainerBuilder;
$container = new ContainerBuilder();
$container
->register('mailer', 'Mailer')
->addArgument('sendmail');
This class is now much more flexible as you have separated the choice of transport out of the implementation and into the container.
Which mail transport you have chosen may be something other services need
to know about. You can avoid having to change it in multiple places by making
it a parameter in the container and then referring to this parameter for
the Mailer
service's constructor argument:
1 2 3 4 5 6 7
use Symfony\Component\DependencyInjection\ContainerBuilder;
$container = new ContainerBuilder();
$container->setParameter('mailer.transport', 'sendmail');
$container
->register('mailer', 'Mailer')
->addArgument('%mailer.transport%');
Now that the mailer
service is in the container you can inject it as
a dependency of other classes. If you have a NewsletterManager
class
like this:
1 2 3 4 5 6 7 8 9 10 11
class NewsletterManager
{
private $mailer;
public function __construct(\Mailer $mailer)
{
$this->mailer = $mailer;
}
// ...
}
When defining the newsletter_manager
service, the mailer
service does
not exist yet. Use the Reference
class to tell the container to inject the
mailer
service when it initializes the newsletter manager:
1 2 3 4 5 6 7 8 9 10 11 12 13
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Reference;
$container = new ContainerBuilder();
$container->setParameter('mailer.transport', 'sendmail');
$container
->register('mailer', 'Mailer')
->addArgument('%mailer.transport%');
$container
->register('newsletter_manager', 'NewsletterManager')
->addArgument(new Reference('mailer'));
If the NewsletterManager
did not require the Mailer
and injecting
it was only optional then you could use setter injection instead:
1 2 3 4 5 6 7 8 9 10 11
class NewsletterManager
{
private $mailer;
public function setMailer(\Mailer $mailer)
{
$this->mailer = $mailer;
}
// ...
}
You can now choose not to inject a Mailer
into the NewsletterManager
.
If you do want to though then the container can call the setter method:
1 2 3 4 5 6 7 8 9 10 11 12 13
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Reference;
$container = new ContainerBuilder();
$container->setParameter('mailer.transport', 'sendmail');
$container
->register('mailer', 'Mailer')
->addArgument('%mailer.transport%');
$container
->register('newsletter_manager', 'NewsletterManager')
->addMethodCall('setMailer', array(new Reference('mailer')));
You could then get your newsletter_manager
service from the container
like this:
1 2 3 4 5 6 7
use Symfony\Component\DependencyInjection\ContainerBuilder;
$container = new ContainerBuilder();
// ...
$newsletterManager = $container->get('newsletter_manager');
Avoiding your Code Becoming Dependent on the Container
Whilst you can retrieve services from the container directly it is best
to minimize this. For example, in the NewsletterManager
you injected
the mailer
service in rather than asking for it from the container.
You could have injected the container in and retrieved the mailer
service
from it but it would then be tied to this particular container making it
difficult to reuse the class elsewhere.
You will need to get a service from the container at some point but this should be as few times as possible at the entry point to your application.
Setting up the Container with Configuration Files
As well as setting up the services using PHP as above you can also use configuration files. This allows you to use XML or YAML to write the definitions for the services rather than using PHP to define the services as in the above examples. In anything but the smallest applications it makes sense to organize the service definitions by moving them into one or more configuration files. To do this you also need to install the Config component.
Loading an XML config file:
1 2 3 4 5 6 7
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
$container = new ContainerBuilder();
$loader = new XmlFileLoader($container, new FileLocator(__DIR__));
$loader->load('services.xml');
Loading a YAML config file:
1 2 3 4 5 6 7
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;
$container = new ContainerBuilder();
$loader = new YamlFileLoader($container, new FileLocator(__DIR__));
$loader->load('services.yml');
Note
If you want to load YAML config files then you will also need to install the Yaml component.
If you do want to use PHP to create the services then you can move this into a separate config file and load it in a similar way:
1 2 3 4 5 6 7
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\Loader\PhpFileLoader;
$container = new ContainerBuilder();
$loader = new PhpFileLoader($container, new FileLocator(__DIR__));
$loader->load('services.php');
You can now set up the newsletter_manager
and mailer
services using
config files:
1 2 3 4 5 6 7 8 9 10 11 12
parameters:
# ...
mailer.transport: sendmail
services:
mailer:
class: Mailer
arguments: ['%mailer.transport%']
newsletter_manager:
class: NewsletterManager
calls:
- [setMailer, ['@mailer']]
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd">
<parameters>
<!-- ... -->
<parameter key="mailer.transport">sendmail</parameter>
</parameters>
<services>
<service id="mailer" class="Mailer">
<argument>%mailer.transport%</argument>
</service>
<service id="newsletter_manager" class="NewsletterManager">
<call method="setMailer">
<argument type="service" id="mailer" />
</call>
</service>
</services>
</container>
1 2 3 4 5 6 7 8 9 10 11
use Symfony\Component\DependencyInjection\Reference;
// ...
$container->setParameter('mailer.transport', 'sendmail');
$container
->register('mailer', 'Mailer')
->addArgument('%mailer.transport%');
$container
->register('newsletter_manager', 'NewsletterManager')
->addMethodCall('setMailer', array(new Reference('mailer')));
Learn More
- Defining Services Dependencies Automatically (Autowiring)
- Compiling the Container
- Container Building Workflow
- How to Create Service Aliases and Mark Services as Private
- How to Work with Compiler Passes in Bundles
- How to Configure a Service with a Configurator
- How to Debug the Service Container & List Services
- How to work with Service Definition Objects
- How to Inject Values Based on Complex Expressions
- Using a Factory to Create Services
- How to Import Configuration Files/Resources
- Types of Injection
- Lazy Services
- How to Make Service Arguments/References Optional
- Introduction to Parameters
- How to Manage Common Dependencies with Parent Services
- How to Retrieve the Request from the Service Container
- How to Decorate Services
- How to Define Non Shared Services
- How to Inject Instances into the Container
- How to Work with Service Tags
- How to Work with Services Provided by Third-Party Bundles