PHP EntityManagerInterface::getProxyFactory方法代码示例

 public function fire()
 {
     $this->info('Starting proxy generation....');
     // flush all generated and cached entities, etc
     \D2Cache::flushAll();
     try {
         $metadata = $this->d2em->getMetadataFactory()->getAllMetadata();
     } catch (\Doctrine\Common\Persistence\Mapping\MappingException $e) {
         if ($this->option('verbose') == 3) {
             throw $e;
         }
         $this->error("Caught Doctrine\\Common\\Persistence\\Mapping\\MappingException: " . $e->getMessage());
         $this->info("Re-optimizing:");
         $this->call('optimize');
         $this->comment("*** You must now rerun this artisan command ***");
         exit(-1);
     }
     if (empty($metadata)) {
         $this->error('No metadata found to generate entities.');
         return -1;
     }
     $directory = Config::get('d2doctrine.paths.proxies');
     if (!$directory) {
         $this->error('The proxy directory has not been set.');
         return -1;
     }
     $this->info('Processing entities:');
     foreach ($metadata as $item) {
         $this->line($item->name);
     }
     $this->d2em->getProxyFactory()->generateProxyClasses($metadata, $directory);
     $this->info('Proxies have been created.');
 }

 public function fire()
 {
     $this->info('Starting proxy generation....');
     $metadata = $this->entityManager->getMetadataFactory()->getAllMetadata();
     if (empty($metadata)) {
         $this->error('No metadata found to generate any entities.');
         exit;
     }
     $directory = $this->laravel['config']['doctrine::doctrine.proxy.directory'];
     if (!$directory) {
         $this->error('The proxy directory has not been set.');
         exit;
     }
     $this->info('Processing entities:');
     foreach ($metadata as $item) {
         $this->line($item->name);
     }
     $this->entityManager->getProxyFactory()->generateProxyClasses($metadata, $directory);
     $this->info('Proxies have been created.');
 }

 /**
  * @param object $entity
  * @param object $managedCopy
  *
  * @throws ORMException
  * @throws OptimisticLockException
  * @throws TransactionRequiredException
  */
 private function mergeEntityStateIntoManagedCopy($entity, $managedCopy)
 {
     $class = $this->em->getClassMetadata(get_class($entity));
     foreach ($this->reflectionPropertiesGetter->getProperties($class->name) as $prop) {
         $name = $prop->name;
         $prop->setAccessible(true);
         if (!isset($class->associationMappings[$name])) {
             if (!$class->isIdentifier($name)) {
                 $prop->setValue($managedCopy, $prop->getValue($entity));
             }
         } else {
             $assoc2 = $class->associationMappings[$name];
             if ($assoc2['type'] & ClassMetadata::TO_ONE) {
                 $other = $prop->getValue($entity);
                 if ($other === null) {
                     $prop->setValue($managedCopy, null);
                 } else {
                     if ($other instanceof Proxy && !$other->__isInitialized()) {
                         // do not merge fields marked lazy that have not been fetched.
                         return;
                     }
                     if (!$assoc2['isCascadeMerge']) {
                         if ($this->getEntityState($other) === self::STATE_DETACHED) {
                             $targetClass = $this->em->getClassMetadata($assoc2['targetEntity']);
                             $relatedId = $targetClass->getIdentifierValues($other);
                             if ($targetClass->subClasses) {
                                 $other = $this->em->find($targetClass->name, $relatedId);
                             } else {
                                 $other = $this->em->getProxyFactory()->getProxy($assoc2['targetEntity'], $relatedId);
                                 $this->registerManaged($other, $relatedId, array());
                             }
                         }
                         $prop->setValue($managedCopy, $other);
                     }
                 }
             } else {
                 $mergeCol = $prop->getValue($entity);
                 if ($mergeCol instanceof PersistentCollection && !$mergeCol->isInitialized()) {
                     // do not merge fields marked lazy that have not been fetched.
                     // keep the lazy persistent collection of the managed copy.
                     return;
                 }
                 $managedCol = $prop->getValue($managedCopy);
                 if (!$managedCol) {
                     $managedCol = new PersistentCollection($this->em, $this->em->getClassMetadata($assoc2['targetEntity']), new ArrayCollection());
                     $managedCol->setOwner($managedCopy, $assoc2);
                     $prop->setValue($managedCopy, $managedCol);
                     $this->originalEntityData[spl_object_hash($entity)][$name] = $managedCol;
                 }
                 if ($assoc2['isCascadeMerge']) {
                     $managedCol->initialize();
                     // clear and set dirty a managed collection if its not also the same collection to merge from.
                     if (!$managedCol->isEmpty() && $managedCol !== $mergeCol) {
                         $managedCol->unwrap()->clear();
                         $managedCol->setDirty(true);
                         if ($assoc2['isOwningSide'] && $assoc2['type'] == ClassMetadata::MANY_TO_MANY && $class->isChangeTrackingNotify()) {
                             $this->scheduleForDirtyCheck($managedCopy);
                         }
                     }
                 }
             }
         }
         if ($class->isChangeTrackingNotify()) {
             // Just treat all properties as changed, there is no other choice.
             $this->propertyChanged($managedCopy, $name, null, $prop->getValue($managedCopy));
         }
     }
 }

 /**
  * Sets up the database schema of an extension.
  *
  * Generates proxy classes for database entities and creates database schema.
  *
  * @param string $extensionNamespace Namespace of the extension to install the entities of
  * @param string $entityDirectory Directory where the entity classes are located
  * @param \Doctrine\ORM\EntityManagerInterface $entityManager Entity manager used to access the database
  * @throws \Doctrine\Common\Proxy\Exception\UnexpectedValueException
  * @throws \Doctrine\ORM\Tools\ToolsException
  * @return void
  */
 private function setUpDatabaseSchema($extensionNamespace, $entityDirectory, EntityManagerInterface $entityManager)
 {
     // get entity meta data
     $entityMetaData = array();
     foreach (new GlobIterator(sprintf('%s/*Entity.php', $entityDirectory)) as $entityFile) {
         $entityMetaData[] = $entityManager->getClassMetadata(sprintf('%s:%s', $extensionNamespace, $entityFile->getBasename('.php')));
     }
     // generate proxies + database schema
     if (!empty($entityMetaData)) {
         // generate proxy classes
         $entityManager->getProxyFactory()->generateProxyClasses($entityMetaData, ABLERON_DOCTRINE_PROXY_DIR);
         // create database schema
         (new SchemaTool($entityManager))->createSchema($entityMetaData);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function getProxyFactory()
 {
     return $this->wrapped->getProxyFactory();
 }

//.........这里部分代码省略.........
                     }
                 }
                 if (!$associatedId) {
                     // Foreign key is NULL
                     $class->reflFields[$field]->setValue($entity, null);
                     $this->originalEntityData[$oid][$field] = null;
                     continue;
                 }
                 if (!isset($hints['fetchMode'][$class->name][$field])) {
                     $hints['fetchMode'][$class->name][$field] = $assoc['fetch'];
                 }
                 // Foreign key is set
                 // Check identity map first
                 // FIXME: Can break easily with composite keys if join column values are in
                 //        wrong order. The correct order is the one in ClassMetadata#identifier.
                 $relatedIdHash = implode(' ', $associatedId);
                 switch (true) {
                     case isset($this->identityMap[$targetClass->rootEntityName][$relatedIdHash]):
                         $newValue = $this->identityMap[$targetClass->rootEntityName][$relatedIdHash];
                         // If this is an uninitialized proxy, we are deferring eager loads,
                         // this association is marked as eager fetch, and its an uninitialized proxy (wtf!)
                         // then we can append this entity for eager loading!
                         if ($hints['fetchMode'][$class->name][$field] == ClassMetadata::FETCH_EAGER && isset($hints[self::HINT_DEFEREAGERLOAD]) && !$targetClass->isIdentifierComposite && $newValue instanceof Proxy && $newValue->__isInitialized__ === false) {
                             $this->eagerLoadingEntities[$targetClass->rootEntityName][$relatedIdHash] = current($associatedId);
                         }
                         break;
                     case $targetClass->subClasses:
                         // If it might be a subtype, it can not be lazy. There isn't even
                         // a way to solve this with deferred eager loading, which means putting
                         // an entity with subclasses at a *-to-one location is really bad! (performance-wise)
                         $newValue = $this->getEntityPersister($assoc['targetEntity'])->loadOneToOneEntity($assoc, $entity, $associatedId);
                         break;
                     default:
                         switch (true) {
                             // We are negating the condition here. Other cases will assume it is valid!
                             case $hints['fetchMode'][$class->name][$field] !== ClassMetadata::FETCH_EAGER:
                                 $newValue = $this->em->getProxyFactory()->getProxy($assoc['targetEntity'], $associatedId);
                                 break;
                                 // Deferred eager load only works for single identifier classes
                             // Deferred eager load only works for single identifier classes
                             case isset($hints[self::HINT_DEFEREAGERLOAD]) && !$targetClass->isIdentifierComposite:
                                 // TODO: Is there a faster approach?
                                 $this->eagerLoadingEntities[$targetClass->rootEntityName][$relatedIdHash] = current($associatedId);
                                 $newValue = $this->em->getProxyFactory()->getProxy($assoc['targetEntity'], $associatedId);
                                 break;
                             default:
                                 // TODO: This is very imperformant, ignore it?
                                 $newValue = $this->em->find($assoc['targetEntity'], $associatedId);
                                 break;
                         }
                         // PERF: Inlined & optimized code from UnitOfWork#registerManaged()
                         $newValueOid = spl_object_hash($newValue);
                         $this->entityIdentifiers[$newValueOid] = $associatedId;
                         $this->identityMap[$targetClass->rootEntityName][$relatedIdHash] = $newValue;
                         if ($newValue instanceof NotifyPropertyChanged && (!$newValue instanceof Proxy || $newValue->__isInitialized())) {
                             $newValue->addPropertyChangedListener($this);
                         }
                         $this->entityStates[$newValueOid] = self::STATE_MANAGED;
                         // make sure that when an proxy is then finally loaded, $this->originalEntityData is set also!
                         break;
                 }
                 $this->originalEntityData[$oid][$field] = $newValue;
                 $class->reflFields[$field]->setValue($entity, $newValue);
                 if ($assoc['inversedBy'] && $assoc['type'] & ClassMetadata::ONE_TO_ONE) {
                     $inverseAssoc = $targetClass->associationMappings[$assoc['inversedBy']];
                     $targetClass->reflFields[$inverseAssoc['fieldName']]->setValue($newValue, $entity);
                 }
                 break;
             default:
                 // Ignore if its a cached collection
                 if (isset($hints[Query::HINT_CACHE_ENABLED]) && $class->getFieldValue($entity, $field) instanceof PersistentCollection) {
                     break;
                 }
                 // use the given collection
                 if (isset($data[$field]) && $data[$field] instanceof PersistentCollection) {
                     $data[$field]->setOwner($entity, $assoc);
                     $class->reflFields[$field]->setValue($entity, $data[$field]);
                     $this->originalEntityData[$oid][$field] = $data[$field];
                     break;
                 }
                 // Inject collection
                 $pColl = new PersistentCollection($this->em, $targetClass, new ArrayCollection());
                 $pColl->setOwner($entity, $assoc);
                 $pColl->setInitialized(false);
                 $reflField = $class->reflFields[$field];
                 $reflField->setValue($entity, $pColl);
                 if ($assoc['fetch'] == ClassMetadata::FETCH_EAGER) {
                     $this->loadCollection($pColl);
                     $pColl->takeSnapshot();
                 }
                 $this->originalEntityData[$oid][$field] = $pColl;
                 break;
         }
     }
     if ($overrideLocalValues) {
         // defer invoking of postLoad event to hydration complete step
         $this->hydrationCompleteHandler->deferPostLoadInvoking($class, $entity);
     }
     return $entity;
 }