Skip to content
  • About
    • What is Symfony?
    • Community
    • News
    • Contributing
    • Support
  • Documentation
    • Symfony Docs
    • Symfony Book
    • Screencasts
    • Symfony Bundles
    • Symfony Cloud
    • Training
  • Services
    • SensioLabs Professional services to help you with Symfony
    • Platform.sh for Symfony Best platform to deploy Symfony apps
    • SymfonyInsight Automatic quality checks for your apps
    • Symfony Certification Prove your knowledge and boost your career
    • Blackfire Profile and monitor performance of your apps
  • Other
  • Blog
  • Download
sponsored by SensioLabs
  1. Home
  2. Documentation
  3. Service Container
  4. Using a Factory to Create Services
  • Documentation
  • Book
  • Reference
  • Bundles
  • Cloud

Table of Contents

  • Static Factories
  • Using the Class as Factory Itself
  • Non-Static Factories
  • Invokable Factories
  • Using Expressions in Service Factories
  • Passing Arguments to the Factory Method

Using a Factory to Create Services

Edit this page

Using a Factory to Create Services

Symfony's Service Container provides multiple features to control the creation of objects, allowing you to specify arguments passed to the constructor as well as calling methods and setting parameters.

However, sometimes you need to apply the factory design pattern to delegate the object creation to some special object called "the factory". In those cases, the service container can call a method on your factory to create the object rather than directly instantiating the class.

Static Factories

Suppose you have a factory that configures and returns a new NewsletterManager object by calling the static createNewsletterManager() method:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// src/Email/NewsletterManagerStaticFactory.php
namespace App\Email;

// ...

class NewsletterManagerStaticFactory
{
    public static function createNewsletterManager(): NewsletterManager
    {
        $newsletterManager = new NewsletterManager();

        // ...

        return $newsletterManager;
    }
}

To make the NewsletterManager object available as a service, use the factory option to define which method of which class must be called to create its object:

1
2
3
4
5
6
7
# config/services.yaml
services:
    # ...

    App\Email\NewsletterManager:
        # the first argument is the class and the second argument is the static method
        factory: ['App\Email\NewsletterManagerStaticFactory', 'createNewsletterManager']
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
        https://symfony.com/schema/dic/services/services-1.0.xsd">

    <services>
        <service id="App\Email\NewsletterManager">
            <!-- the first argument is the class and the second argument is the static method -->
            <factory class="App\Email\NewsletterManagerStaticFactory" method="createNewsletterManager"/>
        </service>
    </services>
</container>
1
2
3
4
5
6
7
8
9
10
11
12
13
// config/services.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

use App\Email\NewsletterManager;
use App\Email\NewsletterManagerStaticFactory;

return function(ContainerConfigurator $containerConfigurator) {
    $services = $containerConfigurator->services();

    $services->set(NewsletterManager::class)
        // the first argument is the class and the second argument is the static method
        ->factory([NewsletterManagerStaticFactory::class, 'createNewsletterManager']);
};

Note

When using a factory to create services, the value chosen for class has no effect on the resulting service. The actual class name only depends on the object that is returned by the factory. However, the configured class name may be used by compiler passes and therefore should be set to a sensible value.

Using the Class as Factory Itself

When the static factory method is on the same class as the created instance, the class name can be omitted from the factory declaration. Let's suppose the NewsletterManager class has a create() method that needs to be called to create the object and needs a sender:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// src/Email/NewsletterManager.php
namespace App\Email;

// ...

class NewsletterManager
{
    private string $sender;

    public static function create(string $sender): self
    {
        $newsletterManager = new self();
        $newsletterManager->sender = $sender;
        // ...

        return $newsletterManager;
    }
}

You can omit the class on the factory declaration:

1
2
3
4
5
6
7
8
# config/services.yaml
services:
    # ...

    App\Email\NewsletterManager:
        factory: [null, 'create']
        arguments:
            $sender: 'fabien@symfony.com'
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
        https://symfony.com/schema/dic/services/services-1.0.xsd">

    <services>
        <service id="App\Email\NewsletterManager">
            <factory method="create"/>
        </service>
    </services>
</container>
1
2
3
4
5
6
7
8
9
10
11
12
// config/services.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

use App\Email\NewsletterManager;

return function(ContainerConfigurator $containerConfigurator) {
    $services = $containerConfigurator->services();

    // Note that we are not using service()
    $services->set(NewsletterManager::class)
        ->factory([null, 'create']);
};

Non-Static Factories

If your factory is using a regular method instead of a static one to configure and create the service, instantiate the factory itself as a service too. Configuration of the service container then looks like this:

1
2
3
4
5
6
7
8
9
10
11
# config/services.yaml
services:
    # ...

    # first, create a service for the factory
    App\Email\NewsletterManagerFactory: ~

    # second, use the factory service as the first argument of the 'factory'
    # option and the factory method as the second argument
    App\Email\NewsletterManager:
        factory: ['@App\Email\NewsletterManagerFactory', 'createNewsletterManager']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<!-- 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
        https://symfony.com/schema/dic/services/services-1.0.xsd">

    <services>
        <!-- first, create a service for the factory -->
        <service id="App\Email\NewsletterManagerFactory"/>

        <!-- second, use the factory service as the first argument of the 'factory'
             option and the factory method as the second argument -->
        <service id="App\Email\NewsletterManager">
            <factory service="App\Email\NewsletterManagerFactory"
                method="createNewsletterManager"
            />
        </service>
    </services>
</container>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// config/services.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

use App\Email\NewsletterManager;
use App\Email\NewsletterManagerFactory;

return function(ContainerConfigurator $containerConfigurator) {
    $services = $containerConfigurator->services();

    // first, create a service for the factory
    $services->set(NewsletterManagerFactory::class);

    // second, use the factory service as the first argument of the 'factory'
    // method and the factory method as the second argument
    $services->set(NewsletterManager::class)
        ->factory([service(NewsletterManagerFactory::class), 'createNewsletterManager']);
};

Invokable Factories

Suppose you now change your factory method to __invoke() so that your factory service can be used as a callback:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// src/Email/InvokableNewsletterManagerFactory.php
namespace App\Email;

// ...
class InvokableNewsletterManagerFactory
{
    public function __invoke(): NewsletterManager
    {
        $newsletterManager = new NewsletterManager();

        // ...

        return $newsletterManager;
    }
}

Services can be created and configured via invokable factories by omitting the method name:

1
2
3
4
5
6
7
# config/services.yaml
services:
    # ...

    App\Email\NewsletterManager:
        class:   App\Email\NewsletterManager
        factory: '@App\Email\InvokableNewsletterManagerFactory'
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
        https://symfony.com/schema/dic/services/services-1.0.xsd">

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

        <service id="App\Email\NewsletterManager"
                 class="App\Email\NewsletterManager">
            <factory service="App\Email\InvokableNewsletterManagerFactory"/>
        </service>
    </services>
</container>
1
2
3
4
5
6
7
8
9
10
11
12
// config/services.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

use App\Email\NewsletterManager;
use App\Email\NewsletterManagerFactory;

return function(ContainerConfigurator $containerConfigurator) {
    $services = $containerConfigurator->services();

    $services->set(NewsletterManager::class)
        ->factory(service(InvokableNewsletterManagerFactory::class));
};

Using Expressions in Service Factories

6.1

Using expressions as factories was introduced in Symfony 6.1.

Instead of using PHP classes as a factory, you can also use expressions. This allows you to e.g. change the service based on a parameter:

1
2
3
4
5
6
7
8
9
10
11
12
# config/services.yaml
services:
    App\Email\NewsletterManagerInterface:
        # use the "tracable_newsletter" service when debug is enabled, "newsletter" otherwise.
        # "@=" indicates that this is an expression
        factory: '@=parameter("kernel.debug") ? service("tracable_newsletter") : service("newsletter")'

    # you can use the arg() function to retrieve an argument from the definition
    App\Email\NewsletterManagerInterface:
        factory: "@=arg(0).createNewsletterManager() ?: service("default_newsletter_manager")"
        arguments:
            - '@App\Email\NewsletterManagerFactory'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<!-- 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
        https://symfony.com/schema/dic/services/services-1.0.xsd">

    <services>
        <service id="App\Email\NewsletterManagerInterface">
            <!-- use the "tracable_newsletter" service when debug is enabled, "newsletter" otherwise -->
            <factory expression="parameter('kernel.debug') ? service('tracable_newsletter') : service('newsletter')"/>
        </service>

        <!-- you can use the arg() function to retrieve an argument from the definition -->
        <service id="App\Email\NewsletterManagerInterface">
            <factory expression="arg(0).createNewsletterManager() ?: service("default_newsletter_manager")"/>
            <argument type="service" id="App\Email\NewsletterManagerFactory"/>
        </service>
    </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
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

use App\Email\NewsletterManagerFactory;
use App\Email\NewsletterManagerInterface;

return function(ContainerConfigurator $containerConfigurator) {
    $services = $containerConfigurator->services();

    $services->set(NewsletterManagerInterface::class)
        // use the "tracable_newsletter" service when debug is enabled, "newsletter" otherwise.
        ->factory(expr("parameter('kernel.debug') ? service('tracable_newsletter') : service('newsletter')"))
    ;

    // you can use the arg() function to retrieve an argument from the definition
    $services->set(NewsletterManagerInterface::class)
        ->factory(expr("arg(0).createNewsletterManager() ?: service('default_newsletter_manager')"))
        ->args([
            service(NewsletterManagerFactory::class),
        ])
    ;
};

Passing Arguments to the Factory Method

Tip

Arguments to your factory method are autowired if that's enabled for your service.

If you need to pass arguments to the factory method you can use the arguments option. For example, suppose the createNewsletterManager() method in the previous examples takes the templating service as an argument:

1
2
3
4
5
6
7
# config/services.yaml
services:
    # ...

    App\Email\NewsletterManager:
        factory:   ['@App\Email\NewsletterManagerFactory', createNewsletterManager]
        arguments: ['@templating']
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
        https://symfony.com/schema/dic/services/services-1.0.xsd">

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

        <service id="App\Email\NewsletterManager">
            <factory service="App\Email\NewsletterManagerFactory" method="createNewsletterManager"/>
            <argument type="service" id="templating"/>
        </service>
    </services>
</container>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// config/services.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

use App\Email\NewsletterManager;
use App\Email\NewsletterManagerFactory;

return function(ContainerConfigurator $containerConfigurator) {
    $services = $containerConfigurator->services();

    $services->set(NewsletterManager::class)
        ->factory([service(NewsletterManagerFactory::class), 'createNewsletterManager'])
        ->args([service('templating')])
    ;
};
This work, including the code samples, is licensed under a Creative Commons BY-SA 3.0 license.
TOC
    Version
    We stand with Ukraine.
    Version:

    Symfony 6.2 is backed by

    Symfony 6.2 is backed by

    Measure & Improve Symfony Code Performance

    Measure & Improve Symfony Code Performance

    Code consumes server resources. Blackfire tells you how

    Code consumes server resources. Blackfire tells you how

    Symfony footer

    ↓ Our footer now uses the colors of the Ukrainian flag because Symfony stands with the people of Ukraine.

    Avatar of Chris Smith, a Symfony contributor

    Thanks Chris Smith (@cs278) for being a Symfony contributor

    5 commits • 129 lines changed

    View all contributors that help us make Symfony

    Become a Symfony contributor

    Be an active part of the community and contribute ideas, code and bug fixes. Both experts and newcomers are welcome.

    Learn how to contribute

    Symfony™ is a trademark of Symfony SAS. All rights reserved.

    • What is Symfony?

      • Symfony at a Glance
      • Symfony Components
      • Case Studies
      • Symfony Releases
      • Security Policy
      • Logo & Screenshots
      • Trademark & Licenses
      • symfony1 Legacy
    • Learn Symfony

      • Symfony Docs
      • Symfony Book
      • Reference
      • Bundles
      • Best Practices
      • Training
      • eLearning Platform
      • Certification
    • Screencasts

      • Learn Symfony
      • Learn PHP
      • Learn JavaScript
      • Learn Drupal
      • Learn RESTful APIs
    • Community

      • SymfonyConnect
      • Support
      • How to be Involved
      • Code of Conduct
      • Events & Meetups
      • Projects using Symfony
      • Downloads Stats
      • Contributors
      • Backers
    • Blog

      • Events & Meetups
      • A week of symfony
      • Case studies
      • Cloud
      • Community
      • Conferences
      • Diversity
      • Documentation
      • Living on the edge
      • Releases
      • Security Advisories
      • SymfonyInsight
      • Twig
      • SensioLabs
    • Services

      • SensioLabs services
      • Train developers
      • Manage your project quality
      • Improve your project performance
      • Host Symfony projects

      Deployed on

    Follow Symfony

    Search by Algolia