Symfony：控制器与EventListener之间的数据共享方案问询

Alright, let's tackle this problem you're facing with Symfony 3.4, Doctrine, and sharing objects between your controller and the kernel.terminate listener—no extra DB queries needed. Here are a couple of solid approaches that work well for this scenario:

Approach 1: Store the Object in Request Attributes #

This is the simplest method since the Request object is already available in both the controller and the PostResponseEvent (triggered by kernel.terminate).

Step 1: Save the Entity in Your Controller #

When you load your Doctrine entity in the controller, store it in the request's attributes bag:

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\JsonResponse;
use AppBundle\Entity\YourEntity;

public function yourAction(Request $request, $id)
{
    // Load the entity from Doctrine
    $entity = $this->getDoctrine()
        ->getRepository(YourEntity::class)
        ->find($id);

    // Your business logic here...

    // Store the entity in request attributes
    $request->attributes->set('shared_your_entity', $entity);

    return new JsonResponse(['status' => 'success']);
}

Step 2: Retrieve the Entity in Your Listener #

In your kernel.terminate listener, fetch the entity directly from the request object:

use Symfony\Component\HttpKernel\Event\PostResponseEvent;

class YourTerminateListener
{
    public function onKernelTerminate(PostResponseEvent $event)
    {
        $request = $event->getRequest();
        
        // Check if the entity exists in attributes to avoid errors
        if (!$request->attributes->has('shared_your_entity')) {
            return;
        }

        $entity = $request->attributes->get('shared_your_entity');
        
        // Use the entity for post-response tasks (e.g., send emails)
        // Note: At this point, the Doctrine EntityManager is already closed
        // If you need to modify/persist the entity, you'll need to reopen the EM:
        // $em = $this->doctrine->getManager();
        // $em->open();
        // $em->merge($entity); // Reattach the detached entity
        // $em->flush();
    }
}

Approach 2: Use a Request-Scoped Service #

If you prefer a more structured approach (especially if you need to share multiple objects), create a request-scoped service to hold your objects.

Step 1: Create the Object Holder Service #

Make a simple class to store and retrieve objects:

namespace AppBundle\Service;

class RequestObjectHolder
{
    private $storage = [];

    public function set(string $key, $object): void
    {
        $this->storage[$key] = $object;
    }

    public function get(string $key)
    {
        return $this->storage[$key] ?? null;
    }

    public function has(string $key): bool
    {
        return isset($this->storage[$key]);
    }
}

Step 2: Configure the Service as Request-Scoped #

In your app/config/services.yml, define the service with scope: request (this ensures a fresh instance per request):

services:
    app.request_object_holder:
        class: AppBundle\Service\RequestObjectHolder
        scope: request

Step 3: Use the Holder in Your Controller #

Inject the service into your controller and store the entity:

use AppBundle\Service\RequestObjectHolder;
use Symfony\Component\HttpFoundation\JsonResponse;
use AppBundle\Entity\YourEntity;

public function yourAction(RequestObjectHolder $holder, $id)
{
    $entity = $this->getDoctrine()
        ->getRepository(YourEntity::class)
        ->find($id);

    // Your business logic...

    $holder->set('shared_your_entity', $entity);

    return new JsonResponse(['status' => 'success']);
}

Step 4: Retrieve the Entity in Your Listener #

Inject the same service into your listener and fetch the entity:

use Symfony\Component\HttpKernel\Event\PostResponseEvent;
use AppBundle\Service\RequestObjectHolder;

class YourTerminateListener
{
    private $objectHolder;

    public function __construct(RequestObjectHolder $objectHolder)
    {
        $this->objectHolder = $objectHolder;
    }

    public function onKernelTerminate(PostResponseEvent $event)
    {
        if (!$this->objectHolder->has('shared_your_entity')) {
            return;
        }

        $entity = $this->objectHolder->get('shared_your_entity');
        
        // Perform your post-response tasks here
    }
}

Key Notes to Remember #

• Doctrine EntityManager State: When kernel.terminate runs, Symfony has already closed the EntityManager. If you need to modify and persist the entity, you'll need to reopen the EM and merge the detached entity (as shown in Approach 1's listener comment).
• Stateless API Safety: Both approaches are safe for stateless APIs because request attributes and request-scoped services are isolated to individual requests—no cross-request data leakage.
• Cleanup: You don't need to manually clean up the stored objects; Symfony handles request cleanup after kernel.terminate completes.

内容的提问来源于stack exchange，提问作者CaptainStiggz