Fetching and using Services

The moment you start a Symfony app, your container already contains many services. These are like tools: waiting for you to take advantage of them. In your controller, you can "ask" for a service from the container by type-hinting an argument with the service's class or interface name. Want to log something? No problem:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// src/Controller/ProductController.php
// ...

use Psr\Log\LoggerInterface;

/**
 * @Route("/products")
 */
public function list(LoggerInterface $logger)
{
    $logger->info('Look! I just used a service');

    // ...
}

What other services are available? Find out by running:

1
2
3
4
5
6
7
8
9
10
11
12
13

$ php bin/console debug:autowiring

# this is just a *small* sample of the output...
=============================================================== =====================================
Class/Interface Type                                            Alias Service ID
=============================================================== =====================================
``Psr\Cache\CacheItemPoolInterface``                            alias for "cache.app.recorder"
``Psr\Log\LoggerInterface``                                     alias for "monolog.logger"
``Symfony\Component\EventDispatcher\EventDispatcherInterface``  alias for "debug.event_dispatcher"
``Symfony\Component\HttpFoundation\RequestStack``               alias for "request_stack"
``Symfony\Component\HttpFoundation\Session\SessionInterface``   alias for "session"
``Symfony\Component\Routing\RouterInterface``                   alias for "router.default"
=============================================================== =====================================

When you use these type-hints in your controller methods or inside your own services, Symfony will automatically pass you the service object matching that type.

Throughout the docs, you'll see how to use the many different services that live in the container.

Creating/Configuring Services in the Container

You can also organize your own code into services. For example, suppose you need to show your users a random, happy message. If you put this code in your controller, it can't be re-used. Instead, you decide to create a new class:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// src/Service/MessageGenerator.php
namespace App\Service;

class MessageGenerator
{
    public function getHappyMessage()
    {
        $messages = [
            'You did it! You updated the system! Amazing!',
            'That was one of the coolest updates I\'ve seen all day!',
            'Great work! Keep going!',
        ];

        $index = array_rand($messages);

        return $messages[$index];
    }
}

Congratulations! You've just created your first service class! You can use it immediately inside your controller:

1
2
3
4
5
6
7
8
9
10
11
12

use App\Service\MessageGenerator;

public function new(MessageGenerator $messageGenerator)
{
    // thanks to the type-hint, the container will instantiate a
    // new MessageGenerator and pass it to you!
    // ...

    $message = $messageGenerator->getHappyMessage();
    $this->addFlash('success', $message);
    // ...
}

When you ask for the MessageGenerator service, the container constructs a new MessageGenerator object and returns it (see sidebar below). But if you never ask for the service, it's never constructed: saving memory and speed. As a bonus, the MessageGenerator service is only created once: the same instance is returned each time you ask for it.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# config/services.yaml
services:
    # default configuration for services in *this* file
    _defaults:
        autowire: true      # Automatically injects dependencies in your services.
        autoconfigure: true # Automatically registers your services as commands, event subscribers, etc.
        public: false       # Allows optimizing the container by removing unused services; this also means
                            # fetching services directly from the container via $container->get() won't work.
                            # The best practice is to be explicit about your dependencies anyway.

    # makes classes in src/ available to be used as services
    # this creates a service per class whose id is the fully-qualified class name
    App\:
        resource: '../src/*'
        exclude: '../src/{Entity,Migrations,Tests,Kernel.php}'

    # ...

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<!-- config/services.xml -->
<?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">

    <services>
        <!-- Default configuration for services in *this* file -->
        <defaults autowire="true" autoconfigure="true" public="false" />

        <prototype namespace="App\" resource="../src/*" exclude="../src/{Entity,Migrations,Tests}" />
    </services>
</container>

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// config/services.php
use Symfony\Component\DependencyInjection\Definition;

// To use as default template
$definition = new Definition();

$definition
    ->setAutowired(true)
    ->setAutoconfigured(true)
    ->setPublic(false)
;

// $this is a reference to the current loader
$this->registerClasses($definition, 'App\\', '../src/*', '../src/{Entity,Migrations,Tests}');

Injecting Services/Config into a Service

What if you need to access the logger service from within MessageGenerator? No problem! Create a __construct() method with a $logger argument that has the LoggerInterface type-hint. Set this on a new $logger property and use it later:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// src/Service/MessageGenerator.php
// ...

use Psr\Log\LoggerInterface;

class MessageGenerator
{
    private $logger;

    public function __construct(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }

    public function getHappyMessage()
    {
        $this->logger->info('About to find a happy message!');
        // ...
    }
}

That's it! The container will automatically know to pass the logger service when instantiating the MessageGenerator. How does it know to do this? Autowiring. The key is the LoggerInterface type-hint in your __construct() method and the autowire: true config in services.yaml. When you type-hint an argument, the container will automatically find the matching service. If it can't, you'll see a clear exception with a helpful suggestion.

By the way, this method of adding dependencies to your __construct() method is called dependency injection. It's a scary term for a simple concept.

How should you know to use LoggerInterface for the type-hint? You can either read the docs for whatever feature you're using, or get a list of autowireable type-hints by running:

1

$ php bin/console debug:autowiring

This command is your best friend. This is a small subset of the output:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// src/Updates/SiteUpdateManager.php
namespace App\Updates;

use App\Service\MessageGenerator;

class SiteUpdateManager
{
    private $messageGenerator;
    private $mailer;

    public function __construct(MessageGenerator $messageGenerator, \Swift_Mailer $mailer)
    {
        $this->messageGenerator = $messageGenerator;
        $this->mailer = $mailer;
    }

    public function notifyOfSiteUpdate()
    {
        $happyMessage = $this->messageGenerator->getHappyMessage();

        $message = (new \Swift_Message('Site update just happened!'))
            ->setFrom('admin@example.com')
            ->setTo('manager@example.com')
            ->addPart(
                'Someone just updated the site. We told them: '.$happyMessage
            );

        return $this->mailer->send($message) > 0;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// src/Controller/SiteController.php

// ...
use App\Updates\SiteUpdateManager;

public function new(SiteUpdateManager $siteUpdateManager)
{
    // ...

    if ($siteUpdateManager->notifyOfSiteUpdate()) {
        $this->addFlash('success', 'Notification mail was sent successfully.');
    }

    // ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// src/Updates/SiteUpdateManager.php
// ...

class SiteUpdateManager
{
    // ...
+    private $adminEmail;

-    public function __construct(MessageGenerator $messageGenerator, \Swift_Mailer $mailer)
+    public function __construct(MessageGenerator $messageGenerator, \Swift_Mailer $mailer, $adminEmail)
    {
        // ...
+        $this->adminEmail = $adminEmail;
    }

    public function notifyOfSiteUpdate()
    {
        // ...

        $message = \Swift_Message::newInstance()
            // ...
-            ->setTo('manager@example.com')
+            ->setTo($this->adminEmail)
            // ...
        ;
        // ...
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

# config/services.yaml
services:
    # ...

    # same as before
    App\:
        resource: '../src/*'
        exclude: '../src/{Entity,Migrations,Tests}'

    # explicitly configure the service
    App\Updates\SiteUpdateManager:
        arguments:
            $adminEmail: 'manager@example.com'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<!-- config/services.xml -->
<?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">

    <services>
        <!-- ... -->

        <!-- Same as before -->
        <prototype namespace="App\" resource="../src/*" exclude="../src/{Entity,Migrations,Tests}" />

        <!-- Explicitly configure the service -->
        <service id="App\Updates\SiteUpdateManager">
            <argument key="$adminEmail">manager@example.com</argument>
        </service>
    </services>
</container>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// config/services.php
use App\Updates\SiteUpdateManager;
use Symfony\Component\DependencyInjection\Definition;

// Same as before
$definition = new Definition();

$definition
    ->setAutowired(true)
    ->setAutoconfigured(true)
    ->setPublic(false)
;

$this->registerClasses($definition, 'App\\', '../src/*', '../src/{Entity,Migrations,Tests}');

// Explicitly configure the service
$container->getDefinition(SiteUpdateManager::class)
    ->setArgument('$adminEmail', 'manager@example.com');

Service Parameters

In addition to holding service objects, the container also holds configuration, called parameters. To create a parameter, add it under the parameters key and reference it with the %parameter_name% syntax:

1
2
3
4
5
6
7
8
9
10

# config/services.yaml
parameters:
    admin_email: manager@example.com

services:
    # ...

    App\Updates\SiteUpdateManager:
        arguments:
            $adminEmail: '%admin_email%'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<!-- config/services.xml -->
<?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="admin_email">manager@example.com</parameter>
    </parameters>

    <services>
        <!-- ... -->

        <service id="App\Updates\SiteUpdateManager">
            <argument key="$adminEmail">%admin_email%</argument>
        </service>
    </services>
</container>

1
2
3
4
5
6
7

// config/services.php
use App\Updates\SiteUpdateManager;
$container->setParameter('admin_email', 'manager@example.com');

$container->autowire(SiteUpdateManager::class)
    // ...
    ->setArgument('$adminEmail', '%admin_email%');

Actually, once you define a parameter, it can be referenced via the %parameter_name% syntax in any other configuration file. Many parameters are defined in the config/services.yaml file.

You can then fetch the parameter in the service:

1
2
3
4
5
6
7
8
9
10
11

class SiteUpdateManager
{
    // ...

    private $adminEmail;

    public function __construct($adminEmail)
    {
        $this->adminEmail = $adminEmail;
    }
}

You can also fetch parameters directly from the container:

1
2
3
4
5
6
7
8
9
10

public function new()
{
    // ...

    // this ONLY works if you extend the base Controller
    $adminEmail = $this->container->getParameter('admin_email');

    // or a shorter way!
    // $adminEmail = $this->getParameter('admin_email');
}

For more info about parameters, see Introduction to Parameters.

Choose a Specific Service

The MessageGenerator service created earlier requires a LoggerInterface argument:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// src/Service/MessageGenerator.php
// ...

use Psr\Log\LoggerInterface;

class MessageGenerator
{
    private $logger;

    public function __construct(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }
    // ...
}

However, there are multiple services in the container that implement LoggerInterface, such as logger, monolog.logger.request, monolog.logger.php, etc. How does the container know which one to use?

In these situations, the container is usually configured to automatically choose one of the services - logger in this case (read more about why in Defining Services Dependencies Automatically (Autowiring)). But, you can control this and pass in a different logger:

1
2
3
4
5
6
7
8

# config/services.yaml
services:
    # ... same code as before

    # explicitly configure the service
    App\Service\MessageGenerator:
        arguments:
            $logger: '@monolog.logger.request'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<!-- config/services.xml -->
<?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">

    <services>
        <!-- ... same code as before -->

        <!-- Explicitly configure the service -->
        <service id="App\Service\MessageGenerator">
            <argument key="$logger" type="service" id="monolog.logger.request" />
        </service>
    </services>
</container>

1
2
3
4
5
6
7
8

// config/services.php
use App\Service\MessageGenerator;
use Symfony\Component\DependencyInjection\Reference;

$container->autowire(MessageGenerator::class)
    ->setAutoconfigured(true)
    ->setPublic(false)
    ->setArgument('$logger', new Reference('monolog.logger.request'));

This tells the container that the $logger argument to __construct should use service whose id is monolog.logger.request.

For a full list of all possible services in the container, run:

1

php bin/console debug:container --show-private

Binding Arguments by Name or Type

You can also use the bind keyword to bind specific arguments by name or type:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# config/services.yaml
services:
    _defaults:
        bind:
            # pass this value to any $adminEmail argument for any service
            # that's defined in this file (including controller arguments)
            $adminEmail: 'manager@example.com'

            # pass this service to any $requestLogger argument for any
            # service that's defined in this file
            $requestLogger: '@monolog.logger.request'

            # pass this service for any LoggerInterface type-hint for any
            # service that's defined in this file
            Psr\Log\LoggerInterface: '@monolog.logger.request'

    # ...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

<!-- config/services.xml -->
<?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">

    <services>
        <defaults autowire="true" autoconfigure="true" public="false">
            <bind key="$adminEmail">manager@example.com</bind>
            <bind key="$requestLogger"
                type="service"
                id="monolog.logger.request"
            />
            <bind key="Psr\Log\LoggerInterface"
                type="service"
                id="monolog.logger.request"
            />
        </defaults>

        <!-- ... -->
    </services>
</container>

1
2
3
4
5
6
7
8
9
10
11
12
13

// config/services.php
use App\Controller\LuckyController;
use Symfony\Component\DependencyInjection\Reference;
use Psr\Log\LoggerInterface;

$container->register(LuckyController::class)
    ->setPublic(true)
    ->setBindings(array(
        '$adminEmail' => 'manager@example.com',
        '$requestLogger' => new Reference('monolog.logger.request'),
        LoggerInterface::class => new Reference('monolog.logger.request'),
    ))
;

By putting the bind key under _defaults, you can specify the value of any argument for any service defined in this file! You can bind arguments by name (e.g. $adminEmail) or by type (e.g. Psr\Log\LoggerInterface).

The bind config can also be applied to specific services or when loading many services at once (i.e. Service Container).

The autowire Option

Above, the services.yaml file has autowire: true in the _defaults section so that it applies to all services defined in that file. With this setting, you're able to type-hint arguments in the __construct() method of your services and the container will automatically pass you the correct arguments. This entire entry has been written around autowiring.

For more details about autowiring, check out Defining Services Dependencies Automatically (Autowiring).

The autoconfigure Option

Above, the services.yaml file has autoconfigure: true in the _defaults section so that it applies to all services defined in that file. With this setting, the container will automatically apply certain configuration to your services, based on your service's class. This is mostly used to auto-tag your services.

For example, to create a Twig extension, you need to create a class, register it as a service, and tag it with twig.extension.

But, with autoconfigure: true, you don't need the tag. In fact, if you're using the default services.yaml config, you don't need to do anything: the service will be automatically loaded. Then, autoconfigure will add the twig.extension tag for you, because your class implements Twig\\Extension\\ExtensionInterface. And thanks to autowire, you can even add constructor arguments without any configuration.

Public Versus Private Services

Thanks to the _defaults section in services.yaml, every service defined in this file is public: false by default.

What does this mean? When a service is public, you can access it directly from the container object, which is accessible from any controller that extends Controller:

1
2
3
4
5
6
7
8
9
10
11

use App\Service\MessageGenerator;

// ...
public function new()
{
    // there IS a public "logger" service in the container
    $logger = $this->container->get('logger');

    // this will NOT work: MessageGenerator is a private service
    $generator = $this->container->get(MessageGenerator::class);
}

As a best practice, you should only create private services, which will happen automatically. And also, you should not use the $container->get() method to fetch public services.

But, if you do need to make a service public, just override the public setting:

1
2
3
4
5
6
7

# config/services.yaml
services:
    # ... same code as before

    # explicitly configure the service
    App\Service\MessageGenerator:
        public: true

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<!-- config/services.xml -->
<?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">

    <services>
        <!-- ... same code as before -->

        <!-- Explicitly configure the service -->
        <service id="App\Service\MessageGenerator" public="true"></service>
    </services>
</container>

Importing Many Services at once with resource

You've already seen that you can import many services at once by using the resource key. For example, the default Symfony configuration contains this:

1
2
3
4
5
6
7
8
9

# config/services.yaml
services:
    # ...

    # makes classes in src/ available to be used as services
    # this creates a service per class whose id is the fully-qualified class name
    App\:
        resource: '../src/*'
        exclude: '../src/{Entity,Migrations,Tests}'

1
2
3
4
5
6
7
8
9
10
11
12
13

<!-- config/services.xml -->
<?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">

    <services>
        <!-- ... -->

        <prototype namespace="App\" resource="../src/*" exclude="../src/{Entity,Migrations,Tests}" />
    </services>
</container>

1
2
3
4
5
6
7
8
9
10
11
12
13

// config/services.php
use Symfony\Component\DependencyInjection\Definition;

// To use as default template
$definition = new Definition();

$definition
    ->setAutowired(true)
    ->setAutoconfigured(true)
    ->setPublic(false)
;

$this->registerClasses($definition, 'App\\', '../src/*', '../src/{Entity,Migrations,Tests}');

This can be used to quickly make many classes available as services and apply some default configuration. The id of each service is its fully-qualified class name. You can override any service that's imported by using its id (class name) below (e.g. see Service Container). If you override a service, none of the options (e.g. public) are inherited from the import (but the overridden service does still inherit from _defaults).

You can also exclude certain paths. This is optional, but will slightly increase performance in the dev environment: excluded paths are not tracked and so modifying them will not cause the container to be rebuilt.

1
2
3
4
5

# config/services.yaml
services:
    App\Domain\:
        resource: '../src/Domain/*'
        # ...

1
2
3
4
5
6
7
8
9
10
11

# config/services.yaml
services:
    command_handlers:
        namespace: App\Domain\
        resource: '../src/Domain/*/CommandHandler'
        tags: [command_handler]

    event_subscribers:
        namespace: App\Domain\
        resource: '../src/Domain/*/EventSubscriber'
        tags: [event_subscriber]

Explicitly Configuring Services and Arguments

Prior to Symfony 3.3, all services and (typically) arguments were explicitly configured: it was not possible to load services automatically and autowiring was much less common.

Both of these features are optional. And even if you use them, there may be some cases where you want to manually wire a service. For example, suppose that you want to register 2 services for the SiteUpdateManager class - each with a different admin email. In this case, each needs to have a unique service id:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# config/services.yaml
services:
    # ...

    # this is the service's id
    site_update_manager.superadmin:
        class: App\Updates\SiteUpdateManager
        # you CAN still use autowiring: we just want to show what it looks like without
        autowire: false
        # manually wire all arguments
        arguments:
            - '@App\Service\MessageGenerator'
            - '@mailer'
            - 'superadmin@example.com'

    site_update_manager.normal_users:
        class: App\Updates\SiteUpdateManager
        autowire: false
        arguments:
            - '@App\Service\MessageGenerator'
            - '@mailer'
            - 'contact@example.com'

    # Create an alias, so that - by default - if you type-hint SiteUpdateManager,
    # the site_update_manager.superadmin will be used
    App\Updates\SiteUpdateManager: '@site_update_manager.superadmin'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

<!-- config/services.xml -->
<?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">

    <services>
        <!-- ... -->

        <service id="site_update_manager.superadmin" class="App\Updates\SiteUpdateManager" autowire="false">
            <argument type="service" id="App\Service\MessageGenerator" />
            <argument type="service" id="mailer" />
            <argument>superadmin@example.com</argument>
        </service>

        <service id="site_update_manager.normal_users" class="App\Updates\SiteUpdateManager" autowire="false">
            <argument type="service" id="App\Service\MessageGenerator" />
            <argument type="service" id="mailer" />
            <argument>contact@example.com</argument>
        </service>

        <service id="App\Updates\SiteUpdateManager" alias="site_update_manager.superadmin" />
    </services>
</container>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// config/services.php
use App\Updates\SiteUpdateManager;
use App\Service\MessageGenerator;
use Symfony\Component\DependencyInjection\Reference;

$container->register('site_update_manager.superadmin', SiteUpdateManager::class)
    ->setAutowired(false)
    ->setArguments(array(
        new Reference(MessageGenerator::class),
        new Reference('mailer'),
        'superadmin@example.com'
    ));

$container->register('site_update_manager.normal_users', SiteUpdateManager::class)
    ->setAutowired(false)
    ->setArguments(array(
        new Reference(MessageGenerator::class),
        new Reference('mailer'),
        'contact@example.com'
    ));

$container->setAlias(SiteUpdateManager::class, 'site_update_manager.superadmin')

In this case, two services are registered: site_update_manager.superadmin and site_update_manager.normal_users. Thanks to the alias, if you type-hint SiteUpdateManager the first (site_update_manager.superadmin) will be passed. If you want to pass the second, you'll need to manually wire the service.

Learn more