json_decode 到自定义类

Question

是否可以将 json 字符串解码为 stdClass 以外的对象？

Answer 1

您可以通过以下方式做到这一点..

<?php
class CatalogProduct
{
    public $product_id;
    public $sku;
    public $name;
    public $set;
    public $type;
    public $category_ids;
    public $website_ids;

    function __construct(array $data) 
    {
        foreach($data as $key => $val)
        {
            if(property_exists(__CLASS__,$key))
            {
                $this->$key =  $val;
            }
        }
    }
}

？>

欲了解更多详情，请访问
create-custom-class-in-php-from- json 或数组

Answer 2

您可以为您的对象创建一个包装器，并使包装器看起来就像对象本身一样。它将适用于多级对象。

<?php
class Obj
{
    public $slave;

    public function __get($key) {
        return property_exists ( $this->slave ,  $key ) ? $this->slave->{$key} : null;
    }

    public function __construct(stdClass $slave)
    {
        $this->slave = $slave;
    }
}

$std = json_decode('{"s3":{"s2":{"s1":777}}}');

$o = new Obj($std);

echo $o->s3->s2->s1; // you will have 777

Answer 3

使用 反射：

function json_decode_object(string $json, string $class)
{
    $reflection = new ReflectionClass($class);
    $instance = $reflection->newInstanceWithoutConstructor();
    $json = json_decode($json, true);
    $properties = $reflection->getProperties();
    foreach ($properties as $key => $property) {
        $property->setAccessible(true);
        $property->setValue($instance, $json[$property->getName()]);
    }
    return $instance;
}

Answer 4

不，从 PHP 5.5.1 开始这是不可能的。

唯一可能的是 json_decode返回关联数组而不是 StdClass 对象。

Answer 5

正如戈登所说，这是不可能的。但是，如果您正在寻找一种方法来获取可以解码为给定类实例的字符串，您可以使用 序列化 并反序列化。

class Foo
{

    protected $bar = 'Hello World';

    function getBar() {
        return $this->bar;
    }

}

$string = serialize(new Foo);

$foo = unserialize($string);
echo $foo->getBar();

Answer 6

我曾经为此目的创建了一个抽象基类。我们将其称为 JsonConvertible。它应该对公共成员进行序列化和反序列化。使用反射和后期静态绑定可以实现这一点。

abstract class JsonConvertible {
   static function fromJson($json) {
       $result = new static();
       $objJson = json_decode($json);
       $class = new \ReflectionClass($result);
       $publicProps = $class->getProperties(\ReflectionProperty::IS_PUBLIC);
       foreach ($publicProps as $prop) {
            $propName = $prop->name;
            if (isset($objJson->$propName) {
                $prop->setValue($result, $objJson->$propName);
            }
            else {
                $prop->setValue($result, null);
            }
       }
       return $result;
   }
   function toJson() {
      return json_encode($this);
   }
} 

class MyClass extends JsonConvertible {
   public $name;
   public $whatever;
}
$mine = MyClass::fromJson('{"name": "My Name", "whatever": "Whatever"}');
echo $mine->toJson();

只是凭记忆，所以可能并不完美。您还必须排除静态属性，并且可能会为派生类提供在序列化到 json 或从 json 序列化时忽略某些属性的机会。尽管如此，我希望你能明白。

Answer 7

JSON 是一种在各种编程语言之间传输数据的简单协议（它也是 JavaScript 的子集），仅支持某些类型：数字、字符串、数组/列表、对象/字典。对象只是键=值映射，数组是有序列表。

所以没有办法以通用的方式表达自定义对象。解决方案是定义一个结构，您的程序将知道它是一个自定义对象。

这是一个示例：

{ "cls": "MyClass", fields: { "a": 123, "foo": "bar" } }

这可用于创建 MyClass 的实例并将字段 a 和 foo 设置为 123 和“栏”。

Answer 8

我继续将 John Petit 的答案实现为一个函数(gist)：

function json_decode_to(string $json, string $class = stdClass::class, int $depth = 512, int $options = 0)
{
    $stdObj = json_decode($json, false, $depth, $options);
    if ($class === stdClass::class) return $stdObj;

    $count = strlen($class);
    $temp = serialize($stdObj);
    $temp = preg_replace("@^O:8:\"stdClass\":@", "O:$count:\"$class\":", $temp);
    return unserialize($temp);  
}

这非常适合我的用例。然而，Yevgeniy Afanasyev 的回应对我来说似乎同样有希望。可以让你的类有一个额外的“构造函数”，如下所示：

public static function withJson(string $json) {
    $instance = new static();
    // Do your thing
    return $instance;
}

这也是受到这个答案的启发。

编辑：我已经使用 karriereat/json-decoder 一段时间了，我已经绝对没问题。它是轻量级的并且非常容易扩展。 这是我编写的用于将 JSON 反序列化为 Carbon/CarbonImmutable 对象的绑定示例。

Answer 9

这对我有用，特别是如果目标类中没有设置器或命名属性

function cast($jsonstring, $class)
{
   //$class is a string like 'User'

    $json= json_decode($jsonstring,true);  //array
   
    $reflection = new ReflectionClass($class);
    $instance = $reflection->newInstanceWithoutConstructor();
    $keys = array_keys($json);

    foreach ($keys  as $key => $property) {
        $instance->{$property} =$json[$property];
    }

   // print_r($instance);

    return $instance;
}

Answer 10

不直接，但如果类有一个参数名称与 JSON 对象中的键匹配的构造函数，您可以简单地将 JSON 解码为关联数组，然后通过“...”（参数解包）运算符将其传递给构造函数：

<?php
class MyClass {
    public function __construct(
        public int $id,
        public string $name,
        public array $attributes,
    ){}
}
$json = '{"name":"foo","id":42,"attributes":{"color":"red"}}';
$object = new MyClass(...json_decode($json, true));
print_r($object);

输出：

MyClass Object
(
    [id] => 42
    [name] => foo
    [attributes] => Array
        (
            [color] => red
        )

)

然而，在实践中，经常需要做一些额外的映射，特别是也需要递归解码的子对象。因此，通常最好在每个类中有一个静态 fromArray 函数，在将结果传递给构造函数之前预处理 json 解码的数组：

class Part {
    public function __construct(public float $weight){}
    public static function fromArray(array $data): self {
        return new self(...$data);
    }
}
class System {
    public function __construct(
        public string $name,
        public Part $mainPart,
        public array $otherParts,
    ){}
    public static function fromArray(array $data): self {
        $data['mainPart'] = Part::fromArray($data['mainPart']);
        $data['otherParts'] = array_map(Part::fromArray(...), $data['otherParts']); // php 8.1
        return new self(...$data);
    }
}
$json = '{"name":"foo","mainPart":{"weight":2},"otherParts":[{"weight":1}, {"weight":0.5}]}';
$object = System::fromArray(json_decode($json, true));

Answer 11

所有这些都激发了我对通用函数的灵感：

function loadJSON($Obj, $json)
{
     $dcod = json_decode($json);
     $prop = get_object_vars ( $dcod );
     foreach($prop as $key => $lock)
     {
        if(property_exists ( $Obj ,  $key ))
        {
            if(is_object($dcod->$key))
            {
                loadJSON($Obj->$key, json_encode($dcod->$key));
            }
            else
            {
                $Obj->$key = $dcod->$key;
            }
        }
    }
    return $Obj;
}

在类声明中调用：

class Bar{public $bar = " Boss";}
class Bas
{
    public $ber ;
    public $bas=" Boven"; 
    public function __construct() 
        {$this->ber = new Bar;}
}
class Baz
{
    public $bes ;
    public $baz=" Baaz";  
    public function __construct() 
        {$this->bes = new Bas;}
}

$Bazjson = '{"bes":{"ber":{"bar":"Baas"}}}';

$Bazobj = new Baz;

loadJSON($Bazobj, $Bazjson);
var_dump($Bazobj);

Answer 12

不是自动的。但你可以按照老式的路线来做。

$data = json_decode($json, true);

$class = new Whatever();
foreach ($data as $key => $value) $class->{$key} = $value;

或者，您可以使其更加自动化：

class Whatever {
    public function set($data) {
        foreach ($data AS $key => $value) $this->{$key} = $value;
    }
}

$class = new Whatever();
$class->set($data);

编辑：变得更奇特：

class JSONObject {
    public function __construct($json = false) {
        if ($json) $this->set(json_decode($json, true));
    }

    public function set($data) {
        foreach ($data AS $key => $value) {
            if (is_array($value)) {
                $sub = new JSONObject;
                $sub->set($value);
                $value = $sub;
            }
            $this->{$key} = $value;
        }
    }
}

// These next steps aren't necessary. I'm just prepping test data.
$data = array(
    "this" => "that",
    "what" => "who",
    "how" => "dy",
    "multi" => array(
        "more" => "stuff"
    )
);
$jsonString = json_encode($data);

// Here's the sweetness.
$class = new JSONObject($jsonString);
print_r($class);

Answer 13

我们构建了 JsonMapper 来自动将 JSON 对象映射到我们自己的模型类上。它适用于嵌套/子对象。

它仅依赖于文档块类型信息进行映射，大多数类属性无论如何都有：

<?php
$mapper = new JsonMapper();
$contactObject = $mapper->map(
    json_decode(file_get_contents('http://example.org/contact.json')),
    new Contact()
);
?>

Answer 14

你可以做到——这是一个拼凑，但完全有可能。当我们开始将东西存储在沙发底座中时，我们必须这样做。

$stdobj = json_decode($json_encoded_myClassInstance);  //JSON to stdClass
$temp = serialize($stdobj);                   //stdClass to serialized

// Now we reach in and change the class of the serialized object
$temp = preg_replace('@^O:8:"stdClass":@','O:7:"MyClass":',$temp);

// Unserialize and walk away like nothing happend
$myClassInstance = unserialize($temp);   // Presto a php Class 

在我们的基准测试中，这比尝试迭代所有类变量要快得多。

警告：不适用于 stdClass 之外的嵌套对象

编辑：请记住数据源，强烈建议您不要在没有仔细分析风险的情况下使用来自用户的不受信任的数据执行此操作。

Answer 15

您可以使用 Johannes Schmitt 的序列化程序库。

$serializer = JMS\Serializer\SerializerBuilder::create()->build();
$object = $serializer->deserialize($jsonData, 'MyNamespace\MyObject', 'json');

在最新版本的 JMS 序列化器中，语法为：

$serializer = SerializerBuilder::create()->build();
$object = $serializer->deserialize($jsonData, MyObject::class, 'json');

Answer 16

我很惊讶还没有人提到这一点。

使用 Symfony 序列化器组件： https://symfony.com/doc/current/components/serializer .html

从对象序列化为 JSON：

use App\Model\Person;

$person = new Person();
$person->setName('foo');
$person->setAge(99);
$person->setSportsperson(false);

$jsonContent = $serializer->serialize($person, 'json');

// $jsonContent contains {"name":"foo","age":99,"sportsperson":false,"createdAt":null}

echo $jsonContent; // or return it in a Response

从 JSON 反序列化为对象： （本示例使用 XML 只是为了演示格式的灵活性）

use App\Model\Person;

$data = <<<EOF
<person>
    <name>foo</name>
    <age>99</age>
    <sportsperson>false</sportsperson>
</person>
EOF;

$person = $serializer->deserialize($data, Person::class, 'xml');