vendor/doctrine/orm/lib/Doctrine/ORM/Proxy/ProxyFactory.php line 207

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Proxy;
  7. use Closure;
  8. use Doctrine\Common\Proxy\AbstractProxyFactory;
  9. use Doctrine\Common\Proxy\Proxy as CommonProxy;
  10. use Doctrine\Common\Proxy\ProxyDefinition;
  11. use Doctrine\Common\Proxy\ProxyGenerator;
  12. use Doctrine\Common\Util\ClassUtils;
  13. use Doctrine\ORM\EntityManagerInterface;
  14. use Doctrine\ORM\EntityNotFoundException;
  15. use Doctrine\ORM\Persisters\Entity\EntityPersister;
  16. use Doctrine\ORM\Proxy\Proxy as LegacyProxy;
  17. use Doctrine\ORM\UnitOfWork;
  18. use Doctrine\ORM\Utility\IdentifierFlattener;
  19. use Doctrine\Persistence\Mapping\ClassMetadata;
  20. use Doctrine\Persistence\Proxy;
  21. use ReflectionProperty;
  22. use Symfony\Component\VarExporter\ProxyHelper;
  23. use Symfony\Component\VarExporter\VarExporter;
  25. use function array_flip;
  26. use function str_replace;
  27. use function strpos;
  28. use function substr;
  29. use function uksort;
  31. /**
  32.  * This factory is used to create proxy objects for entities at runtime.
  33.  *
  34.  * @psalm-type AutogenerateMode = ProxyFactory::AUTOGENERATE_NEVER|ProxyFactory::AUTOGENERATE_ALWAYS|ProxyFactory::AUTOGENERATE_FILE_NOT_EXISTS|ProxyFactory::AUTOGENERATE_EVAL|ProxyFactory::AUTOGENERATE_FILE_NOT_EXISTS_OR_CHANGED
  35.  */
  36. class ProxyFactory extends AbstractProxyFactory
  37. {
  38.     private const PROXY_CLASS_TEMPLATE = <<<'EOPHP'
  39. <?php
  41. namespace <namespace>;
  43. /**
  44.  * DO NOT EDIT THIS FILE - IT WAS CREATED BY DOCTRINE'S PROXY GENERATOR
  45.  */
  46. class <proxyShortClassName> extends \<className> implements \<baseProxyInterface>
  47. {
  48.     <useLazyGhostTrait>
  50.     /**
  51.      * @internal
  52.      */
  53.     public bool $__isCloning = false;
  55.     public function __construct(?\Closure $initializer = null)
  56.     {
  57.         self::createLazyGhost($initializer, <skippedProperties>, $this);
  58.     }
  60.     public function __isInitialized(): bool
  61.     {
  62.         return isset($this->lazyObjectState) && $this->isLazyObjectInitialized();
  63.     }
  65.     public function __clone()
  66.     {
  67.         $this->__isCloning = true;
  69.         try {
  70.             $this->__doClone();
  71.         } finally {
  72.             $this->__isCloning = false;
  73.         }
  74.     }
  76.     public function __serialize(): array
  77.     {
  78.         <serializeImpl>
  79.     }
  80. }
  82. EOPHP;
  84.     /** @var EntityManagerInterface The EntityManager this factory is bound to. */
  85.     private $em;
  87.     /** @var UnitOfWork The UnitOfWork this factory uses to retrieve persisters */
  88.     private $uow;
  90.     /** @var string */
  91.     private $proxyNs;
  93.     /**
  94.      * The IdentifierFlattener used for manipulating identifiers
  95.      *
  96.      * @var IdentifierFlattener
  97.      */
  98.     private $identifierFlattener;
  100.     /**
  101.      * Initializes a new instance of the <tt>ProxyFactory</tt> class that is
  102.      * connected to the given <tt>EntityManager</tt>.
  103.      *
  104.      * @param EntityManagerInterface $em           The EntityManager the new factory works for.
  105.      * @param string                 $proxyDir     The directory to use for the proxy classes. It must exist.
  106.      * @param string                 $proxyNs      The namespace to use for the proxy classes.
  107.      * @param bool|int               $autoGenerate The strategy for automatically generating proxy classes. Possible
  108.      *                                             values are constants of {@see ProxyFactory::AUTOGENERATE_*}.
  109.      * @psalm-param bool|AutogenerateMode $autoGenerate
  110.      */
  111.     public function __construct(EntityManagerInterface $em, $proxyDir, $proxyNs, $autoGenerate = self::AUTOGENERATE_NEVER)
  112.     {
  113.         $proxyGenerator = new ProxyGenerator($proxyDir, $proxyNs);
  115.         if ($em->getConfiguration()->isLazyGhostObjectEnabled()) {
  116.             $proxyGenerator->setPlaceholder('baseProxyInterface', Proxy::class);
  117.             $proxyGenerator->setPlaceholder('useLazyGhostTrait', Closure::fromCallable([$this, 'generateUseLazyGhostTrait']));
  118.             $proxyGenerator->setPlaceholder('skippedProperties', Closure::fromCallable([$this, 'generateSkippedProperties']));
  119.             $proxyGenerator->setPlaceholder('serializeImpl', Closure::fromCallable([$this, 'generateSerializeImpl']));
  120.             $proxyGenerator->setProxyClassTemplate(self::PROXY_CLASS_TEMPLATE);
  121.         } else {
  122.             $proxyGenerator->setPlaceholder('baseProxyInterface', LegacyProxy::class);
  123.         }
  125.         parent::__construct($proxyGenerator, $em->getMetadataFactory(), $autoGenerate);
  127.         $this->em                  = $em;
  128.         $this->uow                 = $em->getUnitOfWork();
  129.         $this->proxyNs             = $proxyNs;
  130.         $this->identifierFlattener = new IdentifierFlattener($this->uow, $em->getMetadataFactory());
  131.     }
  133.     /**
  134.      * {@inheritDoc}
  135.      */
  136.     protected function skipClass(ClassMetadata $metadata)
  137.     {
  138.         return $metadata->isMappedSuperclass
  139.             || $metadata->isEmbeddedClass
  140.             || $metadata->getReflectionClass()->isAbstract();
  141.     }
  143.     /**
  144.      * {@inheritDoc}
  145.      */
  146.     protected function createProxyDefinition($className)
  147.     {
  148.         $classMetadata   = $this->em->getClassMetadata($className);
  149.         $entityPersister = $this->uow->getEntityPersister($className);
  151.         if ($this->em->getConfiguration()->isLazyGhostObjectEnabled()) {
  152.             $initializer = $this->createLazyInitializer($classMetadata, $entityPersister);
  153.             $cloner      = static function (): void {
  154.             };
  155.         } else {
  156.             $initializer = $this->createInitializer($classMetadata, $entityPersister);
  157.             $cloner      = $this->createCloner($classMetadata, $entityPersister);
  158.         }
  160.         return new ProxyDefinition(
  161.             ClassUtils::generateProxyClassName($className, $this->proxyNs),
  162.             $classMetadata->getIdentifierFieldNames(),
  163.             $classMetadata->getReflectionProperties(),
  164.             $initializer,
  165.             $cloner
  166.         );
  167.     }
  169.     /**
  170.      * Creates a closure capable of initializing a proxy
  171.      *
  172.      * @psalm-return Closure(CommonProxy):void
  173.      *
  174.      * @throws EntityNotFoundException
  175.      */
  176.     private function createInitializer(ClassMetadata $classMetadata, EntityPersister $entityPersister): Closure
  177.     {
  178.         $wakeupProxy = $classMetadata->getReflectionClass()->hasMethod('__wakeup');
  180.         return function (CommonProxy $proxy) use ($entityPersister, $classMetadata, $wakeupProxy): void {
  181.             $initializer = $proxy->__getInitializer();
  182.             $cloner      = $proxy->__getCloner();
  184.             $proxy->__setInitializer(null);
  185.             $proxy->__setCloner(null);
  187.             if ($proxy->__isInitialized()) {
  188.                 return;
  189.             }
  191.             $properties = $proxy->__getLazyProperties();
  193.             foreach ($properties as $propertyName => $property) {
  194.                 if (! isset($proxy->$propertyName)) {
  195.                     $proxy->$propertyName = $properties[$propertyName];
  196.                 }
  197.             }
  199.             $proxy->__setInitialized(true);
  201.             if ($wakeupProxy) {
  202.                 $proxy->__wakeup();
  203.             }
  205.             $identifier = $classMetadata->getIdentifierValues($proxy);
  207.             if ($entityPersister->loadById($identifier, $proxy) === null) {
  208.                 $proxy->__setInitializer($initializer);
  209.                 $proxy->__setCloner($cloner);
  210.                 $proxy->__setInitialized(false);
  212.                 throw EntityNotFoundException::fromClassNameAndIdentifier(
  213.                     $classMetadata->getName(),
  214.                     $this->identifierFlattener->flattenIdentifier($classMetadata, $identifier)
  215.                 );
  216.             }
  217.         };
  218.     }
  220.     /**
  221.      * Creates a closure capable of initializing a proxy
  222.      *
  223.      * @return Closure(Proxy):void
  224.      *
  225.      * @throws EntityNotFoundException
  226.      */
  227.     private function createLazyInitializer(ClassMetadata $classMetadata, EntityPersister $entityPersister): Closure
  228.     {
  229.         return function (Proxy $proxy) use ($entityPersister, $classMetadata): void {
  230.             $identifier = $classMetadata->getIdentifierValues($proxy);
  231.             $entity     = $entityPersister->loadById($identifier, $proxy->__isCloning ? null : $proxy);
  233.             if ($entity === null) {
  234.                 throw EntityNotFoundException::fromClassNameAndIdentifier(
  235.                     $classMetadata->getName(),
  236.                     $this->identifierFlattener->flattenIdentifier($classMetadata, $identifier)
  237.                 );
  238.             }
  240.             if (! $proxy->__isCloning) {
  241.                 return;
  242.             }
  244.             $class = $entityPersister->getClassMetadata();
  246.             foreach ($class->getReflectionProperties() as $property) {
  247.                 if (! $class->hasField($property->name) && ! $class->hasAssociation($property->name)) {
  248.                     continue;
  249.                 }
  251.                 $property->setAccessible(true);
  252.                 $property->setValue($proxy, $property->getValue($entity));
  253.             }
  254.         };
  255.     }
  257.     /**
  258.      * Creates a closure capable of finalizing state a cloned proxy
  259.      *
  260.      * @psalm-return Closure(CommonProxy):void
  261.      *
  262.      * @throws EntityNotFoundException
  263.      */
  264.     private function createCloner(ClassMetadata $classMetadata, EntityPersister $entityPersister): Closure
  265.     {
  266.         return function (CommonProxy $proxy) use ($entityPersister, $classMetadata): void {
  267.             if ($proxy->__isInitialized()) {
  268.                 return;
  269.             }
  271.             $proxy->__setInitialized(true);
  272.             $proxy->__setInitializer(null);
  274.             $class      = $entityPersister->getClassMetadata();
  275.             $identifier = $classMetadata->getIdentifierValues($proxy);
  276.             $original   = $entityPersister->loadById($identifier);
  278.             if ($original === null) {
  279.                 throw EntityNotFoundException::fromClassNameAndIdentifier(
  280.                     $classMetadata->getName(),
  281.                     $this->identifierFlattener->flattenIdentifier($classMetadata, $identifier)
  282.                 );
  283.             }
  285.             foreach ($class->getReflectionProperties() as $property) {
  286.                 if (! $class->hasField($property->name) && ! $class->hasAssociation($property->name)) {
  287.                     continue;
  288.                 }
  290.                 $property->setAccessible(true);
  291.                 $property->setValue($proxy, $property->getValue($original));
  292.             }
  293.         };
  294.     }
  296.     private function generateUseLazyGhostTrait(ClassMetadata $class): string
  297.     {
  298.         $code = ProxyHelper::generateLazyGhost($class->getReflectionClass());
  299.         $code = substr($code, 7 + (int) strpos($code, "\n{"));
  300.         $code = substr($code, 0, (int) strpos($code, "\n}"));
  301.         $code = str_replace('LazyGhostTrait;', str_replace("\n    ", "\n", 'LazyGhostTrait {
  302.             initializeLazyObject as __load;
  303.             setLazyObjectAsInitialized as public __setInitialized;
  304.             isLazyObjectInitialized as private;
  305.             createLazyGhost as private;
  306.             resetLazyObject as private;
  307.             __clone as private __doClone;
  308.         }'), $code);
  310.         return $code;
  311.     }
  313.     private function generateSkippedProperties(ClassMetadata $class): string
  314.     {
  315.         $skippedProperties = ['__isCloning' => true];
  316.         $identifiers       = array_flip($class->getIdentifierFieldNames());
  317.         $filter            = ReflectionProperty::IS_PUBLIC | ReflectionProperty::IS_PROTECTED | ReflectionProperty::IS_PRIVATE;
  318.         $reflector         = $class->getReflectionClass();
  320.         while ($reflector) {
  321.             foreach ($reflector->getProperties($filter) as $property) {
  322.                 $name = $property->getName();
  324.                 if ($property->isStatic() || (($class->hasField($name) || $class->hasAssociation($name)) && ! isset($identifiers[$name]))) {
  325.                     continue;
  326.                 }
  328.                 $prefix = $property->isPrivate() ? "\0" . $property->getDeclaringClass()->getName() . "\0" : ($property->isProtected() ? "\0*\0" : '');
  330.                 $skippedProperties[$prefix . $name] = true;
  331.             }
  333.             $filter    = ReflectionProperty::IS_PRIVATE;
  334.             $reflector = $reflector->getParentClass();
  335.         }
  337.         uksort($skippedProperties, 'strnatcmp');
  339.         $code = VarExporter::export($skippedProperties);
  340.         $code = str_replace(VarExporter::export($class->getName()), 'parent::class', $code);
  341.         $code = str_replace("\n", "\n        ", $code);
  343.         return $code;
  344.     }
  346.     private function generateSerializeImpl(ClassMetadata $class): string
  347.     {
  348.         $reflector  = $class->getReflectionClass();
  349.         $properties = $reflector->hasMethod('__serialize') ? 'parent::__serialize()' : '(array) $this';
  351.         $code = '$properties = ' . $properties . ';
  352.         unset($properties["\0" . self::class . "\0lazyObjectState"], $properties[\'__isCloning\']);
  354.         ';
  356.         if ($reflector->hasMethod('__serialize') || ! $reflector->hasMethod('__sleep')) {
  357.             return $code . 'return $properties;';
  358.         }
  360.         return $code . '$data = [];
  362.         foreach (parent::__sleep() as $name) {
  363.             $value = $properties[$k = $name] ?? $properties[$k = "\0*\0$name"] ?? $properties[$k = "\0' . $reflector->getName() . '\0$name"] ?? $k = null;
  365.             if (null === $k) {
  366.                 trigger_error(sprintf(\'serialize(): "%s" returned as member variable from __sleep() but does not exist\', $name), \E_USER_NOTICE);
  367.             } else {
  368.                 $data[$k] = $value;
  369.             }
  370.         }
  372.         return $data;';
  373.     }
  374. }