New in Symfony 5.3: Service Autowiring with Attributes
Autowiring Iterators/Locators with Attributes¶
Contributed by
Alexander M. Turek
and Nicolas Grekas
in #40406.
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:
2
3
4
5
6
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:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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:
2
3
4
5
6
7
8
9
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:
2
3
4
5
6
7
8
9
10
11
12
13
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:
2
3
4
5
6
7
8
9
10
11
12
13
14
use SymfonyContractsHttpClientHttpClientInterface;
class GitHubDownloader
{
private $httpClient;
public function __construct(#[Target(‚githubApi‘)] HttpClientInterface $httpClient)
{
$this->httpClient = $httpClient;
}
// …
}
Symfony Blog
Read More