public function create($component, array $args = [], $forceNewInstance = false, $share = [])
{
if (!$forceNewInstance && isset($this->instances[$component])) {
return $this->instances[$component];
}
if (empty($this->cache[$component])) {
$rule = $this->getRule($component);
$class = new \ReflectionClass($rule->instanceOf ? $rule->instanceOf : $component);
$constructor = $class->getConstructor();
$params = $constructor ? $this->getParams($constructor, $rule) : null;
$this->cache[$component] = function ($args) use($component, $rule, $class, $constructor, $params, $share) {
if ($rule->shared) {
if ($constructor) {
try {
$this->instances[$component] = $object = $class->newInstanceWithoutConstructor();
$constructor->invokeArgs($object, $params($args, $share));
} catch (\ReflectionException $r) {
$this->instances[$component] = $object = $class->newInstanceArgs($params($args, $share));
}
} else {
$this->instances[$component] = $object = $class->newInstanceWithoutConstructor();
}
} else {
$object = $params ? $class->newInstanceArgs($params($args, $share)) : new $class->name();
}
if ($rule->call) {
foreach ($rule->call as $call) {
$class->getMethod($call[0])->invokeArgs($object, call_user_func($this->getParams($class->getMethod($call[0]), $rule), $this->expand($call[1])));
}
}
return $object;
};
}
return $this->cache[$component]($args);
}
public function testGenerator()
{
if (!self::$dbh) {
$this->markTestSkipped('The mysql database isn\'t available, check config and server.');
}
$generator = new \Snok\EntityGenerator(self::$dbh, "Test\\Snok\\Entity", __DIR__ . "/Entity");
$generator->generateAll();
require_once __DIR__ . "/Entity/Address.php";
$reflection = new \ReflectionClass("\\Test\\Snok\\Entity\\Address");
$instance = $reflection->newInstanceWithoutConstructor();
$this->setupEntity($instance);
$instance->firstname = "John";
$instance->lastname = "Logan";
$instance->address = "123 Ground street";
$instance->district = "Harlem";
$instance->city = "Detroit";
$instance->phone = "555-1234";
$instance->commit();
$instance2 = $reflection->newInstanceWithoutConstructor();
$this->setupEntity($instance2);
$this->assertNull($instance2->address_id);
$this->assertNull($instance2->firstname);
$instance2->address_id = $instance->address_id;
$instance2->refresh();
$this->assertEquals("John", $instance2->firstname, "When adding a name to an object with auto increment name should be returned");
unlink(__DIR__ . "/Entity/Address.php");
}
/**
* Injects the data in the class
* @param object $object The object to inject the data in
* @return object The instanciated class with its loaded properties
*/
public function injectData($object = null)
{
if ($object !== null) {
$reflection = new \ReflectionClass($object);
if ($reflection->getParentClass()->name !== $this->reflection->name) {
throw new \LogicException('You can only inject data in a class of the same type');
}
$class = $object;
} else {
$reflection = $this->reflection;
$class = $this->reflection->newInstanceWithoutConstructor();
}
foreach ($this->data as $key => $value) {
$prop = $reflection->getProperty($key);
$prop->setAccessible(true);
// When the value given only is a reference, load it.
if ($value instanceof Reference) {
$value = $value->loadRef();
} elseif (is_array($value)) {
$value = self::injectDataInArray($value);
}
$prop->setValue($class, $value);
}
return $class;
}
/**
* Get the interactor name
*
* @return mixed
*
* @throws Exception\NonInteractorException
*/
public function getInteractorName()
{
if (!$this->isInteractor()) {
throw new NonInteractorException($this->file->getFilename());
}
$method = $this->reflection->getMethod(self::NAME_GETTER_METHOD);
return $method->invoke($this->reflection->newInstanceWithoutConstructor(), self::NAME_GETTER_METHOD);
}
/**
* @param array $array
* @return static
*/
public static function createFromArray(array $array)
{
$reflection = new \ReflectionClass(static::class);
$object = $reflection->newInstanceWithoutConstructor();
$object->fromArray($array);
return $object;
}
/**
* @param object $entity
*
* @return MetaInformation
*
* @throws \RuntimeException if no declaration for document found in $entity
*/
public function loadInformation($entity)
{
$className = $this->getClass($entity);
if (!is_object($entity)) {
$reflectionClass = new \ReflectionClass($className);
if (!$reflectionClass->isInstantiable()) {
throw new \RuntimeException(sprintf('cannot instantiate entity %s', $className));
}
$entity = $reflectionClass->newInstanceWithoutConstructor();
}
if (!$this->annotationReader->hasDocumentDeclaration($entity)) {
throw new \RuntimeException(sprintf('no declaration for document found in entity %s', $className));
}
$metaInformation = new MetaInformation();
$metaInformation->setEntity($entity);
$metaInformation->setClassName($className);
$metaInformation->setDocumentName($this->getDocumentName($className));
$metaInformation->setFieldMapping($this->annotationReader->getFieldMapping($entity));
$metaInformation->setFields($this->annotationReader->getFields($entity));
$metaInformation->setRepository($this->annotationReader->getRepository($entity));
$metaInformation->setIdentifier($this->annotationReader->getIdentifier($entity));
$metaInformation->setBoost($this->annotationReader->getEntityBoost($entity));
$metaInformation->setSynchronizationCallback($this->annotationReader->getSynchronizationCallback($entity));
$metaInformation->setIndex($this->annotationReader->getDocumentIndex($entity));
$metaInformation->setIsDoctrineEntity($this->annotationReader->isDoctrineEntity($entity));
return $metaInformation;
}
/**
* @param $array
* @param $key
* @param $expected
*
* @dataProvider keyExistsProvider
*/
public function testKeyExists($array, $key, $expected)
{
$method = self::$inst->getMethod('keyExists');
$method->setAccessible(true);
$actual = $method->invoke(self::$inst->newInstanceWithoutConstructor(), $key, $array);
$this->assertEquals($expected, $actual);
}
/**
* This is INSANE - don't put your actions in a constructor.
*/
function test_actions_added_in_constructor()
{
$class = new \ReflectionClass('\\tenup\\demo\\Real_World_Class');
$object = $class->newInstanceWithoutConstructor();
\WP_Mock::expectActionAdded('init', [$object, 'action_init']);
$object->__construct();
}
/**
* Returns the current row of a result set under HHVM
* The problem was fetch_object creates new instance of a given class,
* and attaches resulted key/value pairs after the class was constructed.
*
* @return mixed
*/
private function currentHHVM()
{
if ($this->_as_object === TRUE or is_string($this->_as_object)) {
if ($this->_reflect_class === NULL) {
// Create reflection class of given classname or stdClass
$this->_reflect_class = new ReflectionClass(is_string($this->_as_object) ? $this->_as_object : 'stdClass');
}
// Support ORM with loaded, when the class has __set and __construct if its ORM
if ($this->_reflect_class->hasMethod('__set') === TRUE && $this->_reflect_class->hasMethod('__construct') === TRUE) {
// Get row as associated array
$row = $this->_result->fetch_assoc();
// Get new instance without constructing it
$object = $this->_reflect_class->newInstanceWithoutConstructor();
foreach ($row as $column => $value) {
// Trigger the class setter
$object->__set($column, $value);
}
// Construct the class with no parameters
$object->__construct(NULL);
return $object;
} elseif (is_string($this->_as_object)) {
// Return an object of given class name
return $this->_result->fetch_object($this->_as_object, (array) $this->_object_params);
} else {
// Return an stdClass
return $this->_result->fetch_object();
}
}
// Get row as associated array
return $this->_result->fetch_assoc();
}
protected function _checkProtection($protectionType)
{
// Check type
if (!is_string($protectionType) || $protectionType != self::PROTECTION_CSRF && $protectionType != self::PROTECTION_CAPTCHA && $protectionType != self::PROTECTION_BRUTEFORCE && $protectionType != self::PROTECTION_XSS) {
throw new \Exception('Invalid protection type : "' . $protectionType . '"');
}
// Check class
if (class_exists('framework\\security\\form\\' . ucfirst($protectionType))) {
$className = 'framework\\security\\form\\' . ucfirst($protectionType);
} else {
$className = $protectionType;
}
$class = new \ReflectionClass($className);
if (!in_array('framework\\security\\IForm', $class->getInterfaceNames())) {
throw new \Exception('Form protection drivers must be implement framework\\security\\IForm');
}
if ($class->isAbstract()) {
throw new \Exception('Form protection drivers must be not abstract class');
}
if ($class->isInterface()) {
throw new \Exception('Form protection drivers must be not interface');
}
$classInstance = $class->newInstanceWithoutConstructor();
$constuctor = new \ReflectionMethod($classInstance, '__construct');
if ($constuctor->isPrivate() || $constuctor->isProtected()) {
throw new \Exception('Protection constructor must be public');
}
return $className;
}
/**
* @param array $transformed
* @param string $type
* @return object
* @throws \Exception
*/
protected function revertObject($transformed, $type)
{
$class = new \ReflectionClass($type);
$instance = $class->newInstanceWithoutConstructor();
if (!is_array($transformed)) {
throw new \Exception("Error while reverting [{$type}]. Input is not an array: " . ValuePrinter::serialize($transformed));
}
$reader = new PropertyReader($this->types, $class->getName());
$properties = [];
foreach ($reader->readState() as $property) {
$properties[] = $property->name();
if (array_key_exists($property->name(), $transformed)) {
$value = new TypedValue($transformed[$property->name()], $property->type());
$transformer = $this->transformers->toRevert($value);
$property->set($instance, $transformer->revert($value));
}
}
foreach ($transformed as $key => $value) {
if (!in_array($key, $properties)) {
$transformer = $this->transformers->toRevert($value);
$instance->{$key} = $transformer->revert($value);
}
}
return $instance;
}
protected static function _registerSingleton($singleton, $singletonNumber, $parameters)
{
if (self::_isLocked($singleton)) {
throw new \Exception('Loop singleton');
}
self::_lockSingleton($singleton);
$num = $singletonNumber == null ? 0 : $singletonNumber;
// No parameters, or empty, instance directly
if (empty($parameters)) {
self::$_singletons[$singleton][$num] = new $singleton();
} else {
// create reflectionClass instance, check if is abstract class
$ref = new \ReflectionClass($singleton);
if ($ref->isAbstract()) {
throw new \Exception('Your singletoned class :"' . $singleton . '" must be non-abstract class');
}
// Instance, and check constructor, setAccessible if is not, for invoke
$inst = $ref->newInstanceWithoutConstructor();
$constuctor = new \ReflectionMethod($inst, '__construct');
if ($constuctor->isPrivate() || $constuctor->isProtected()) {
$constuctor->setAccessible(true);
}
//Finally invoke (with args) and asign object into singletons list
if (!is_array($parameters)) {
// Single parameter
$constuctor->invoke($inst, $parameters);
} else {
$constuctor->invokeArgs($inst, $parameters);
}
self::$_singletons[$singleton][$num] = $inst;
}
self::_unLockSingleton($singleton);
}
/**
* 实例化验证规则
* @param string $type
* @param array $arguments
* @throws UploadException
* @return RuleInterface
*/
public static function create($type, $arguments = null)
{
$ruleClass = '';
switch ($type) {
case static::RULE_SIZE:
$ruleClass = 'SizeRule';
break;
case static::RULE_MIME_TYPE:
$ruleClass = 'MimeTypeRule';
break;
case static::RULE_EXTENSION:
$ruleClass = 'ExtensionRule';
break;
case static::RULE_SYSTEM:
$ruleClass = 'SystemRule';
break;
}
$ruleClass = "Slince\\Upload\\Rule\\{$ruleClass}";
try {
$ruleReflection = new \ReflectionClass($ruleClass);
if ($ruleReflection->getConstructor() != null) {
$instance = $ruleReflection->newInstanceArgs($arguments);
} else {
$instance = $ruleReflection->newInstanceWithoutConstructor();
}
return $instance;
} catch (\ReflectionException $e) {
throw new UploadException(sprintf('Rule "%s" does not support', $type));
}
}
/**
* Create a ghost object.
*
* @param array $values
* @return static
*/
public static function lazyload($values)
{
$class = get_called_class();
if (is_scalar($values)) {
if (!is_a($class, Identifiable::class, true)) {
throw new \Exception("Unable to lazy load a scalar value for {$class}: Identity property not defined");
}
$prop = static::getIdProperty();
if (is_array($prop)) {
throw new \Exception("Unable to lazy load a scalar value for {$class}: Class has a complex identity");
}
$values = [$prop => $values];
}
$reflection = new \ReflectionClass($class);
$entity = $reflection->newInstanceWithoutConstructor();
foreach ((array) $entity as $prop => $value) {
if ($prop[0] === "") {
continue;
}
// Ignore private and protected properties
unset($entity->{$prop});
}
foreach ($values as $key => $value) {
$entity->{$key} = $value;
}
$entity->ghost__ = true;
return $entity;
}
/**
* Gets the Multiton instance referenced by key.
*
* Automatically creates an instance if non exists. If one instance already exists, the argument list is ignored.
*
* @param string $key The key of the Multiton instance to get.
* @param mixed $args,... The arguments for creating the Multiton instance.
*
* @return Multiton The Multiton instance.
*/
public static function instance($key = 'default')
{
if (!is_string($key) and !empty($key)) {
throw new \InvalidArgumentException("The \$key must be a non-empty string.");
}
$class = static::$T;
if (!class_exists($class)) {
throw new Exceptions\ClassNotFoundException("The class {$class} was not found.");
}
if (!array_key_exists($class, static::$instances) or !array_key_exists($key, static::$instances[$class])) {
if (!array_key_exists($class, static::$cache)) {
static::$cache[$class]['forgeable'] = Utils::class_implements($class, 'axelitus\\Patterns\\Interfaces\\Forgeable');
}
$args = array_slice(func_get_args(), 1);
if (static::$cache[$class]['forgeable']) {
static::$instances[$class][$key] = call_user_func_array([$class, 'forge'], $args);
} else {
$ref = new \ReflectionClass($class);
$ctor = $ref->getConstructor();
$ctor->setAccessible(true);
static::$instances[$class][$key] = $ref->newInstanceWithoutConstructor();
$ctor->invokeArgs(static::$instances[$class][$key], $args);
}
}
return static::$instances[$class][$key];
}
/**
* @param ChangeSet $changeset
* @return bool|object
*/
public function applyChangeSet(ChangeSet $changeset)
{
$now = new \DateTime();
if ($changeset->getChangeAt() == null || $changeset->getChangeAt()->diff($now)->invert) {
return false;
}
if ($changeset->getAction() == LoggableListener::ACTION_CREATE && $changeset->getObjectId() != null) {
throw new \Exception("changeSet invalid {$changeset->getId()} create with object id");
}
if ($changeset->getAction() != LoggableListener::ACTION_CREATE && $changeset->getObjectId() == null) {
throw new \Exception("changeSet invalid {$changeset->getId()} no objectId found but no create Action");
}
$data = $changeset->getData();
if ($changeset->getObjectId() == null) {
//create a new one
$r = new \ReflectionClass($changeset->getObjectClass());
$entity = $r->newInstanceWithoutConstructor();
} else {
//edit
$entity = $this->_em->find($changeset->getObjectClass(), $changeset->getObjectId());
}
if ($changeset->getAction() == LoggableListener::ACTION_REMOVE) {
//very rudimental remove... dont care about sitdeffects
$this->_em->remove($entity);
$this->_em->remove($changeset);
$this->_em->flush();
return true;
}
$wrapped = new EntityWrapper($entity, $this->_em);
$objectMeta = $wrapped->getMetadata();
foreach ($data as $field => $value) {
if ($objectMeta->isSingleValuedAssociation($field)) {
$mapping = $objectMeta->getAssociationMapping($field);
$value = $value ? $this->_em->getReference($mapping['targetEntity'], $value) : null;
}
if (property_exists($changeset->getObjectClass(), $field)) {
$wrapped->setPropertyValue($field, $value);
}
}
if ($changeset->getObjectId() == null) {
//MANY_TO_ONE create new one
foreach ($objectMeta->getAssociationMappings() as $associationMapping) {
if ($associationMapping['type'] != \Doctrine\ORM\Mapping\ClassMetadata::MANY_TO_ONE) {
continue;
}
$one = $objectMeta->getReflectionProperty($associationMapping['fieldName'])->getValue($entity);
if (array_key_exists('inversedBy', $associationMapping)) {
$field = $associationMapping['inversedBy'];
$associationMeta = $this->_em->getClassMetadata($associationMapping['targetEntity']);
$associationMeta->getReflectionProperty($field)->getValue($one)->add($entity);
}
}
}
$object = $wrapped->getObject();
$object->removeScheduledChangeDate();
$this->_em->persist($object);
$this->_em->remove($changeset);
$this->_em->flush();
return $object;
}
/**
* Get document fields
*
* @param Document $document Document
* @return array
*/
private function getFormFields(Document $document)
{
$reflection = new \ReflectionClass($document->getClass());
if ($reflection->implementsInterface('Graviton\\I18nBundle\\Document\\TranslatableDocumentInterface')) {
$instance = $reflection->newInstanceWithoutConstructor();
$translatableFields = $instance->getTranslatableFields();
} else {
$translatableFields = [];
}
$result = [];
foreach ($document->getFields() as $field) {
if ($field instanceof Field) {
list($type, $options) = $this->resolveFieldParams($translatableFields, $field->getFieldName(), $field->getType());
$result[] = [$field->getFormName(), $type, array_replace(['property_path' => $field->getFieldName()], $options)];
} elseif ($field instanceof ArrayField) {
list($type, $options) = $this->resolveFieldParams($translatableFields, $field->getFieldName(), $field->getItemType());
$result[] = [$field->getFormName(), 'collection', ['property_path' => $field->getFieldName(), 'type' => $type, 'options' => $options]];
} elseif ($field instanceof EmbedOne) {
$result[] = [$field->getFormName(), 'form', ['property_path' => $field->getFieldName(), 'data_class' => $field->getDocument()->getClass(), 'required' => $field->isRequired()]];
} elseif ($field instanceof EmbedMany) {
$result[] = [$field->getFormName(), 'collection', ['property_path' => $field->getFieldName(), 'type' => 'form', 'options' => ['data_class' => $field->getDocument()->getClass()]]];
}
}
return $result;
}
public static function instanceCell($cellUri)
{
if (is_array($cellUri)) {
return self::_cell($cellUri);
}
if (isset(self::$_aliases[$cellUri])) {
$cellUri = self::$_aliases[$cellUri];
}
$className = str_replace("/", "\\", $cellUri);
if (class_exists($className)) {
$reflection = new \ReflectionClass($className);
$constructor = $reflection->getConstructor();
if ($constructor) {
$cell = $reflection->newInstanceArgs();
} else {
$cell = $reflection->newInstanceWithoutConstructor();
}
$fileConfig = str_replace('.php', '.yml', $reflection->getFileName());
if (file_exists($fileConfig)) {
$data = \Symfony\Component\Yaml\Yaml::parse(file_get_contents($fileConfig));
$cell->setData($data);
}
} else {
$fileConfig = stream_resolve_include_path(str_replace("\\", "/", trim($cellUri, "/")) . '.yml');
if ($fileConfig !== FALSE) {
$data = \Symfony\Component\Yaml\Yaml::parse(file_get_contents($fileConfig));
$cell = self::_cell($data);
} else {
$cell = new \Nucleus\Cell();
}
}
$cell->setCellUri($cellUri);
return $cell;
}
/**
* (@inheritdoc)
*/
public function deserialize($type, array $data)
{
$reflectionClass = new \ReflectionClass($type);
$object = $reflectionClass->newInstanceWithoutConstructor();
$object = $this->setReflectionPropertiesFromData($data, $reflectionClass, $object);
return $object;
}
/**
* @test
*/
public function I_can_easily_find_out_if_is_melee()
{
$reflection = new \ReflectionClass(self::getSutClass());
/** @var RangedWeaponCode $sut */
$sut = $reflection->newInstanceWithoutConstructor();
self::assertFalse($sut->isMelee());
}
/**
* Creates a new instance of the cacheable object or returns an already
* cached one
*
* The parameters of this method are derived from the constructor of the
* cacheable class. Additionally, the following parameters are dynamically
* added:
*
* @param bool $fetch If <var>true</var> the object’s <var>fetch()</var>
* method will be called
* @param bool $bypassCache If <var>true</var> the cache will not be hit
* @return mixed A new object or a matching cached one
*/
public static function create()
{
$args = func_get_args();
$className = empty(self::$className) ? get_class() : self::$className;
$class = new \ReflectionClass($className);
$constructor = $class->getConstructor();
$arity = $constructor->getNumberOfParameters();
if (sizeof($args) < $arity) {
array_fill(0, $arity, null);
}
$bypassCache = sizeof($args) > $arity + 1 ? array_pop($args) : false;
$fetch = sizeof($args) > $arity ? array_pop($args) : true;
$object = $class->newInstanceWithoutConstructor();
$constructor->setAccessible(true);
$constructor->invokeArgs($object, $args);
$cachedObject = $object->cachedInstance();
if ($cachedObject != null && !$bypassCache) {
$object = $cachedObject;
}
if ($fetch && ($bypassCache || !$object->isFetched())) {
$object->fetch();
$object->cache();
}
return $object;
}
/**
* @param string $base_class A parent class or interface.
* @param bool $callback Optionally, don't call the register callback to construct the results array.
* @param bool $use_constructor Optionally, get a class-instance via constructor - potentially UNSAFE!
* @return array Array of result classes, optionally keyed.
*/
public function match($base_class, $callback = true, $use_constructor = false)
{
$results = array();
//foreach ($this as $class) {
foreach ($this->classes as $class) {
if (is_subclass_of($class, $base_class)) {
if ($callback) {
try {
$obj = null;
if ($use_constructor) {
$obj = new $class();
} else {
$reflect = new \ReflectionClass($class);
// Ignore abstract classes.
if ($reflect->isInstantiable()) {
$obj = $reflect->newInstanceWithoutConstructor();
}
}
if ($obj) {
$obj->{self::REGISTER_FN}($results);
}
} catch (\ReflectionException $e) {
$this->debug('Warning! (RF) ' . $e->getMessage());
} catch (\Exception $e) {
$this->debug('Warning! ' . $e->getMessage());
}
//Was: $results[ $class::{ $callback }() ] = $class;
} else {
$results[] = $class;
}
}
}
return $results;
}
/**
* 重载callback()
* 将微信服务器请求的数据进行解析
* 并回调控制器的接口方法
*/
public function callback()
{
$req = parent::callback();
//$this->log($req);
empty($_GET) && die;
// 必须有附带参数
extract($_GET);
if ($this->sha1_sign($req->Encrypt, $timestamp, $nonce, $msg_signature)) {
$reply = '';
$ES = \es\core\Controller\ControllerAbstract::getInstance();
switch (strtolower($req->MsgType)) {
case 'text':
$reply = $ES->_keywords($req->Content);
break;
case 'event':
$reply = $ES->_events($req);
break;
}
empty($reply) && die;
list($method, $args) = $reply;
$args = ['to' => $req->FromUserName, 'from' => $req->ToUserName] + $args;
$reflector = new \ReflectionClass('\\es\\libraries\\Wechat\\ReplyStatic');
$rMethod = $reflector->getMethod($method);
$xml = $rMethod->invokeArgs($reflector->newInstanceWithoutConstructor(), $args);
//$this->log($xml); // 未加密的消息体
die($xml);
$xml = $this->crypt_generate($xml);
$signature = $this->set_sha1_sign($xml, $timestamp, $nonce);
$xml = ReplyStatic::crypt_xml($xml, $signature, $timestamp, $nonce);
//$this->log($xml); // 加密后的消息体
echo $xml;
exit;
}
exit;
}
/**
* {@inheritdoc}
*/
public function getCommandFrom($className)
{
if (class_exists($className)) {
$accessor = PropertyAccess::createPropertyAccessor();
$reflector = new \ReflectionClass($className);
$instance = $reflector->newInstanceWithoutConstructor();
foreach ($reflector->getProperties() as $property) {
if ($instance instanceof ConsoleCommandInterface && $property->getName() == 'io') {
continue;
}
if (!$this->format->hasArgument($property->getName()) && !$this->format->hasOption($property->getName())) {
throw new \InvalidArgumentException(sprintf("There is not '%s' argument defined in the %s command", $property->getName(), $className));
}
$value = null;
if ($this->format->hasArgument($property->getName())) {
$value = $this->args->getArgument($property->getName());
} elseif ($this->format->hasOption($property->getName())) {
$value = $this->args->getOption($property->getName());
}
$accessor->setValue($instance, $property->getName(), $value);
}
return $instance;
}
return;
}
private function createInstance(Scope $scope)
{
if (!$this->arguments) {
return $this->class->newInstanceWithoutConstructor();
}
return $this->class->newInstanceArgs($this->newArguments($scope));
}
/**
* {@inheritdoc}
*/
public function convert($value)
{
$ref = new \ReflectionClass($this->class);
$data = $ref->newInstanceWithoutConstructor();
$this->propertyAccessor->setValue($data, $this->label, $value);
return (object) $data;
}
/**
* 重载callback()
* 将微信服务器请求的数据进行解析
* 并回调控制器的接口方法
*/
public function callback()
{
$postXML = parent::callback();
empty($_GET) && die;
// 必须有附带参数
extract($_GET);
if ($this->sha1_sign($postXML->Encrypt, $timest, $nonce, $msg_signature)) {
$req = $this->crypt_extract(parent::callback());
$reply = '';
switch (strtolower($req->MsgType)) {
case 'text':
$reply = ES_controller::get_instance()->_keywords($req->Content);
break;
case 'event':
$reply = ES_controller::get_instance()->_events($req);
break;
}
empty($reply) && die;
list($method, $args) = $reply;
$args = array('to' => $req->FromUserName, 'from' => $req->ToUserName) + $args;
$reflector = new ReflectionClass('Reply');
$rMethod = $reflector->getMethod($method);
$xml = $rMethod->invokeArgs($reflector->newInstanceWithoutConstructor(), $args);
// log_msg($xml); // 未加密的消息体
$xml = $this->crypt_generate($xml);
$signature = $this->set_sha1_sign($xml, $timestamp, $nonce);
$xml = Reply::crypt_xml($xml, $signature, $timestamp, $nonce);
// log_msg($xml); // 加密后的消息体
echo $xml;
exit;
}
exit;
}
/**
* @param $string
* @return static
*/
public static function createFromJson($string)
{
$reflection = new \ReflectionClass(static::class);
$object = $reflection->newInstanceWithoutConstructor();
$object->fromJson($string);
return $object;
}
/**
* {@inheritdoc}
*/
public function get($name)
{
if ($this->has($name)) {
return $this->definitions[$name];
}
if (!class_exists($name) && !interface_exists($name)) {
return;
}
$autowiring = function ($name) {
$class = new \ReflectionClass($name);
$constructor = $class->getConstructor();
if ($constructor && $constructor->isPublic()) {
$parameters = $this->getParametersDefinition($constructor);
if ($constructor->getNumberOfRequiredParameters() !== count($parameters)) {
return;
}
$object = $class->newInstanceArgs($parameters);
$this->set($name, $object);
return $object;
}
$object = $class->newInstanceWithoutConstructor();
$this->set($name, $object);
return $object;
};
return $autowiring($name);
}
/**
* Creates a data object from an array of data.
*
* @param array $data The array containing object data.
*
* @return self A new object instance.
*/
public static function fromData(array $data)
{
$reflection = new \ReflectionClass(static::class);
$instance = $reflection->newInstanceWithoutConstructor();
$instance->data = $data;
$instance->jsonUnserialize($data);
return $instance;
}
