Service Subscribers & Locators ¶

Sometimes, a service needs access to several other services without being sure that all of them will actually be used. In those cases, you may want the instantiation of the services to be lazy. However, that's not possible using the explicit dependency injection since services are not all meant to be lazy (see Lazy Services).

場合によっては、すべてのサービスが実際に使用されるかどうかを確認せずに、サービスが他のいくつかのサービスにアクセスする必要があります。そのような場合、サービスのインスタンス化を遅延させたい場合があります。ただし、すべてのサービスが遅延することを意図しているわけではないため、明示的な依存性注入を使用してこれを行うことはできません (Lazy Services を参照)。

This can typically be the case in your controllers, where you may inject several services in the constructor, but the action called only uses some of them. Another example are applications that implement the Command pattern using a CommandBus to map command handlers by Command class names and use them to handle their respective command when it is asked for:

これは通常、コンストラクターに複数のサービスを注入することができるコントローラーの場合に当てはまりますが、呼び出されたアクションはそれらの一部のみを使用します。別の例は、Command バスを使用して Command パターンを実装し、Command クラス名によってコマンドハンドラーをマップし、使用するアプリケーションです。要求されたときにそれぞれのコマンドを処理します。

    
        
                
                
                        // src/CommandBus.php
namespace App;

// ...
class CommandBus
{
    /**
     * @var CommandHandler[]
     */
    private $handlerMap;

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

    public function handle(Command $command)
    {
        $commandClass = get_class($command);

        if (!isset($this->handlerMap[$commandClass])) {
            return;
        }

        return $this->handlerMap[$commandClass]->handle($command);
    }
}

// ...
$commandBus->handle(new FooCommand());
                    

            

    

Considering that only one command is handled at a time, instantiating all the other command handlers is unnecessary. A possible solution to lazy-load the handlers could be to inject the main dependency injection container.

一度に処理されるコマンドは 1 つだけであるため、他のすべてのコマンドハンドラをインスタンス化する必要はありません。ハンドラーを遅延ロードするための可能な解決策は、メインの依存性注入コンテナーを注入することです。

However, injecting the entire container is discouraged because it gives too broad access to existing services and it hides the actual dependencies of the services. Doing so also requires services to be made public, which isn't the case by default in Symfony applications.

ただし、コンテナー全体を注入することはお勧めできません。これは、既存のサービスへのアクセスが広範になりすぎて、サービスの実際の依存関係が隠蔽されるためです。これを行うには、サービスを公開する必要もありますが、Symfony アプリケーションではデフォルトではそうではありません。

Service Subscribers are intended to solve this problem by giving access to a set of predefined services while instantiating them only when actually needed through a Service Locator, a separate lazy-loaded container.

サービスサブスクライバーは、事前定義された一連のサービスへのアクセスを提供する一方で、サービスロケーター (個別の遅延ロードコンテナー) を介して実際に必要な場合にのみサービスをインスタンス化することで、この問題を解決することを目的としています。

Defining a Service Subscriber ¶

First, turn CommandBus into an implementation of ServiceSubscriberInterface. Use its getSubscribedServices() method to include as many services as needed in the service subscriber and change the type hint of the container to a PSR-11 ContainerInterface:

まず、CommandBus を ServiceSubscriberInterface の実装に変更します。その getSubscribeServices() メソッドを使用して、サービスサブスクライバーに必要な数のサービスを含め、コンテナーのタイプヒントを PSR-11 ContainerInterface に変更します。

    
        
                
                
                        // src/CommandBus.php
namespace App;

use App\CommandHandler\BarHandler;
use App\CommandHandler\FooHandler;
use Psr\Container\ContainerInterface;
use Symfony\Contracts\Service\ServiceSubscriberInterface;

class CommandBus implements ServiceSubscriberInterface
{
    private $locator;

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

    public static function getSubscribedServices(): array
    {
        return [
            'App\FooCommand' => FooHandler::class,
            'App\BarCommand' => BarHandler::class,
        ];
    }

    public function handle(Command $command)
    {
        $commandClass = get_class($command);

        if ($this->locator->has($commandClass)) {
            $handler = $this->locator->get($commandClass);

            return $handler->handle($command);
        }
    }
}
                    

            

    

Tip

ヒント

If the container does not contain the subscribed services, double-check that you have autoconfigure enabled. You can also manually add the container.service_subscriber tag.

コンテナーにサブスクライブされたサービスが含まれていない場合は、自動構成が有効になっていることを再確認してください。 container.service_subscriber タグを手動で追加することもできます。

The injected service is an instance of ServiceLocator which implements the PSR-11 ContainerInterface, but it is also a callable:

挿入されたサービスは、PSR-11 ContainerInterface を実装する ServiceLocator のインスタンスですが、呼び出し可能でもあります。

    
                        // ...
$handler = ($this->locator)($commandClass);

return $handler->handle($command);

Including Services ¶

In order to add a new dependency to the service subscriber, use the getSubscribedServices() method to add service types to include in the service locator:

サービスサブスクライバーに新しい依存関係を追加するには、getSubscribeServices() メソッドを使用してサービスタイプを追加し、サービスロケーターに含めます。

    
                        use Psr\Log\LoggerInterface;

public static function getSubscribedServices(): array
{
    return [
        // ...
        LoggerInterface::class,
    ];
}

Service types can also be keyed by a service name for internal use:

サービスタイプは、内部使用のためにサービス名でキー付けすることもできます。

    
                        use Psr\Log\LoggerInterface;

public static function getSubscribedServices(): array
{
    return [
        // ...
        'logger' => LoggerInterface::class,
    ];
}

When extending a class that also implements ServiceSubscriberInterface, it's your responsibility to call the parent when overriding the method. This typically happens when extending AbstractController:

ServiceSubscriberInterface も実装するクラスを拡張する場合、メソッドをオーバーライドするときに親を呼び出すのはユーザーの責任です。これは通常、AbstractController を拡張するときに発生します。

    
                        use Psr\Log\LoggerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;

class MyController extends AbstractController
{
    public static function getSubscribedServices(): array
    {
        return array_merge(parent::getSubscribedServices(), [
            // ...
            'logger' => LoggerInterface::class,
        ]);
    }
}

Optional Services ¶

For optional dependencies, prepend the service type with a ? to prevent errors if there's no matching service found in the service container:

オプションの依存関係については、サービスタイプの前に ? を追加します。サービスコンテナに一致するサービスが見つからない場合のエラーを防ぐには:

    
                        use Psr\Log\LoggerInterface;

public static function getSubscribedServices(): array
{
    return [
        // ...
        '?'.LoggerInterface::class,
    ];
}

Note

ノート

Make sure an optional service exists by calling has() on the service locator before calling the service itself.

サービス自体を呼び出す前に、servicelocator で has() を呼び出して、オプションのサービスが存在することを確認してください。

Aliased Services ¶

By default, autowiring is used to match a service type to a service from the service container. If you don't use autowiring or need to add a non-traditional service as a dependency, use the container.service_subscriber tag to map a service type to a service.

デフォルトでは、オートワイヤーを使用して、サービスタイプをサービスコンテナのサービスに一致させます。オートワイヤーを使用しない場合、または従来とは異なるサービスを依存関係として追加する必要がある場合は、container.service_subscriber タグを使用してサービスタイプをサービスにマップします。

YAML
YAML
XML
XML
PHP
PHP

    
                        # config/services.yaml
services:
    App\CommandBus:
        tags:
            - { name: 'container.service_subscriber', key: 'logger', id: 'monolog.logger.event' }

    
                        <!-- 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\CommandBus">
            <tag name="container.service_subscriber" key="logger" id="monolog.logger.event"/>
        </service>

    </services>
</container>

    
                        // config/services.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

use App\CommandBus;

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

    $services->set(CommandBus::class)
        ->tag('container.service_subscriber', ['key' => 'logger', 'id' => 'monolog.logger.event']);
};

Tip

ヒント

The key attribute can be omitted if the service name internally is the same as in the service container.

内部のサービス名がサービスコンテナと同じ場合は、key 属性を省略できます。

Add Dependency Injection Attributes ¶

6.2

The ability to add attributes was introduced in Symfony 6.2.

属性を追加する機能は Symfony 6.2 で導入されました。

As an alternate to aliasing services in your configuration, you can also configure the following dependency injection attributes in the getSubscribedServices() method directly:

設定でサービスをエイリアシングする代わりに、次の依存性注入属性を getSubscribeServices() メソッドで直接設定することもできます。

Autowire
自動配線
TaggedIterator
TaggedIterator
TaggedLocator
タグ付きロケータ
Target
目標
MapDecorated
地図装飾

This is done by having getSubscribedServices() return an array of SubscribedService objects (these can be combined with standard string[] values):

これは、 getSubscribeServices() がSubscribeServiceオブジェクトの配列を返すようにすることによって行われます(これらは標準のstring[]値と組み合わせることができます):

    
        
                
                
                        use Psr\Container\ContainerInterface;
use Psr\Log\LoggerInterface;
use Symfony\Component\DependencyInjection\Attribute\Autowire;
use Symfony\Component\DependencyInjection\Attribute\TaggedIterator;
use Symfony\Component\DependencyInjection\Attribute\TaggedLocator;
use Symfony\Component\DependencyInjection\Attribute\Target;
use Symfony\Contracts\Service\Attribute\SubscribedService;

public static function getSubscribedServices(): array
{
    return [
        // ...
        new SubscribedService('logger', LoggerInterface::class, attributes: new Autowire(service: 'monolog.logger.event')),

        // can event use parameters
        new SubscribedService('env', string, attributes: new Autowire('%kernel.environment%')),

        // Target
        new SubscribedService('event.logger', LoggerInterface::class, attributes: new Target('eventLogger')),

        // TaggedIterator
        new SubscribedService('loggers', 'iterable', attributes: new TaggedIterator('logger.tag')),

        // TaggedLocator
        new SubscribedService('handlers', ContainerInterface::class, attributes: new TaggedLocator('handler.tag')),
    ];
}
                    

            

    

Note

ノート

The above example requires using 3.2 version or newer of symfony/service-contracts.

上記の例では、バージョン 3.2 以降の symfony/service-contracts を使用する必要があります。

Defining a Service Locator ¶

To manually define a service locator and inject it to another service, create an argument of type service_locator:

サービスロケーターを手動で定義して別のサービスに注入するには、タイプ service_locator の引数を作成します。

YAML
YAML
XML
XML
PHP
PHP

    
                        # config/services.yaml
services:
    App\CommandBus:
        arguments:
          - !service_locator
              App\FooCommand: '@app.command_handler.foo'
              App\BarCommand: '@app.command_handler.bar'

    
        
                
                
                        <!-- 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\CommandBus">
            <argument type="service_locator">
                <argument key="App\FooCommand" type="service" id="sapp.command_handler.foo"/>
                <argument key="App\BarCommandr" type="service" id="app.command_handler.bar"/>
                <!-- if the element has no key, the ID of the original service is used -->
                <argument type="service" id="app.command_handler.baz"/>
            </argument>
        </service>
    </services>
</container>
                    

            

    

    
                        // config/services.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

use App\CommandBus;

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

    $services->set(CommandBus::class)
        ->args([service_locator([
            'App\FooCommand' => service('app.command_handler.foo'),
            'App\BarCommand' => service('app.command_handler.bar'),
            // if the element has no key, the ID of the original service is used
            service('app.command_handler.baz'),
        ])]);
};

As shown in the previous sections, the constructor of the CommandBus class must type-hint its argument with ContainerInterface. Then, you can get any of the service locator services via their ID (e.g. $this->locator->get('App\FooCommand')).

前のセクションで示したように、CommandBus クラスのコンストラクターは、その引数を ContainerInterface で型ヒントする必要があります。次に、ID を介して任意のサービスロケーターサービスを取得できます (例: $this->locator->get('App\FooCommand'))。

Reusing a Service Locator in Multiple Services ¶

If you inject the same service locator in several services, it's better to define the service locator as a stand-alone service and then inject it in the other services. To do so, create a new service definition using the ServiceLocator class:

同じサービスロケーターを複数のサービスに挿入する場合は、サービスロケーターをスタンドアロンサービスとして定義してから、他のサービスに挿入することをお勧めします。これを行うには、ServiceLocator クラスを使用して新しいサービス定義を作成します。

YAML
YAML
XML
XML
PHP
PHP

    
        
                
                
                        # config/services.yaml
services:
    app.command_handler_locator:
        class: Symfony\Component\DependencyInjection\ServiceLocator
        arguments:
            -
                App\FooCommand: '@app.command_handler.foo'
                App\BarCommand: '@app.command_handler.bar'
        # if you are not using the default service autoconfiguration,
        # add the following tag to the service definition:
        # tags: ['container.service_locator']

    # if the element has no key, the ID of the original service is used
    app.another_command_handler_locator:
        class: Symfony\Component\DependencyInjection\ServiceLocator
        arguments:
            -
                - '@app.command_handler.baz'
                    

            

    

    
        
                
                
                        <!-- 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.command_handler_locator" class="Symfony\Component\DependencyInjection\ServiceLocator">
            <argument type="collection">
                <argument key="App\FooCommand" type="service" id="app.command_handler.foo"/>
                <argument key="App\BarCommand" type="service" id="app.command_handler.bar"/>
                <!-- if the element has no key, the ID of the original service is used -->
                <argument type="service" id="app.command_handler.baz"/>
            </argument>
            <!--
                if you are not using the default service autoconfiguration,
                add the following tag to the service definition:
                <tag name="container.service_locator"/>
            -->
        </service>

    </services>
</container>
                    

            

    

    
        
                
                
                        // config/services.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

use Symfony\Component\DependencyInjection\ServiceLocator;

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

    $services->set('app.command_handler_locator', ServiceLocator::class)
        ->args([[
            'App\FooCommand' => service('app.command_handler.foo'),
            'App\BarCommand' => service('app.command_handler.bar'),
        ]])
        // if you are not using the default service autoconfiguration,
        // add the following tag to the service definition:
        // ->tag('container.service_locator')
    ;

    // if the element has no key, the ID of the original service is used
    $services->set('app.another_command_handler_locator', ServiceLocator::class)
        ->args([[
            service('app.command_handler.baz'),
        ]])
    ;
};
                    

            

    

Note

ノート

The services defined in the service locator argument must include keys, which later become their unique identifiers inside the locator.

サービスロケーター引数で定義されたサービスには、後でロケーター内の一意の識別子になるキーが含まれている必要があります。

Now you can inject the service locator in any other services:

これで、サービスロケーターを他のサービスに挿入できます。

YAML
YAML
XML
XML
PHP
PHP

    
                        # config/services.yaml
services:
    App\CommandBus:
        arguments: ['@app.command_handler_locator']

    
                        <!-- 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\CommandBus">
            <argument type="service" id="app.command_handler_locator"/>
        </service>

    </services>
</container>

    
                        // config/services.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

use App\CommandBus;

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

    $services->set(CommandBus::class)
        ->args([service('app.command_handler_locator')]);
};

Using Service Locators in Compiler Passes ¶

In compiler passes it's recommended to use the register() method to create the service locators. This will save you some boilerplate and will share identical locators among all the services referencing them:

コンパイラパスでは、register() メソッドを使用してサービスロケータを作成することをお勧めします。これにより定型文が節約され、それらを参照するすべてのサービス間で同一のロケーターが共有されます。

    
                        use Symfony\Component\DependencyInjection\Compiler\ServiceLocatorTagPass;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Reference;

public function process(ContainerBuilder $container): void
{
    // ...

    $locateableServices = [
        // ...
        'logger' => new Reference('logger'),
    ];
    
    $myService = $container->findDefinition(MyService::class);

    $myService->addArgument(ServiceLocatorTagPass::register($container, $locateableServices));
}

Indexing the Collection of Services ¶

Services passed to the service locator can define their own index using an arbitrary attribute whose name is defined as index_by in the service locator.

サービスロケータに渡されるサービスは、名前がサービスロケータで index_by として定義されている任意の属性を使用して、独自のインデックスを定義できます。

In the following example, the App\Handler\HandlerCollection locator receives all services tagged with app.handler and they are indexed using the value of the key tag attribute (as defined in the index_by locator option):

次の例では、App\Handler\HandlerCollection ロケーターは app.handler でタグ付けされたすべてのサービスを受け取り、キータグ属性の値を使用してインデックスが作成されます (index_by ロケーターオプションで定義されています)。

YAML
YAML
XML
XML
PHP
PHP

    
                        # config/services.yaml
services:
    App\Handler\One:
        tags:
            - { name: 'app.handler', key: 'handler_one' }

    App\Handler\Two:
        tags:
            - { name: 'app.handler', key: 'handler_two' }

    App\Handler\HandlerCollection:
        # inject all services tagged with app.handler as first argument
        arguments: [!tagged_locator { tag: 'app.handler', index_by: 'key' }]

    
        
                
                
                        <!-- 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\Handler\One">
            <tag name="app.handler" key="handler_one"/>
        </service>

        <service id="App\Handler\Two">
            <tag name="app.handler" key="handler_two"/>
        </service>

        <service id="App\HandlerCollection">
            <!-- inject all services tagged with app.handler as first argument -->
            <argument type="tagged_locator" tag="app.handler" index-by="key"/>
        </service>
    </services>
</container>
                    

            

    

    
                        // config/services.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

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

    $services->set(App\Handler\One::class)
        ->tag('app.handler', ['key' => 'handler_one'])
    ;

    $services->set(App\Handler\Two::class)
        ->tag('app.handler', ['key' => 'handler_two'])
    ;

    $services->set(App\Handler\HandlerCollection::class)
        // inject all services tagged with app.handler as first argument
        ->args([tagged_locator('app.handler', 'key')])
    ;
};

Inside this locator you can retrieve services by index using the value of the key attribute. For example, to get the App\Handler\Two service:

このロケーター内では、key 属性の値を使用して、インデックスによってサービスを取得できます。たとえば、App\Handler\Two サービスを取得するには、次のようにします。

    
                        // src/Handler/HandlerCollection.php
namespace App\Handler;

use Symfony\Component\DependencyInjection\ServiceLocator;

class HandlerCollection
{
    public function __construct(ServiceLocator $locator)
    {
        $handlerTwo = $locator->get('handler_two');
    }

    // ...
}

Instead of defining the index in the service definition, you can return its value in a method called getDefaultIndexName() inside the class associated to the service:

サービス定義でインデックスを定義する代わりに、サービスに関連付けられたクラス内の getDefaultIndexName() と呼ばれるメソッドでその値を返すことができます。

    
                        // src/Handler/One.php
namespace App\Handler;

class One
{
    public static function getDefaultIndexName(): string
    {
        return 'handler_one';
    }

    // ...
}

If you prefer to use another method name, add a default_index_method attribute to the locator service defining the name of this custom method:

別のメソッド名を使用する場合は、このカスタムメソッドの名前を定義するロケーターサービスに default_index_methodattribute を追加します。

YAML
YAML
XML
XML
PHP
PHP

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

    App\HandlerCollection:
        arguments: [!tagged_locator { tag: 'app.handler', index_by: 'key', default_index_method: 'myOwnMethodName' }]

    
                        <!-- 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\HandlerCollection">
            <argument type="tagged_locator" tag="app.handler" index-by="key" default-index-method="myOwnMethodName"/>
        </service>
    </services>
</container>

    
                        // config/services.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

return function(ContainerConfigurator $configurator) {
    $configurator->services()
        ->set(App\HandlerCollection::class)
            ->args([tagged_locator('app.handler', 'key', 'myOwnMethodName')])
    ;
};

Note

ノート

Since code should not be responsible for defining how the locators are going to be used, a configuration key (key in the example above) must be set so the custom method may be called as a fallback.

ロケーターの使用方法をコードで定義する必要はないため、構成キー (上記の例ではキー) を設定して、カスタムメソッドをフォールバックとして呼び出すことができるようにする必要があります。

Service Subscriber Trait ¶

The ServiceSubscriberTrait provides an implementation for ServiceSubscriberInterface that looks through all methods in your class that are marked with the SubscribedService attribute. It provides a ServiceLocator for the services of each method's return type. The service id is __METHOD__. This allows you to add dependencies to your services based on type-hinted helper methods:

ServiceSubscriberTrait は、SubscriberService 属性でマークされたクラス内のすべてのメソッドを調べる ServiceSubscriberInterface の実装を提供します。各メソッドの戻り型のサービスに ServiceLocator を提供します。サービス ID は __METHOD__ です。これにより、型ヒント付きのヘルパーメソッドに基づいてサービスに依存関係を追加できます。

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

use Psr\Log\LoggerInterface;
use Symfony\Component\Routing\RouterInterface;
use Symfony\Contracts\Service\Attribute\SubscribedService;
use Symfony\Contracts\Service\ServiceSubscriberInterface;
use Symfony\Contracts\Service\ServiceSubscriberTrait;

class MyService implements ServiceSubscriberInterface
{
    use ServiceSubscriberTrait;

    public function doSomething()
    {
        // $this->router() ...
        // $this->logger() ...
    }

    #[SubscribedService]
    private function router(): RouterInterface
    {
        return $this->container->get(__METHOD__);
    }

    #[SubscribedService]
    private function logger(): LoggerInterface
    {
        return $this->container->get(__METHOD__);
    }
}
                    

            

    

This allows you to create helper traits like RouterAware, LoggerAware, etc... and compose your services with them:

これにより、RouterAware、LoggerAware などのヘルパートレイトを作成し、それらを使用してサービスを構成できます。

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

use Psr\Log\LoggerInterface;
use Symfony\Contracts\Service\Attribute\SubscribedService;

trait LoggerAware
{
    #[SubscribedService]
    private function logger(): LoggerInterface
    {
        return $this->container->get(__CLASS__.'::'.__FUNCTION__);
    }
}

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

use Symfony\Component\Routing\RouterInterface;
use Symfony\Contracts\Service\Attribute\SubscribedService;

trait RouterAware
{
    #[SubscribedService]
    private function router(): RouterInterface
    {
        return $this->container->get(__CLASS__.'::'.__FUNCTION__);
    }
}

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

use Symfony\Contracts\Service\ServiceSubscriberInterface;
use Symfony\Contracts\Service\ServiceSubscriberTrait;

class MyService implements ServiceSubscriberInterface
{
    use ServiceSubscriberTrait, LoggerAware, RouterAware;

    public function doSomething()
    {
        // $this->router() ...
        // $this->logger() ...
    }
}
                    

            

    

Caution

注意

When creating these helper traits, the service id cannot be __METHOD__ as this will include the trait name, not the class name. Instead, use __CLASS__.'::'.__FUNCTION__ as the service id.

これらのヘルパートレイトを作成する場合、クラス名ではなくトレイト名が含まれるため、サービス ID を __METHOD__ にすることはできません。代わりに、__CLASS__.'::'.__FUNCTION__ をサービス ID として使用します。

`SubscribedService` Attributes ¶

6.2

The ability to add attributes was introduced in Symfony 6.2.

属性を追加する機能は Symfony 6.2 で導入されました。

You can use the attributes argument of SubscribedService to add any of the following dependency injection attributes:

SubscribedService の attributes 引数を使用して、次の依存性注入属性を追加できます。

Autowire
自動配線
TaggedIterator
TaggedIterator
TaggedLocator
タグ付きロケータ
Target
目標
MapDecorated
地図装飾

Here's an example:

次に例を示します。

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

use Psr\Log\LoggerInterface;
use Symfony\Component\DependencyInjection\Attribute\Autowire;
use Symfony\Component\DependencyInjection\Attribute\Target;
use Symfony\Component\Routing\RouterInterface;
use Symfony\Contracts\Service\Attribute\SubscribedService;
use Symfony\Contracts\Service\ServiceSubscriberInterface;
use Symfony\Contracts\Service\ServiceSubscriberTrait;

class MyService implements ServiceSubscriberInterface
{
    use ServiceSubscriberTrait;

    public function doSomething()
    {
        // $this->environment() ...
        // $this->router() ...
        // $this->logger() ...
    }

    #[SubscribedService(attributes: new Autowire('%kernel.environment%'))]
    private function environment(): string
    {
        return $this->container->get(__METHOD__);
    }

    #[SubscribedService(attributes: new Autowire(service: 'router'))]
    private function router(): RouterInterface
    {
        return $this->container->get(__METHOD__);
    }

    #[SubscribedService(attributes: new Target('requestLogger'))]
    private function logger(): LoggerInterface
    {
        return $this->container->get(__METHOD__);
    }
}
                    

            

    

Note

ノート

The above example requires using 3.2 version or newer of symfony/service-contracts.

上記の例では、バージョン 3.2 以降の symfony/service-contracts を使用する必要があります。

Testing a Service Subscriber ¶

To unit test a service subscriber, you can create a fake ServiceLocator:

サービスサブスクライバーを単体テストするには、偽の ServiceLocator を作成できます。

    
        
                
                
                        use Symfony\Component\DependencyInjection\ServiceLocator;

$container = new class() extends ServiceLocator {
    private $services = [];

    public function __construct()
    {
        parent::__construct([
            'foo' => function () {
                return $this->services['foo'] = $this->services['foo'] ?? new stdClass();
            },
            'bar' => function () {
                return $this->services['bar'] = $this->services['bar'] ?? $this->createBar();
            },
        ]);
    }

    private function createBar()
    {
        $bar = new stdClass();
        $bar->foo = $this->get('foo');

        return $bar;
    }
};

$serviceSubscriber = new MyService($container);
// ...
                    

            

    

Another alternative is to mock it using PHPUnit:

もう 1 つの方法は、PHPUnit を使用してモックすることです。

    
                        use Psr\Container\ContainerInterface;

$container = $this->createMock(ContainerInterface::class);
$container->expects(self::any())
    ->method('get')
    ->willReturnMap([
        ['foo', $this->createStub(Foo::class)],
        ['bar', $this->createStub(Bar::class)],
    ])
;

$serviceSubscriber = new MyService($container);
// ...

Service Subscribers & Locators ¶

Defining a Service Subscriber ¶

Including Services ¶

Optional Services ¶

Aliased Services ¶

Add Dependency Injection Attributes ¶

Defining a Service Locator ¶

Reusing a Service Locator in Multiple Services ¶

Using Service Locators in Compiler Passes ¶

Indexing the Collection of Services ¶

Service Subscriber Trait ¶

SubscribedService Attributes ¶

Testing a Service Subscriber ¶

`SubscribedService` Attributes ¶