vendor/doctrine/common/src/Proxy/AbstractProxyFactory.php line 184

  1. <?php
  3. namespace Doctrine\Common\Proxy;
  5. use Doctrine\Common\Proxy\Exception\InvalidArgumentException;
  6. use Doctrine\Common\Proxy\Exception\OutOfBoundsException;
  7. use Doctrine\Common\Util\ClassUtils;
  8. use Doctrine\Persistence\Mapping\ClassMetadata;
  9. use Doctrine\Persistence\Mapping\ClassMetadataFactory;
  11. use function class_exists;
  12. use function file_exists;
  13. use function filemtime;
  14. use function in_array;
  16. /**
  17.  * Abstract factory for proxy objects.
  18.  */
  19. abstract class AbstractProxyFactory
  20. {
  21.     /**
  22.      * Never autogenerate a proxy and rely that it was generated by some
  23.      * process before deployment.
  24.      */
  25.     public const AUTOGENERATE_NEVER = 0;
  27.     /**
  28.      * Always generates a new proxy in every request.
  29.      *
  30.      * This is only sane during development.
  31.      */
  32.     public const AUTOGENERATE_ALWAYS = 1;
  34.     /**
  35.      * Autogenerate the proxy class when the proxy file does not exist.
  36.      *
  37.      * This strategy causes a file_exists() call whenever any proxy is used the
  38.      * first time in a request.
  39.      */
  40.     public const AUTOGENERATE_FILE_NOT_EXISTS = 2;
  42.     /**
  43.      * Generate the proxy classes using eval().
  44.      *
  45.      * This strategy is only sane for development, and even then it gives me
  46.      * the creeps a little.
  47.      */
  48.     public const AUTOGENERATE_EVAL = 3;
  50.     /**
  51.      * Autogenerate the proxy class when the proxy file does not exist or
  52.      * when the proxied file changed.
  53.      *
  54.      * This strategy causes a file_exists() call whenever any proxy is used the
  55.      * first time in a request. When the proxied file is changed, the proxy will
  56.      * be updated.
  57.      */
  58.     public const AUTOGENERATE_FILE_NOT_EXISTS_OR_CHANGED = 4;
  60.     private const AUTOGENERATE_MODES = [
  61.         self::AUTOGENERATE_NEVER,
  62.         self::AUTOGENERATE_ALWAYS,
  63.         self::AUTOGENERATE_FILE_NOT_EXISTS,
  64.         self::AUTOGENERATE_EVAL,
  65.         self::AUTOGENERATE_FILE_NOT_EXISTS_OR_CHANGED,
  66.     ];
  68.     /** @var ClassMetadataFactory */
  69.     private $metadataFactory;
  71.     /** @var ProxyGenerator the proxy generator responsible for creating the proxy classes/files. */
  72.     private $proxyGenerator;
  74.     /** @var int Whether to automatically (re)generate proxy classes. */
  75.     private $autoGenerate;
  77.     /** @var ProxyDefinition[] */
  78.     private $definitions = [];
  80.     /**
  81.      * @param bool|int $autoGenerate
  82.      *
  83.      * @throws InvalidArgumentException When auto generate mode is not valid.
  84.      */
  85.     public function __construct(ProxyGenerator $proxyGenerator, ClassMetadataFactory $metadataFactory, $autoGenerate)
  86.     {
  87.         $this->proxyGenerator  = $proxyGenerator;
  88.         $this->metadataFactory = $metadataFactory;
  89.         $this->autoGenerate    = (int) $autoGenerate;
  91.         if (! in_array($this->autoGenerate, self::AUTOGENERATE_MODES, true)) {
  92.             throw InvalidArgumentException::invalidAutoGenerateMode($autoGenerate);
  93.         }
  94.     }
  96.     /**
  97.      * Gets a reference proxy instance for the entity of the given type and identified by
  98.      * the given identifier.
  99.      *
  100.      * @param  string       $className
  101.      * @param  array<mixed> $identifier
  102.      *
  103.      * @return Proxy
  104.      *
  105.      * @throws OutOfBoundsException
  106.      */
  107.     public function getProxy($className, array $identifier)
  108.     {
  109.         $definition = $this->definitions[$className] ?? $this->getProxyDefinition($className);
  110.         $fqcn       = $definition->proxyClassName;
  111.         $proxy      = new $fqcn($definition->initializer, $definition->cloner);
  113.         foreach ($definition->identifierFields as $idField) {
  114.             if (! isset($identifier[$idField])) {
  115.                 throw OutOfBoundsException::missingPrimaryKeyValue($className, $idField);
  116.             }
  118.             $definition->reflectionFields[$idField]->setValue($proxy, $identifier[$idField]);
  119.         }
  121.         return $proxy;
  122.     }
  124.     /**
  125.      * Generates proxy classes for all given classes.
  126.      *
  127.      * @param ClassMetadata[] $classes  The classes (ClassMetadata instances)
  128.      *  for which to generate proxies.
  129.      * @param string          $proxyDir The target directory of the proxy classes. If not specified, the
  130.      *                                  directory configured on the Configuration of the EntityManager used
  131.      *                                  by this factory is used.
  132.      *
  133.      * @return int Number of generated proxies.
  134.      */
  135.     public function generateProxyClasses(array $classes, $proxyDir = null)
  136.     {
  137.         $generated = 0;
  139.         foreach ($classes as $class) {
  140.             if ($this->skipClass($class)) {
  141.                 continue;
  142.             }
  144.             $proxyFileName = $this->proxyGenerator->getProxyFileName($class->getName(), $proxyDir);
  146.             $this->proxyGenerator->generateProxyClass($class, $proxyFileName);
  148.             $generated += 1;
  149.         }
  151.         return $generated;
  152.     }
  154.     /**
  155.      * Reset initialization/cloning logic for an un-initialized proxy
  156.      *
  157.      * @return Proxy
  158.      *
  159.      * @throws InvalidArgumentException
  160.      */
  161.     public function resetUninitializedProxy(Proxy $proxy)
  162.     {
  163.         if ($proxy->__isInitialized()) {
  164.             throw InvalidArgumentException::unitializedProxyExpected($proxy);
  165.         }
  167.         $className  = ClassUtils::getClass($proxy);
  168.         $definition = $this->definitions[$className] ?? $this->getProxyDefinition($className);
  170.         $proxy->__setInitializer($definition->initializer);
  171.         $proxy->__setCloner($definition->cloner);
  173.         return $proxy;
  174.     }
  176.     /**
  177.      * Get a proxy definition for the given class name.
  178.      *
  179.      * @param string $className
  180.      * @psalm-param class-string $className
  181.      *
  182.      * @return ProxyDefinition
  183.      */
  184.     private function getProxyDefinition($className)
  185.     {
  186.         $classMetadata = $this->metadataFactory->getMetadataFor($className);
  187.         $className     = $classMetadata->getName(); // aliases and case sensitivity
  189.         $this->definitions[$className] = $this->createProxyDefinition($className);
  190.         $proxyClassName                = $this->definitions[$className]->proxyClassName;
  192.         if (! class_exists($proxyClassName, false)) {
  193.             $fileName = $this->proxyGenerator->getProxyFileName($className);
  195.             switch ($this->autoGenerate) {
  196.                 case self::AUTOGENERATE_NEVER:
  197.                     require $fileName;
  198.                     break;
  200.                 case self::AUTOGENERATE_FILE_NOT_EXISTS:
  201.                     if (! file_exists($fileName)) {
  202.                         $this->proxyGenerator->generateProxyClass($classMetadata, $fileName);
  203.                     }
  205.                     require $fileName;
  206.                     break;
  208.                 case self::AUTOGENERATE_ALWAYS:
  209.                     $this->proxyGenerator->generateProxyClass($classMetadata, $fileName);
  210.                     require $fileName;
  211.                     break;
  213.                 case self::AUTOGENERATE_EVAL:
  214.                     $this->proxyGenerator->generateProxyClass($classMetadata, false);
  215.                     break;
  217.                 case self::AUTOGENERATE_FILE_NOT_EXISTS_OR_CHANGED:
  218.                     if (! file_exists($fileName) || filemtime($fileName) < filemtime($classMetadata->getReflectionClass()->getFileName())) {
  219.                         $this->proxyGenerator->generateProxyClass($classMetadata, $fileName);
  220.                     }
  222.                     require $fileName;
  223.                     break;
  224.             }
  225.         }
  227.         return $this->definitions[$className];
  228.     }
  230.     /**
  231.      * Determine if this class should be skipped during proxy generation.
  232.      *
  233.      * @return bool
  234.      */
  235.     abstract protected function skipClass(ClassMetadata $metadata);
  237.     /**
  238.      * @param string $className
  239.      * @psalm-param class-string $className
  240.      *
  241.      * @return ProxyDefinition
  242.      */
  243.     abstract protected function createProxyDefinition($className);
  244. }