New in Symfony 5.3: Service Autowiring with Attributes

Autowiring Iterators/Locators with Attributes

The traditional way of working with service tags in Symfony applications
involves these steps:

Apply some tag to one or more services (either manually or applying a tag
automatically to all services that implement some interface);
Add some service configuration to tell Symfony to inject all services tagged
with that tag into another service;
Prepare that other service to receive tagged services as a PHP iterator,

This process can quickly become repetitive and boring. That’s why in Symfony 5.3
we’re improving this feature to inject tagged services with PHP attributes.

Imagine that your application needs to inject all services tagged with a custom
tag called app.handler. First, apply this tag automatically to all services
whose classes implement a certain PHP interface:

1
2
3
4
5
6
# config/services.yaml
services:
_instanceof:
AppHandlerHandlerInterface:
tags: [‚app.handler‘]
# …

Now, use the new #[TaggedIterator] PHP attribute to inject all the services
tagged with that tag. You don’t need to add any extra configuration; just adding
this new attribute is enough:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// src/Handler/HandlerCollection.php
namespace AppHandler;

use SymfonyComponentDependencyInjectionAttributeTaggedIterator;

class HandlerCollection
{
private $handlers;

public function __construct(
#[TaggedIterator(‚app.handler‘)] iterator $handlers
) {
$this->handlers = $handlers;
}
}

Similarly, Symfony 5.3 includes a new #[TaggedLocator] PHP attribute to
inject a service locator with all services tagged with some tag:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// src/Handler/HandlerCollection.php
namespace AppHandler;

use PsrContainerContainerInterface;
use SymfonyComponentDependencyInjectionAttributeTaggedLocator;

class HandlerCollection
{
private $handlers;

public function __construct(
#[TaggedLocator(‚app.handler‘)] ContainerInterface $handlers
) {
$this->handlers = $handlers;
}
}

Selecting Autowire Alias with Attributes

Contributed by
Nicolas Grekas
in #40800.

Autowiring aliases are needed when your application uses autowiring and there
are multiple implementations of the same type. For example, consider the
following scoped HTTP client created to work with GitHub API:

1
2
3
4
5
6
7
8
9
# config/packages/framework.yaml
framework:
http_client:
scoped_clients:
githubApi:
scope: ‚https://api.github.com‘
headers:
Accept: ‚application/vnd.github.v3+json‘
# …

If you want to inject this scoped HTTP client in a service, it’s not enough to
type-hint the constructor argument with HttpClientInterface. You must use
the interface as the type-hint and the autowiring alias (githubApi) as the
variable name:

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

class GitHubDownloader
{
private $githubApi;

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

// …
}

This mechanism works well, but having to use some specific variable names is too
rigid for some developers. In Symfony 5.3 you can use any variable name
because we’ve introduced a #[Target] attribute to select the autowiring
alias. This is how the same example looks in Symfony 5.3:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
use SymfonyComponentDependencyInjectionAttributeTarget;
use SymfonyContractsHttpClientHttpClientInterface;

class GitHubDownloader
{
private $httpClient;

public function __construct(#[Target(‚githubApi‘)] HttpClientInterface $httpClient)
{
$this->httpClient = $httpClient;
}

// …
}

Sponsor the Symfony project.

Symfony Blog
Read More