PHP MappingException::entityListenerClassNotFound方法代码示例

 /**
  * Lookup the entity class to find methods that match to event lifecycle names
  *
  * @param \Doctrine\ORM\Mapping\ClassMetadata $metadata     The entity metadata.
  * @param string $className                                 The listener class name.
  *
  * @throws \Doctrine\ORM\Mapping\MappingException           When the listener class not found.
  */
 public static function bindEntityListener(ClassMetadata $metadata, $className)
 {
     $class = $metadata->fullyQualifiedClassName($className);
     if (!class_exists($class)) {
         throw MappingException::entityListenerClassNotFound($class, $className);
     }
     foreach (get_class_methods($class) as $method) {
         if (!isset(self::$events[$method])) {
             continue;
         }
         $metadata->addEntityListener($method, $class, $method);
     }
 }

 /**
  * Evaluate the EntityListeners annotation and amend the metadata accordingly.
  *
  * @param \ReflectionClass $class
  * @param OrmClassMetadata $metadata
  * @param array $classAnnotations
  * @return void
  * @throws MappingException
  */
 protected function evaluateEntityListenersAnnotation(\ReflectionClass $class, OrmClassMetadata $metadata, array $classAnnotations)
 {
     if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\EntityListeners'])) {
         $entityListenersAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\EntityListeners'];
         foreach ($entityListenersAnnotation->value as $item) {
             $listenerClassName = $metadata->fullyQualifiedClassName($item);
             if (!class_exists($listenerClassName)) {
                 throw MappingException::entityListenerClassNotFound($listenerClassName, $class->getName());
             }
             $hasMapping = false;
             foreach ($class->getMethods() as $method) {
                 if ($method->isPublic()) {
                     // find method callbacks.
                     $callbacks = $this->getMethodCallbacks($method);
                     $hasMapping = $hasMapping ?: !empty($callbacks);
                     foreach ($callbacks as $value) {
                         $metadata->addEntityListener($value[1], $listenerClassName, $value[0]);
                     }
                 }
             }
             // Evaluate the listener using naming convention.
             if ($hasMapping === false) {
                 EntityListenerBuilder::bindEntityListener($metadata, $listenerClassName);
             }
         }
     }
 }

//.........这里部分代码省略.........
                             $mapping['joinTable'] = $joinTable;
                             $mapping['targetEntity'] = $manyToManyAnnot->targetEntity;
                             $mapping['mappedBy'] = $manyToManyAnnot->mappedBy;
                             $mapping['inversedBy'] = $manyToManyAnnot->inversedBy;
                             $mapping['cascade'] = $manyToManyAnnot->cascade;
                             $mapping['indexBy'] = $manyToManyAnnot->indexBy;
                             $mapping['orphanRemoval'] = $manyToManyAnnot->orphanRemoval;
                             $mapping['fetch'] = $this->getFetchMode($className, $manyToManyAnnot->fetch);
                             if ($orderByAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\\ORM\\Mapping\\OrderBy')) {
                                 $mapping['orderBy'] = $orderByAnnot->value;
                             }
                             $metadata->mapManyToMany($mapping);
                         } else {
                             if ($embeddedAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\\ORM\\Mapping\\Embedded')) {
                                 $mapping['class'] = $embeddedAnnot->class;
                                 $mapping['columnPrefix'] = $embeddedAnnot->columnPrefix;
                                 $metadata->mapEmbedded($mapping);
                             }
                         }
                     }
                 }
             }
         }
     }
     // Evaluate AssociationOverrides annotation
     if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\AssociationOverrides'])) {
         $associationOverridesAnnot = $classAnnotations['Doctrine\\ORM\\Mapping\\AssociationOverrides'];
         foreach ($associationOverridesAnnot->value as $associationOverride) {
             $override = array();
             $fieldName = $associationOverride->name;
             // Check for JoinColumn/JoinColumns annotations
             if ($associationOverride->joinColumns) {
                 $joinColumns = array();
                 foreach ($associationOverride->joinColumns as $joinColumn) {
                     $joinColumns[] = $this->joinColumnToArray($joinColumn);
                 }
                 $override['joinColumns'] = $joinColumns;
             }
             // Check for JoinTable annotations
             if ($associationOverride->joinTable) {
                 $joinTableAnnot = $associationOverride->joinTable;
                 $joinTable = array('name' => $joinTableAnnot->name, 'schema' => $joinTableAnnot->schema);
                 foreach ($joinTableAnnot->joinColumns as $joinColumn) {
                     $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumn);
                 }
                 foreach ($joinTableAnnot->inverseJoinColumns as $joinColumn) {
                     $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumn);
                 }
                 $override['joinTable'] = $joinTable;
             }
             // Check for inversedBy
             if ($associationOverride->inversedBy) {
                 $override['inversedBy'] = $associationOverride->inversedBy;
             }
             $metadata->setAssociationOverride($fieldName, $override);
         }
     }
     // Evaluate AttributeOverrides annotation
     if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\AttributeOverrides'])) {
         $attributeOverridesAnnot = $classAnnotations['Doctrine\\ORM\\Mapping\\AttributeOverrides'];
         foreach ($attributeOverridesAnnot->value as $attributeOverrideAnnot) {
             $attributeOverride = $this->columnToArray($attributeOverrideAnnot->name, $attributeOverrideAnnot->column);
             $metadata->setAttributeOverride($attributeOverrideAnnot->name, $attributeOverride);
         }
     }
     // Evaluate EntityListeners annotation
     if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\EntityListeners'])) {
         $entityListenersAnnot = $classAnnotations['Doctrine\\ORM\\Mapping\\EntityListeners'];
         foreach ($entityListenersAnnot->value as $item) {
             $listenerClassName = $metadata->fullyQualifiedClassName($item);
             if (!class_exists($listenerClassName)) {
                 throw MappingException::entityListenerClassNotFound($listenerClassName, $className);
             }
             $hasMapping = false;
             $listenerClass = new \ReflectionClass($listenerClassName);
             /* @var $method \ReflectionMethod */
             foreach ($listenerClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
                 // find method callbacks.
                 $callbacks = $this->getMethodCallbacks($method);
                 $hasMapping = $hasMapping ?: !empty($callbacks);
                 foreach ($callbacks as $value) {
                     $metadata->addEntityListener($value[1], $listenerClassName, $value[0]);
                 }
             }
             // Evaluate the listener using naming convention.
             if (!$hasMapping) {
                 EntityListenerBuilder::bindEntityListener($metadata, $listenerClassName);
             }
         }
     }
     // Evaluate @HasLifecycleCallbacks annotation
     if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\HasLifecycleCallbacks'])) {
         /* @var $method \ReflectionMethod */
         foreach ($class->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
             foreach ($this->getMethodCallbacks($method) as $value) {
                 $metadata->addLifecycleCallback($value[0], $value[1]);
             }
         }
     }
 }

 /**
  * Adds a entity listener for entities of this class.
  *
  * @param string $eventName The entity lifecycle event.
  * @param string $class     The listener class.
  * @param string $method    The listener callback method.
  *
  * @throws \Doctrine\ORM\Mapping\MappingException
  */
 public function addEntityListener($eventName, $class, $method)
 {
     $class = $this->fullyQualifiedClassName($class);
     $listener = array('class' => $class, 'method' => $method);
     if (!class_exists($class)) {
         throw MappingException::entityListenerClassNotFound($class, $this->name);
     }
     if (!method_exists($class, $method)) {
         throw MappingException::entityListenerMethodNotFound($class, $method, $this->name);
     }
     if (isset($this->entityListeners[$eventName]) && in_array($listener, $this->entityListeners[$eventName])) {
         throw MappingException::duplicateEntityListener($class, $method, $this->name);
     }
     $this->entityListeners[$eventName][] = $listener;
 }