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

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 Symfony\Component\VarExporter\ProxyHelper;
  22. use Symfony\Component\VarExporter\VarExporter;
  24. use function array_flip;
  25. use function str_replace;
  26. use function strpos;
  27. use function substr;
  28. use function uksort;
  30. /**
  31.  * This factory is used to create proxy objects for entities at runtime.
  32.  *
  33.  * @psalm-type AutogenerateMode = ProxyFactory::AUTOGENERATE_NEVER|ProxyFactory::AUTOGENERATE_ALWAYS|ProxyFactory::AUTOGENERATE_FILE_NOT_EXISTS|ProxyFactory::AUTOGENERATE_EVAL|ProxyFactory::AUTOGENERATE_FILE_NOT_EXISTS_OR_CHANGED
  34.  */
  35. class ProxyFactory extends AbstractProxyFactory
  36. {
  37.     private const PROXY_CLASS_TEMPLATE = <<<'EOPHP'
  38. <?php
  40. namespace <namespace>;
  42. /**
  43.  * DO NOT EDIT THIS FILE - IT WAS CREATED BY DOCTRINE'S PROXY GENERATOR
  44.  */
  45. class <proxyShortClassName> extends \<className> implements \<baseProxyInterface>
  46. {
  47.     <useLazyGhostTrait>
  49.     /**
  50.      * @internal
  51.      */
  52.     public bool $__isCloning = false;
  54.     public function __construct(?\Closure $initializer = null)
  55.     {
  56.         self::createLazyGhost($initializer, <skippedProperties>, $this);
  57.     }
  59.     public function __isInitialized(): bool
  60.     {
  61.         return isset($this->lazyObjectState) && $this->isLazyObjectInitialized();
  62.     }
  64.     public function __clone()
  65.     {
  66.         $this->__isCloning = true;
  68.         try {
  69.             $this->__doClone();
  70.         } finally {
  71.             $this->__isCloning = false;
  72.         }
  73.     }
  75.     public function __serialize(): array
  76.     {
  77.         <serializeImpl>
  78.     }
  79. }
  81. EOPHP;
  83.     /** @var EntityManagerInterface The EntityManager this factory is bound to. */
  84.     private $em;
  86.     /** @var UnitOfWork The UnitOfWork this factory uses to retrieve persisters */
  87.     private $uow;
  89.     /** @var string */
  90.     private $proxyNs;
  92.     /**
  93.      * The IdentifierFlattener used for manipulating identifiers
  94.      *
  95.      * @var IdentifierFlattener
  96.      */
  97.     private $identifierFlattener;
  99.     /**
  100.      * Initializes a new instance of the <tt>ProxyFactory</tt> class that is
  101.      * connected to the given <tt>EntityManager</tt>.
  102.      *
  103.      * @param EntityManagerInterface $em           The EntityManager the new factory works for.
  104.      * @param string                 $proxyDir     The directory to use for the proxy classes. It must exist.
  105.      * @param string                 $proxyNs      The namespace to use for the proxy classes.
  106.      * @param bool|int               $autoGenerate The strategy for automatically generating proxy classes. Possible
  107.      *                                             values are constants of {@see ProxyFactory::AUTOGENERATE_*}.
  108.      * @psalm-param bool|AutogenerateMode $autoGenerate
  109.      */
  110.     public function __construct(EntityManagerInterface $em, $proxyDir, $proxyNs, $autoGenerate = self::AUTOGENERATE_NEVER)
  111.     {
  112.         $proxyGenerator = new ProxyGenerator($proxyDir, $proxyNs);
  114.         if ($em->getConfiguration()->isLazyGhostObjectEnabled()) {
  115.             $proxyGenerator->setPlaceholder('baseProxyInterface', Proxy::class);
  116.             $proxyGenerator->setPlaceholder('useLazyGhostTrait', Closure::fromCallable([$this, 'generateUseLazyGhostTrait']));
  117.             $proxyGenerator->setPlaceholder('skippedProperties', Closure::fromCallable([$this, 'generateSkippedProperties']));
  118.             $proxyGenerator->setPlaceholder('serializeImpl', Closure::fromCallable([$this, 'generateSerializeImpl']));
  119.             $proxyGenerator->setProxyClassTemplate(self::PROXY_CLASS_TEMPLATE);
  120.         } else {
  121.             $proxyGenerator->setPlaceholder('baseProxyInterface', LegacyProxy::class);
  122.         }
  124.         parent::__construct($proxyGenerator, $em->getMetadataFactory(), $autoGenerate);
  126.         $this->em                  = $em;
  127.         $this->uow                 = $em->getUnitOfWork();
  128.         $this->proxyNs             = $proxyNs;
  129.         $this->identifierFlattener = new IdentifierFlattener($this->uow, $em->getMetadataFactory());
  130.     }
  132.     /**
  133.      * {@inheritDoc}
  134.      */
  135.     protected function skipClass(ClassMetadata $metadata)
  136.     {
  137.         return $metadata->isMappedSuperclass
  138.             || $metadata->isEmbeddedClass
  139.             || $metadata->getReflectionClass()->isAbstract();
  140.     }
  142.     /**
  143.      * {@inheritDoc}
  144.      */
  145.     protected function createProxyDefinition($className)
  146.     {
  147.         $classMetadata   = $this->em->getClassMetadata($className);
  148.         $entityPersister = $this->uow->getEntityPersister($className);
  150.         if ($this->em->getConfiguration()->isLazyGhostObjectEnabled()) {
  151.             $initializer = $this->createLazyInitializer($classMetadata, $entityPersister);
  152.             $cloner      = static function (): void {
  153.             };
  154.         } else {
  155.             $initializer = $this->createInitializer($classMetadata, $entityPersister);
  156.             $cloner      = $this->createCloner($classMetadata, $entityPersister);
  157.         }
  159.         return new ProxyDefinition(
  160.             ClassUtils::generateProxyClassName($className, $this->proxyNs),
  161.             $classMetadata->getIdentifierFieldNames(),
  162.             $classMetadata->getReflectionProperties(),
  163.             $initializer,
  164.             $cloner
  165.         );
  166.     }
  168.     /**
  169.      * Creates a closure capable of initializing a proxy
  170.      *
  171.      * @psalm-return Closure(CommonProxy):void
  172.      *
  173.      * @throws EntityNotFoundException
  174.      */
  175.     private function createInitializer(ClassMetadata $classMetadata, EntityPersister $entityPersister): Closure
  176.     {
  177.         $wakeupProxy = $classMetadata->getReflectionClass()->hasMethod('__wakeup');
  179.         return function (CommonProxy $proxy) use ($entityPersister, $classMetadata, $wakeupProxy): void {
  180.             $initializer = $proxy->__getInitializer();
  181.             $cloner      = $proxy->__getCloner();
  183.             $proxy->__setInitializer(null);
  184.             $proxy->__setCloner(null);
  186.             if ($proxy->__isInitialized()) {
  187.                 return;
  188.             }
  190.             $properties = $proxy->__getLazyProperties();
  192.             foreach ($properties as $propertyName => $property) {
  193.                 if (! isset($proxy->$propertyName)) {
  194.                     $proxy->$propertyName = $properties[$propertyName];
  195.                 }
  196.             }
  198.             $proxy->__setInitialized(true);
  200.             if ($wakeupProxy) {
  201.                 $proxy->__wakeup();
  202.             }
  204.             $identifier = $classMetadata->getIdentifierValues($proxy);
  206.             if ($entityPersister->loadById($identifier, $proxy) === null) {
  207.                 $proxy->__setInitializer($initializer);
  208.                 $proxy->__setCloner($cloner);
  209.                 $proxy->__setInitialized(false);
  211.                 throw EntityNotFoundException::fromClassNameAndIdentifier(
  212.                     $classMetadata->getName(),
  213.                     $this->identifierFlattener->flattenIdentifier($classMetadata, $identifier)
  214.                 );
  215.             }
  216.         };
  217.     }
  219.     /**
  220.      * Creates a closure capable of initializing a proxy
  221.      *
  222.      * @return Closure(Proxy):void
  223.      *
  224.      * @throws EntityNotFoundException
  225.      */
  226.     private function createLazyInitializer(ClassMetadata $classMetadata, EntityPersister $entityPersister): Closure
  227.     {
  228.         return function (Proxy $proxy) use ($entityPersister, $classMetadata): void {
  229.             $identifier = $classMetadata->getIdentifierValues($proxy);
  230.             $entity     = $entityPersister->loadById($identifier, $proxy->__isCloning ? null : $proxy);
  232.             if ($entity === null) {
  233.                 throw EntityNotFoundException::fromClassNameAndIdentifier(
  234.                     $classMetadata->getName(),
  235.                     $this->identifierFlattener->flattenIdentifier($classMetadata, $identifier)
  236.                 );
  237.             }
  239.             if (! $proxy->__isCloning) {
  240.                 return;
  241.             }
  243.             $class = $entityPersister->getClassMetadata();
  245.             foreach ($class->getReflectionProperties() as $property) {
  246.                 if (! $class->hasField($property->name) && ! $class->hasAssociation($property->name)) {
  247.                     continue;
  248.                 }
  250.                 $property->setAccessible(true);
  251.                 $property->setValue($proxy, $property->getValue($entity));
  252.             }
  253.         };
  254.     }
  256.     /**
  257.      * Creates a closure capable of finalizing state a cloned proxy
  258.      *
  259.      * @psalm-return Closure(CommonProxy):void
  260.      *
  261.      * @throws EntityNotFoundException
  262.      */
  263.     private function createCloner(ClassMetadata $classMetadata, EntityPersister $entityPersister): Closure
  264.     {
  265.         return function (CommonProxy $proxy) use ($entityPersister, $classMetadata): void {
  266.             if ($proxy->__isInitialized()) {
  267.                 return;
  268.             }
  270.             $proxy->__setInitialized(true);
  271.             $proxy->__setInitializer(null);
  273.             $class      = $entityPersister->getClassMetadata();
  274.             $identifier = $classMetadata->getIdentifierValues($proxy);
  275.             $original   = $entityPersister->loadById($identifier);
  277.             if ($original === null) {
  278.                 throw EntityNotFoundException::fromClassNameAndIdentifier(
  279.                     $classMetadata->getName(),
  280.                     $this->identifierFlattener->flattenIdentifier($classMetadata, $identifier)
  281.                 );
  282.             }
  284.             foreach ($class->getReflectionProperties() as $property) {
  285.                 if (! $class->hasField($property->name) && ! $class->hasAssociation($property->name)) {
  286.                     continue;
  287.                 }
  289.                 $property->setAccessible(true);
  290.                 $property->setValue($proxy, $property->getValue($original));
  291.             }
  292.         };
  293.     }
  295.     private function generateUseLazyGhostTrait(ClassMetadata $class): string
  296.     {
  297.         $code = ProxyHelper::generateLazyGhost($class->getReflectionClass());
  298.         $code = substr($code, 7 + (int) strpos($code, "\n{"));
  299.         $code = substr($code, 0, (int) strpos($code, "\n}"));
  300.         $code = str_replace('LazyGhostTrait;', str_replace("\n    ", "\n", 'LazyGhostTrait {
  301.             initializeLazyObject as __load;
  302.             setLazyObjectAsInitialized as public __setInitialized;
  303.             isLazyObjectInitialized as private;
  304.             createLazyGhost as private;
  305.             resetLazyObject as private;
  306.             __clone as private __doClone;
  307.         }'), $code);
  309.         return $code;
  310.     }
  312.     private function generateSkippedProperties(ClassMetadata $class): string
  313.     {
  314.         $skippedProperties = ['__isCloning' => true];
  315.         $identifiers       = array_flip($class->getIdentifierFieldNames());
  317.         foreach ($class->getReflectionClass()->getProperties() as $property) {
  318.             $name = $property->getName();
  320.             if ($property->isStatic() || (($class->hasField($name) || $class->hasAssociation($name)) && ! isset($identifiers[$name]))) {
  321.                 continue;
  322.             }
  324.             $prefix = $property->isPrivate() ? "\0" . $property->getDeclaringClass()->getName() . "\0" : ($property->isProtected() ? "\0*\0" : '');
  326.             $skippedProperties[$prefix . $name] = true;
  327.         }
  329.         uksort($skippedProperties, 'strnatcmp');
  331.         $code = VarExporter::export($skippedProperties);
  332.         $code = str_replace(VarExporter::export($class->getName()), 'parent::class', $code);
  333.         $code = str_replace("\n", "\n        ", $code);
  335.         return $code;
  336.     }
  338.     private function generateSerializeImpl(ClassMetadata $class): string
  339.     {
  340.         $reflector  = $class->getReflectionClass();
  341.         $properties = $reflector->hasMethod('__serialize') ? 'parent::__serialize()' : '(array) $this';
  343.         $code = '$properties = ' . $properties . ';
  344.         unset($properties["\0" . self::class . "\0lazyObjectState"], $properties[\'__isCloning\']);
  346.         ';
  348.         if ($reflector->hasMethod('__serialize') || ! $reflector->hasMethod('__sleep')) {
  349.             return $code . 'return $properties;';
  350.         }
  352.         return $code . '$data = [];
  354.         foreach (parent::__sleep() as $name) {
  355.             $value = $properties[$k = $name] ?? $properties[$k = "\0*\0$name"] ?? $properties[$k = "\0' . $reflector->getName() . '\0$name"] ?? $k = null;
  357.             if (null === $k) {
  358.                 trigger_error(sprintf(\'serialize(): "%s" returned as member variable from __sleep() but does not exist\', $name), \E_USER_NOTICE);
  359.             } else {
  360.                 $data[$k] = $value;
  361.             }
  362.         }
  364.         return $data;';
  365.     }
  366. }