PHP ReflectionObject::getConstructor方法代码示例

 /**
  * Call the event's constructor using serialized data
  */
 public function unserialize($data)
 {
     $data = unserialize($data);
     $class = new \ReflectionObject($this);
     $params = $class->getConstructor()->getParameters();
     $pass = array();
     // Iterate through all the parameters of the constructor and try to
     // locate the value for each one in the serialized data
     foreach ($params as $param) {
         if (isset($data[$param->getName()])) {
             $value = $data[$param->getName()];
             // If the serialized data contained a model's ID (and type),
             // pass a new instance of it
             if ($this->isModel($param)) {
                 if ($param->getClass()->isInstantiable()) {
                     $value = $param->getClass()->newInstance($value);
                 } else {
                     $id = $value['id'];
                     $type = $value['type'];
                     $value = new $type($id);
                 }
             }
         } else {
             $value = null;
         }
         $pass[$param->getName()] = $value;
     }
     $class->getConstructor()->invokeArgs($this, $pass);
 }

 /**
  * @param string $className
  * @param $document
  *
  * @throws \Exception
  *
  * @return mixed
  */
 public function hydrate($className, $document)
 {
     $reflClass = new ReflectionClass($className);
     $this->parser->validateClassAnnotation($reflClass);
     $propertyAnnotations = $this->parser->getProperties($reflClass);
     $propertyTypes = $this->parser->getPropertyTypes($reflClass);
     if (is_string($document)) {
         $document = (array) json_decode($document);
     }
     $hydrated = $reflClass->newInstanceWithoutConstructor();
     $reflection = new \ReflectionObject($hydrated);
     $constructor = $reflection->getConstructor();
     if ($constructor) {
         $constructor->setAccessible(true);
         $constructor->invoke($hydrated);
     }
     foreach ($document as $field => $value) {
         if (is_array($value)) {
             $hydrated->{$field} = $value;
         }
         $this->setIdIfPresent($field, $value, $reflClass, $propertyTypes, $hydrated);
         if ($this->propertyCanBeSet($hydrated, $field, $propertyAnnotations)) {
             $field = $propertyAnnotations[$field];
             $type = $propertyTypes[$field];
             $value = $this->coerceValue($type, $value);
             $setter = $this->getSetterMethod($field);
             $hydrated->{$setter}($value);
         }
     }
     return $hydrated;
 }

class B
{
    function B()
    {
    }
}
class C extends B
{
    function C()
    {
    }
}
class D1 extends C
{
    function __construct()
    {
    }
}
class D2 extends C
{
}
$classes = array('NewCtor', 'ExtendsNewCtor', 'OldCtor', 'ExtendsOldCtor', 'OldAndNewCtor', 'NewAndOldCtor', 'B', 'C', 'D1', 'D2', 'X', 'Y');
foreach ($classes as $class) {
    $rc = new ReflectionObject(new $class());
    $rm = $rc->getConstructor();
    if ($rm != null) {
        echo "Constructor of {$class}: " . $rm->getName() . "\n";
    } else {
        echo "No constructor for {$class}\n";
    }
}

<?php

class C
{
}
$rc = new ReflectionObject(new C());
var_dump($rc->getConstructor(null));
var_dump($rc->getConstructor('X'));
var_dump($rc->getConstructor(true));
var_dump($rc->getConstructor(array(1, 2, 3)));

 /**
  * @throws \Exception
  * @param mixed $callable
  * @return mixed
  */
 public function invoke($callable)
 {
     if (!is_callable($callable, true)) {
         throw new \Exception("Not a callable");
     }
     $result = null;
     if (is_array($callable) && count($callable) === 2) {
         $instance = $callable[0];
         if (is_string($instance)) {
             $instance = $this->getDependency($instance);
         }
         $methodName = $callable[1];
         $object = new \ReflectionObject($instance);
         $methodName === "__construct" ? $method = $object->getConstructor() : ($method = $object->getMethod($methodName));
         if ($method !== null) {
             $method->setAccessible(true);
             $dependencies = $this->getDependenciesForFunctionOrMethod($method);
             $result = $method->invokeArgs($instance, $dependencies);
         }
     } else {
         $function = new \ReflectionFunction($callable);
         $dependencies = $this->getDependenciesForFunctionOrMethod($function);
         $result = $function->invokeArgs($dependencies);
     }
     return $result;
 }

 /**
  * @param $param
  * @param \ReflectionObject $reflection
  */
 private function buildFromObject($param, $reflection = null)
 {
     foreach ($param as $key => $value) {
         $this->object['Object default'][$key] = $value;
     }
     // Get info on the object
     $this->object['Reflection']['In namespace'] = $reflection->inNamespace() ? 'Yes' : 'No';
     if ($reflection->inNamespace()) {
         $this->object['Class namespace'] = $reflection->getNamespaceName();
     }
     $this->object['Reflection']['Class name'] = $reflection->getName();
     $this->object['Reflection']['Is internal'] = $reflection->isInternal() ? 'Yes' : 'No';
     $this->object['Reflection']['Is iterable'] = $reflection->isIterateable() ? 'Yes' : 'No';
     $this->object['Reflection']['Is abstract'] = $reflection->isAbstract() ? 'Yes' : 'No';
     $this->object['Reflection']['Is final'] = $reflection->isFinal() ? 'Yes' : 'No';
     $this->object['Reflection']['Is user defined'] = $reflection->isUserDefined() ? 'Yes' : 'No';
     $this->object['Reflection']['Is instantiable'] = $reflection->isInstantiable() ? 'Yes' : 'No';
     $this->object['Reflection']['Is clonable'] = $reflection->isCloneable() ? 'Yes' : 'No';
     $this->object['Reflection']['Is interface'] = $reflection->isInterface() ? 'Yes' : 'No';
     $this->object['Reflection']['Class constants'] = !empty($reflection->getConstants()) ? $reflection->getConstants() : 'Class has no constants';
     $this->object['Reflection']['Class static properties'] = !empty($reflection->getStaticProperties()) ? $reflection->getStaticProperties() : 'Class has no static properties';
     $this->object['Reflection']['Class default properties'] = !empty($reflection->getDefaultProperties()) ? $reflection->getDefaultProperties() : 'Class has no default properties';
     if (null === $reflection->getConstructor()) {
         $this->object['Reflection']['Class construct'] = 'Class has no construct.';
     } else {
         $this->object['Reflection']['Class construct'] = $reflection->getConstructor();
     }
     $this->object['Reflection']['Class interfaces'] = !empty($reflection->getInterfaces()) ? $reflection->getInterfaces() : 'Class implements no interfaces';
     $this->object['Reflection']['Class traits'] = !empty($reflection->getTraits()) ? $reflection->getTraits() : 'Class has no traits';
     $this->object['Reflection']['Class parent'] = $reflection->getParentClass() !== false ? $reflection->getParentClass() : 'Class has no parent';
     if (false === $reflection->getFileName()) {
         $this->object['Reflection']['Defined in'] = 'Class is internal, no definition to provide.';
     } else {
         $this->object['Reflection']['Defined in'] = $reflection->getFileName();
     }
     if (false === $reflection->getFileName()) {
         $this->object['Reflection']['Start line'] = 'Class is internal, no start line to provide.';
     } else {
         $this->object['Reflection']['Start line'] = $reflection->getFileName();
     }
     if (false === $reflection->getEndLine()) {
         $this->object['Reflection']['End line'] = 'Class is internal, no end line to provide.';
     } else {
         $this->object['Reflection']['End line'] = $reflection->getEndLine();
     }
     if (false === $reflection->getDocComment()) {
         $this->object['Reflection']['Doc comments'] = 'No documents to provide.';
     } else {
         $this->object['Reflection']['Doc comments'] = $reflection->getDocComment();
     }
     // End get info
     $this->html .= "<span class=\"js-parent-object\">";
     if (!empty($this->object['Object default'])) {
         $this->html .= "<div class=\"js-object-default-tab \"><button class=\"button-reflection button\">Show reflection</button></div>";
         $this->html .= "<div class=\"js-object-default \">";
         $this->buildFromObjectIterationInformationRecursive($this->object['Object default']);
         $this->html .= "</div>";
     }
     if ($param instanceof \Closure) {
         $this->html .= "<div class=\"js-object-default-tab \"><button class=\"button-reflection button\">Show reflection</button></div>";
         $this->html .= "<div class=\"js-object-default \">";
         $this->html .= "<span class=\"css-type-string\">Nothing here...</span>";
         $this->html .= "</div>";
     }
     $this->html .= "<div class=\"js-object-reflection-tab hide\"><button class=\"button-class-default button\">Show default</button></div>";
     $this->html .= "<div class=\"js-object-reflection hide\">";
     $this->buildFromObjectReflectionInformationRecursive($this->object['Reflection']);
     $this->html .= "</div>";
     $this->html .= "</span>";
     $this->object = [];
 }

 /**
  * Parse a fetched row, using fetch mode.
  * This method also populates bound columns.
  * @param array $row Fetched row to parse
  * @param FetchMode $fetchmode Fetch mode to use
  * @return mixed Fetched row, after transformation and parsing based on fetch mode
  */
 private final function parseFetched(array $row, FetchMode $fetchmode)
 {
     foreach ($row as $tag => $value) {
         if (isset($this->parameters[$tag])) {
             $param =& $this->parameters[$tag]['param'];
             $type = $this->parameters[$tag]['type'];
             $param = $this->connection->quote($value, $type);
         }
     }
     if ($fetchmode->hasMode(DB::FETCH_BOTH)) {
         return array_merge($row, array_values($row));
     }
     if ($fetchmode->hasMode(DB::FETCH_ASSOC)) {
         return $row;
     }
     if ($fetchmode->hasMode(DB::FETCH_NUM)) {
         return array_values($row);
     }
     if ($fetchmode->hasMode(DB::FETCH_COLUMN)) {
         $values = array_values($row);
         return isset($values[$fetchmode->col]) ? $values[$fetchmode->col] : null;
     }
     if ($fetchmode->hasMode(DB::FETCH_OBJ)) {
         return (object) $row;
     }
     if ($fetchmode->hasMode(DB::FETCH_CLASS)) {
         $classname = $fetchmode->hasMode(DB::FETCH_CLASSTYPE) ? array_shift($row) : $fetchmode->classname;
         $refl = new \ReflectionClass($classname);
         $obj = $fetchmode->hasMode(DB::FETCH_PROPS_EARLY) ? $refl->newInstanceWithoutConstructor() : $refl->newInstanceArgs($fetchmode->ctor_args);
         $refl = new \ReflectionObject($obj);
         foreach ($row as $tag => $value) {
             if ($refl->hasProperty($tag)) {
                 $refl->getProperty($tag)->setValue($obj, $value);
             } else {
                 $obj->{$tag} = $value;
             }
         }
         if ($fetchmode->hasMode(DB::FETCH_PROPS_EARLY)) {
             $refl->getConstructor()->invokeArgs($obj, $fetchmode->ctor_args);
         }
         return $obj;
     }
     if ($fetchmode->hasMode(DB::FETCH_INTO)) {
         $refl = new \ReflectionObject($fetchmode->obj);
         foreach ($row as $tag => $value) {
             if ($refl->hasProperty($tag)) {
                 $refl->getProperty($tag)->setValue($obj, $value);
             } else {
                 $obj->{$tag} = $value;
             }
         }
     }
 }