Managing Common Dependencies with Parent Services

Edit this page

Warning: You are browsing the documentation for Symfony 2.0, which is no longer maintained.

Read the updated version of this page for Symfony 6.2 (the current stable version).

Managing Common Dependencies with Parent Services

As you add more functionality to your application, you may well start to have related classes that share some of the same dependencies. For example you may have a Newsletter Manager which uses setter injection to set its dependencies:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class NewsletterManager
{
    protected $mailer;
    protected $emailFormatter;

    public function setMailer(Mailer $mailer)
    {
        $this->mailer = $mailer;
    }

    public function setEmailFormatter(EmailFormatter $emailFormatter)
    {
        $this->emailFormatter = $emailFormatter;
    }

    // ...
}

and also a Greeting Card class which shares the same dependencies:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class GreetingCardManager
{
    protected $mailer;
    protected $emailFormatter;

    public function setMailer(Mailer $mailer)
    {
        $this->mailer = $mailer;
    }

    public function setEmailFormatter(EmailFormatter $emailFormatter)
    {
        $this->emailFormatter = $emailFormatter;
    }

    // ...
}

The service config for these classes would look something like this:

  • YAML
  • XML
  • PHP 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
parameters:
    # ...
    newsletter_manager.class: NewsletterManager
    greeting_card_manager.class: GreetingCardManager
services:
    my_mailer:
        # ...
    my_email_formatter:
        # ...
    newsletter_manager:
        class:     "%newsletter_manager.class%"
        calls:
            - [setMailer, ["@my_mailer"]]
            - [setEmailFormatter, ["@my_email_formatter"]]

    greeting_card_manager:
        class:     "%greeting_card_manager.class%"
        calls:
            - [setMailer, ["@my_mailer"]]
            - [setEmailFormatter, ["@my_email_formatter"]]

There is a lot of repetition in both the classes and the configuration. This means that if you changed, for example, the Mailer of EmailFormatter classes to be injected via the constructor, you would need to update the config in two places. Likewise if you needed to make changes to the setter methods you would need to do this in both classes. The typical way to deal with the common methods of these related classes would be to extract them to a super class:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
abstract class MailManager
{
    protected $mailer;
    protected $emailFormatter;

    public function setMailer(Mailer $mailer)
    {
        $this->mailer = $mailer;
    }

    public function setEmailFormatter(EmailFormatter $emailFormatter)
    {
        $this->emailFormatter = $emailFormatter;
    }

    // ...
}

The NewsletterManager and GreetingCardManager can then extend this super class:

1
2
3
4
class NewsletterManager extends MailManager
{
    // ...
}

and:

1
2
3
4
class GreetingCardManager extends MailManager
{
    // ...
}

In a similar fashion, the Symfony2 service container also supports extending services in the configuration so you can also reduce the repetition by specifying a parent for a service.

  • YAML
  • XML
  • PHP 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
parameters:
    # ...
    newsletter_manager.class: NewsletterManager
    greeting_card_manager.class: GreetingCardManager
services:
    my_mailer:
        # ...
    my_email_formatter:
        # ...
    mail_manager:
        abstract:  true
        calls:
            - [setMailer, ["@my_mailer"]]
            - [setEmailFormatter, ["@my_email_formatter"]]

    newsletter_manager:
        class:     "%newsletter_manager.class%"
        parent: mail_manager

    greeting_card_manager:
        class:     "%greeting_card_manager.class%"
        parent: mail_manager

In this context, having a parent service implies that the arguments and method calls of the parent service should be used for the child services. Specifically, the setter methods defined for the parent service will be called when the child services are instantiated.

Note

If you remove the parent config key, the services will still be instantiated and they will still of course extend the MailManager class. The difference is that omitting the parent config key will mean that the calls defined on the mail_manager service will not be executed when the child services are instantiated.

Caution

The scope, abstract and tags attributes are always taken from the child service.

The parent service is abstract as it should not be directly retrieved from the container or passed into another service. It exists merely as a "template" that other services can use. This is why it can have no class configured which would cause an exception to be raised for a non-abstract service.

Note

In order for parent dependencies to resolve, the ContainerBuilder must first be compiled. See Compiling the Container for more details.

Overriding Parent Dependencies

There may be times where you want to override what class is passed in for a dependency of one child service only. Fortunately, by adding the method call config for the child service, the dependencies set by the parent class will be overridden. So if you needed to pass a different dependency just to the NewsletterManager class, the config would look like this:

  • YAML
  • XML
  • PHP 
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
parameters:
    # ...
    newsletter_manager.class: NewsletterManager
    greeting_card_manager.class: GreetingCardManager
services:
    my_mailer:
        # ...
    my_alternative_mailer:
        # ...
    my_email_formatter:
        # ...
    mail_manager:
        abstract:  true
        calls:
            - [setMailer, ["@my_mailer"]]
            - [setEmailFormatter, ["@my_email_formatter"]]

    newsletter_manager:
        class:     "%newsletter_manager.class%"
        parent: mail_manager
        calls:
            - [setMailer, ["@my_alternative_mailer"]]

    greeting_card_manager:
        class:     "%greeting_card_manager.class%"
        parent: mail_manager

The GreetingCardManager will receive the same dependencies as before, but the NewsletterManager will be passed the my_alternative_mailer instead of the my_mailer service.

Collections of Dependencies

It should be noted that the overridden setter method in the previous example is actually called twice - once per the parent definition and once per the child definition. In the previous example, that was fine, since the second setMailer call replaces mailer object set by the first call.

In some cases, however, this can be a problem. For example, if the overridden method call involves adding something to a collection, then two objects will be added to that collection. The following shows such a case, if the parent class looks like this:

1
2
3
4
5
6
7
8
9
10
11
abstract class MailManager
{
    protected $filters;

    public function setFilter($filter)
    {
        $this->filters[] = $filter;
    }

    // ...
}

If you had the following config:

  • YAML
  • XML
  • PHP 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
parameters:
    # ...
    newsletter_manager.class: NewsletterManager
services:
    my_filter:
        # ...
    another_filter:
        # ...
    mail_manager:
        abstract:  true
        calls:
            - [setFilter, ["@my_filter"]]

    newsletter_manager:
        class:     "%newsletter_manager.class%"
        parent: mail_manager
        calls:
            - [setFilter, ["@another_filter"]]

In this example, the setFilter of the newsletter_manager service will be called twice, resulting in the $filters array containing both my_filter and another_filter objects. This is great if you just want to add additional filters to the subclasses. If you want to replace the filters passed to the subclass, removing the parent setting from the config will prevent the base class from calling setFilter.

Tip

In the examples shown there is a similar relationship between the parent and child services and the underlying parent and child classes. This does not need to be the case though, you can extract common parts of similar service definitions into a parent service without also inheriting a parent class.

This work, including the code samples, is licensed under a Creative Commons BY-SA 3.0 license.
Version:
Symfony Code Performance Profiling

Symfony Code Performance Profiling

Code consumes server resources. Blackfire tells you how

Code consumes server resources. Blackfire tells you how