How to create an Entity Listener lazily and inject dependencies into it

Question

Before Doctrine 2.4 the default way to catch lifecycle events (like prePersist) was a global event listener that would fire for ALL entities. Running such a listener as a Symfony service made it easy to inject other services (like the request or request_stack objects).

Now the better solution seems to be an entity listener since that comes with much less overhead!

So let's start this thing up in our entities header...:

* @ORM\EntityListeners({ "AppBundle\Entity\Listener\LanguageListener" })

And here's the class:

namespace AppBundle\Entity\Listener;

use Doctrine\ORM\Event\LifecycleEventArgs;

class LanguageListener
{
    public function prePersist($obj_entity, LifecycleEventArgs $obj_eventArgs)
    {    
        $request = ???;

        // set entity to users preferred language (for example 'de')
        $obj_entity->setLanguage($request->getLocale());
    }
}

As you can see, I have not the slightest idea how to access Symfonys services (in this case the request object).

But wait! There is a way:

global $kernel;
if ('AppCache' == get_class($kernel))
{
    $kernel = $kernel->getKernel();
}
$request = $kernel->getContainer()->get('request');

And it's working too.

But in all my research I found a lot of related questions strictly warning about excactly that! Only difference: all those questions were referring to Entities, not to Entity listeners...

... leading me to these two questions:

1. Is the above solution the way to go?
2. And if not: how should it be done?

---

[Edit:] Once again (see first sentence) let me make clear that this question is also about how to not use a service. Services come at some cost, see Expensive Service Construction. And particularly in this case I rarely need the functionality - that's why I want to go with Entity Listeners that do not run as service.

Sorry I didn't over emphasize this side aspect. Not sure why this qualified for a rate down though...

[Edit2:] To make things clearer I added one more code example (the first one) that shows how the thing is mapped.

Answer 1

As of doctrine/doctrine-bundle >= 1.5.0 entity listeners can be created as services and if they are tagged with doctrine.orm.entity_listener they will be registered into the desired entity manager automatically. You can inject the required dependencies into the service e.g. the request stack.

Create a listener:

namespace AppBundle\Doctrine\Listener;

use Symfony\Component\HttpFoundation\RequestStack;

class LanguageListener
{
    /**
     * @var RequestStack
     */
    private $requestStack;

    public function __construct(RequestStack $requestStack)
    {
        $this->requestStack = $requestStack;
    }

    public function prePersist($entity)
    {
        if (null !== $request = $this->requestStack->getCurrentRequest()) {
            // put the logic here
        }
    }
}

Register it as a service:

app.doctrine.language_listener:
    class: AppBundle\Doctrine\Listener\LanguageListener
    public: false
    arguments: ["@request_stack"]
    tags:
        - { name: "doctrine.orm.entity_listener" }

Annotate entities:

namespace AppBundle\Entity;

use Doctrine\ORM\Mapping as ORM;
use FOS\UserBundle\Entity\User as BaseUser;

/**
 * @ORM\Entity()
 * @ORM\EntityListeners("AppBundle\Doctrine\Listener\LanguageListener")
 * @ORM\Table("user_")
 */
class User extends BaseUser
{
    // ...  
}

Note that entity listener registered this way are not lazily loaded, so they and their dependencies will be created when the entity manager is created.

UPDATE:

So if your question is about how to use it lazily. The first solution that comes in my mind to declare it as a lazy service, but in this case it actually does not work as expected because in the annotation we use a concrate class which will be created by the listener resolver when needed, but in this case we should write the proxy class name in the annotation, to use the proxy object instead, which is not possible. There is a solution though (which is not documented at the moment), do not annotate the entity with @EntityListeners, but use tag parameters to register the listener. Something like this:

app.doctrine.language_listener:
    class: AppBundle\Doctrine\Listener\LanguageListener
    arguments: ["@request_stack"]
    lazy: true
    tags:
        - { name: "doctrine.orm.entity_listener", entity: AppBundle\Entity\User, event: preUpdate }
        - { name: "doctrine.orm.entity_listener", entity: AppBundle\Entity\User, event: postUpdate }

This way you can use lazy services, but it only works with doctrine/orm >= 2.5.0.

An another solution would be to create an own entity listener resolver which knows about the container (this is actually not a good thing) and uses it to get the listener when it is needed. There is a blog post about a way to do it.