PHP ClassMetadata::invokeLifecycleCallbacks方法代码示例

 /**
  * Refreshes a managed entity.
  *
  * @param array $id The identifier of the entity as an associative array from
  *                  column or field names to values.
  * @param object $entity The entity to refresh.
  */
 public function refresh(array $id, $entity)
 {
     $sql = $this->_getSelectEntitiesSQL($id);
     list($params, $types) = $this->expandParameters($id);
     $stmt = $this->_conn->executeQuery($sql, $params, $types);
     $hydrator = $this->_em->newHydrator(Query::HYDRATE_OBJECT);
     $hydrator->hydrateAll($stmt, $this->_rsm, array(Query::HINT_REFRESH => true));
     if (isset($this->_class->lifecycleCallbacks[Events::postLoad])) {
         $this->_class->invokeLifecycleCallbacks(Events::postLoad, $entity);
     }
     $evm = $this->_em->getEventManager();
     if ($evm->hasListeners(Events::postLoad)) {
         $evm->dispatchEvent(Events::postLoad, new LifecycleEventArgs($entity, $this->_em));
     }
 }

 /**
  * {@inheritdoc}
  */
 protected function hydrateRowData(array $sqlResult, array &$cache, array &$result)
 {
     $entityName = $this->class->name;
     $data = array();
     // We need to find the correct entity class name if we have inheritance in resultset
     if ($this->class->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
         $discrColumnName = $this->_platform->getSQLResultCasing($this->class->discriminatorColumn['name']);
         if ($sqlResult[$discrColumnName] === '') {
             throw HydrationException::emptyDiscriminatorValue(key($this->_rsm->aliasMap));
         }
         $entityName = $this->class->discriminatorMap[$sqlResult[$discrColumnName]];
         unset($sqlResult[$discrColumnName]);
     }
     foreach ($sqlResult as $column => $value) {
         // Hydrate column information if not yet present
         if (!isset($cache[$column])) {
             if (($info = $this->hydrateColumnInfo($entityName, $column)) === null) {
                 continue;
             }
             $cache[$column] = $info;
         }
         // Convert field to a valid PHP value
         if (isset($cache[$column]['field'])) {
             $type = Type::getType($cache[$column]['class']->fieldMappings[$cache[$column]['name']]['type']);
             $value = $type->convertToPHPValue($value, $this->_platform);
         }
         // Prevent overwrite in case of inherit classes using same property name (See AbstractHydrator)
         if (isset($cache[$column]) && (!isset($data[$cache[$column]['name']]) || $value !== null)) {
             $data[$cache[$column]['name']] = $value;
         }
     }
     if (isset($this->_hints[Query::HINT_REFRESH_ENTITY])) {
         $this->registerManaged($this->class, $this->_hints[Query::HINT_REFRESH_ENTITY], $data);
     }
     $uow = $this->_em->getUnitOfWork();
     $entity = $uow->createEntity($entityName, $data, $this->_hints);
     //TODO: These should be invoked later, after hydration, because associations may not yet be loaded here.
     if (isset($this->class->lifecycleCallbacks[Events::postLoad])) {
         $this->class->invokeLifecycleCallbacks(Events::postLoad, $entity);
     }
     $evm = $this->_em->getEventManager();
     if ($evm->hasListeners(Events::postLoad)) {
         $evm->dispatchEvent(Events::postLoad, new LifecycleEventArgs($entity, $this->_em));
     }
     $result[] = $entity;
 }

 /**
  * Executes all entity deletions for entities of the specified type.
  *
  * @param Doctrine\ORM\Mapping\ClassMetadata $class
  */
 private function executeDeletions($class)
 {
     $className = $class->name;
     $persister = $this->getEntityPersister($className);
     $hasLifecycleCallbacks = isset($class->lifecycleCallbacks[Events::postRemove]);
     $hasListeners = $this->evm->hasListeners(Events::postRemove);
     foreach ($this->entityDeletions as $oid => $entity) {
         if (get_class($entity) == $className || $entity instanceof Proxy && $entity instanceof $className) {
             $persister->delete($entity);
             unset($this->entityDeletions[$oid], $this->entityIdentifiers[$oid], $this->originalEntityData[$oid], $this->entityStates[$oid]);
             // Entity with this $oid after deletion treated as NEW, even if the $oid
             // is obtained by a new entity because the old one went out of scope.
             //$this->entityStates[$oid] = self::STATE_NEW;
             if (!$class->isIdentifierNatural()) {
                 $class->reflFields[$class->identifier[0]]->setValue($entity, null);
             }
             if ($hasLifecycleCallbacks) {
                 $class->invokeLifecycleCallbacks(Events::postRemove, $entity);
             }
             if ($hasListeners) {
                 $this->evm->dispatchEvent(Events::postRemove, new LifecycleEventArgs($entity, $this->em));
             }
         }
     }
 }

 /**
  * Refreshes a managed entity.
  * 
  * @param array $id The identifier of the entity as an associative array from
  *                  column or field names to values.
  * @param object $entity The entity to refresh.
  */
 public function refresh(array $id, $entity)
 {
     $sql = $this->_getSelectEntitiesSQL($id);
     list($params, $types) = $this->expandParameters($id);
     $stmt = $this->_conn->executeQuery($sql, $params, $types);
     $result = $stmt->fetch(PDO::FETCH_ASSOC);
     $stmt->closeCursor();
     $metaColumns = array();
     $newData = array();
     // Refresh simple state
     foreach ($result as $column => $value) {
         $column = $this->_resultColumnNames[$column];
         if (isset($this->_class->fieldNames[$column])) {
             $fieldName = $this->_class->fieldNames[$column];
             $newValue = $this->_conn->convertToPHPValue($value, $this->_class->fieldMappings[$fieldName]['type']);
             $this->_class->reflFields[$fieldName]->setValue($entity, $newValue);
             $newData[$fieldName] = $newValue;
         } else {
             $metaColumns[$column] = $value;
         }
     }
     // Refresh associations
     foreach ($this->_class->associationMappings as $field => $assoc) {
         $value = $this->_class->reflFields[$field]->getValue($entity);
         if ($assoc['type'] & ClassMetadata::TO_ONE) {
             if ($value instanceof Proxy && !$value->__isInitialized__) {
                 continue;
                 // skip uninitialized proxies
             }
             if ($assoc['isOwningSide']) {
                 $joinColumnValues = array();
                 foreach ($assoc['targetToSourceKeyColumns'] as $targetColumn => $srcColumn) {
                     if ($metaColumns[$srcColumn] !== null) {
                         $joinColumnValues[$targetColumn] = $metaColumns[$srcColumn];
                     }
                 }
                 if (!$joinColumnValues && $value !== null) {
                     $this->_class->reflFields[$field]->setValue($entity, null);
                     $newData[$field] = null;
                 } else {
                     if ($value !== null) {
                         // Check identity map first, if the entity is not there,
                         // place a proxy in there instead.
                         $targetClass = $this->_em->getClassMetadata($assoc['targetEntity']);
                         if ($found = $this->_em->getUnitOfWork()->tryGetById($joinColumnValues, $targetClass->rootEntityName)) {
                             $this->_class->reflFields[$field]->setValue($entity, $found);
                             // Complete inverse side, if necessary.
                             if ($assoc['inversedBy'] && $assoc['type'] & ClassMetadata::ONE_TO_ONE) {
                                 $inverseAssoc = $targetClass->associationMappings[$assoc['inversedBy']];
                                 $targetClass->reflFields[$inverseAssoc['fieldName']]->setValue($found, $entity);
                             }
                             $newData[$field] = $found;
                         } else {
                             // FIXME: What is happening with subClassees here?
                             $proxy = $this->_em->getProxyFactory()->getProxy($assoc['targetEntity'], $joinColumnValues);
                             $this->_class->reflFields[$field]->setValue($entity, $proxy);
                             $newData[$field] = $proxy;
                             $this->_em->getUnitOfWork()->registerManaged($proxy, $joinColumnValues, array());
                         }
                     }
                 }
             } else {
                 // Inverse side of 1-1/1-x can never be lazy.
                 //$newData[$field] = $assoc->load($entity, null, $this->_em);
                 $newData[$field] = $this->_em->getUnitOfWork()->getEntityPersister($assoc['targetEntity'])->loadOneToOneEntity($assoc, $entity, null);
             }
         } else {
             if ($value instanceof PersistentCollection && $value->isInitialized()) {
                 $value->setInitialized(false);
                 // no matter if dirty or non-dirty entities are already loaded, smoke them out!
                 // the beauty of it being, they are still in the identity map
                 $value->unwrap()->clear();
                 $newData[$field] = $value;
             }
         }
     }
     $this->_em->getUnitOfWork()->setOriginalEntityData($entity, $newData);
     if (isset($this->_class->lifecycleCallbacks[Events::postLoad])) {
         $this->_class->invokeLifecycleCallbacks(Events::postLoad, $entity);
     }
     $evm = $this->_em->getEventManager();
     if ($evm->hasListeners(Events::postLoad)) {
         $evm->dispatchEvent(Events::postLoad, new LifecycleEventArgs($entity, $this->_em));
     }
 }