vendor/jms/serializer/src/EventDispatcher/Subscriber/DoctrineProxySubscriber.php line 101

  1. <?php
  3. declare(strict_types=1);
  5. namespace JMS\Serializer\EventDispatcher\Subscriber;
  7. use Doctrine\Common\Persistence\Proxy as LegacyProxy;
  8. use Doctrine\ODM\MongoDB\PersistentCollection as MongoDBPersistentCollection;
  9. use Doctrine\ODM\PHPCR\PersistentCollection as PHPCRPersistentCollection;
  10. use Doctrine\ORM\PersistentCollection;
  11. use Doctrine\Persistence\Proxy;
  12. use JMS\Serializer\EventDispatcher\EventDispatcherInterface;
  13. use JMS\Serializer\EventDispatcher\EventSubscriberInterface;
  14. use JMS\Serializer\EventDispatcher\PreSerializeEvent;
  15. use ProxyManager\Proxy\LazyLoadingInterface;
  17. final class DoctrineProxySubscriber implements EventSubscriberInterface
  18. {
  19. /**
  20. * @var bool
  21. */
  22. private $skipVirtualTypeInit;
  24. /**
  25. * @var bool
  26. */
  27. private $initializeExcluded;
  29. public function __construct(bool $skipVirtualTypeInit = true, bool $initializeExcluded = false)
  30. {
  31. $this->skipVirtualTypeInit = $skipVirtualTypeInit;
  32. $this->initializeExcluded = $initializeExcluded;
  33. }
  35. public function onPreSerialize(PreSerializeEvent $event): void
  36. {
  37. $object = $event->getObject();
  38. $type = $event->getType();
  40. // If the set type name is not an actual class, but a faked type for which a custom handler exists, we do not
  41. // modify it with this subscriber. Also, we forgo autoloading here as an instance of this type is already created,
  42. // so it must be loaded if its a real class.
  43. $virtualType = !class_exists($type['name'], false);
  45. if (
  46. $object instanceof PersistentCollection
  47. || $object instanceof MongoDBPersistentCollection
  48. || $object instanceof PHPCRPersistentCollection
  49. ) {
  50. if (!$virtualType) {
  51. $event->setType('ArrayCollection');
  52. }
  54. return;
  55. }
  57. if (
  58. ($this->skipVirtualTypeInit && $virtualType) ||
  59. (!$object instanceof Proxy && !$object instanceof LazyLoadingInterface)
  60. ) {
  61. return;
  62. }
  64. // do not initialize the proxy if is going to be excluded by-class by some exclusion strategy
  65. if (false === $this->initializeExcluded && !$virtualType) {
  66. $context = $event->getContext();
  67. $exclusionStrategy = $context->getExclusionStrategy();
  68. $metadata = $context->getMetadataFactory()->getMetadataForClass(get_parent_class($object));
  69. if (null !== $metadata && null !== $exclusionStrategy && $exclusionStrategy->shouldSkipClass($metadata, $context)) {
  70. return;
  71. }
  72. }
  74. if ($object instanceof LazyLoadingInterface) {
  75. $object->initializeProxy();
  76. } else {
  77. $object->__load();
  78. }
  80. if (!$virtualType) {
  81. $event->setType(get_parent_class($object), $type['params']);
  82. }
  83. }
  85. public function onPreSerializeTypedProxy(PreSerializeEvent $event, string $eventName, string $class, string $format, EventDispatcherInterface $dispatcher): void
  86. {
  87. $type = $event->getType();
  88. // is a virtual type? then there is no need to change the event name
  89. if (!class_exists($type['name'], false)) {
  90. return;
  91. }
  93. $object = $event->getObject();
  94. if ($object instanceof Proxy) {
  95. $parentClassName = get_parent_class($object);
  97. // check if this is already a re-dispatch
  98. if (strtolower($class) !== strtolower($parentClassName)) {
  99. $event->stopPropagation();
  100. $newEvent = new PreSerializeEvent($event->getContext(), $object, ['name' => $parentClassName, 'params' => $type['params']]);
  101. $dispatcher->dispatch($eventName, $parentClassName, $format, $newEvent);
  103. // update the type in case some listener changed it
  104. $newType = $newEvent->getType();
  105. $event->setType($newType['name'], $newType['params']);
  106. }
  107. }
  108. }
  110. /**
  111. * {@inheritdoc}
  112. */
  113. public static function getSubscribedEvents()
  114. {
  115. return [
  116. ['event' => 'serializer.pre_serialize', 'method' => 'onPreSerializeTypedProxy', 'interface' => Proxy::class],
  117. ['event' => 'serializer.pre_serialize', 'method' => 'onPreSerializeTypedProxy', 'interface' => LegacyProxy::class],
  118. ['event' => 'serializer.pre_serialize', 'method' => 'onPreSerialize', 'interface' => PersistentCollection::class],
  119. ['event' => 'serializer.pre_serialize', 'method' => 'onPreSerialize', 'interface' => MongoDBPersistentCollection::class],
  120. ['event' => 'serializer.pre_serialize', 'method' => 'onPreSerialize', 'interface' => PHPCRPersistentCollection::class],
  121. ['event' => 'serializer.pre_serialize', 'method' => 'onPreSerialize', 'interface' => Proxy::class],
  122. ['event' => 'serializer.pre_serialize', 'method' => 'onPreSerialize', 'interface' => LegacyProxy::class],
  123. ['event' => 'serializer.pre_serialize', 'method' => 'onPreSerialize', 'interface' => LazyLoadingInterface::class],
  124. ];
  125. }
  126. }