The Serializer Component

The Serializer component is meant to be used to turn objects into aspecific format (XML, JSON, YAML, …) and the other way around.

In order to do so, the Serializer component follows the following schema.

As you can see in the picture above, an array is used as an intermediary betweenobjects and serialized contents. This way, encoders will only deal with turningspecific formats into arrays and vice versa. The same way, Normalizerswill deal with turning specific objects into arrays and vice versa.

Serialization is a complex topic. This component may not cover all your use cases out of the box,but it can be useful for developing tools to serialize and deserialize your objects.

Installation

$ composer require symfony/serializer

Note

If you install this component outside of a Symfony application, you mustrequire the vendor/autoload.php file in your code to enable the classautoloading mechanism provided by Composer. Readthis article for more details.

To use the ObjectNormalizer, the PropertyAccess componentmust also be installed.

Usage

This article explains the philosophy of the Serializer and gets you familiarwith the concepts of normalizers and encoders. The code examples assumethat you use the Serializer as an independent component. If you are usingthe Serializer in a Symfony application, read How to Use the Serializer after youfinish this article.

To use the Serializer component, set up theSerializer specifying which encodersand normalizer are going to be available:

use Symfony\Component\Serializer\Encoder\JsonEncoder;
use Symfony\Component\Serializer\Encoder\XmlEncoder;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
use Symfony\Component\Serializer\Serializer;
 
$encoders = [new XmlEncoder(), new JsonEncoder()];
$normalizers = [new ObjectNormalizer()];
 
$serializer = new Serializer($normalizers, $encoders);

The preferred normalizer is theObjectNormalizer,but other normalizers are available. All the examples shown below usethe ObjectNormalizer.

Serializing an Object

For the sake of this example, assume the following class alreadyexists in your project:

namespace App\Model;
 
class Person
{
    private $age;
    private $name;
    private $sportsperson;
    private $createdAt;
 
    // Getters
    public function getName()
    {
        return $this->name;
    }
 
    public function getAge()
    {
        return $this->age;
    }
 
    public function getCreatedAt()
    {
        return $this->createdAt;
    }
 
    // Issers
    public function isSportsperson()
    {
        return $this->sportsperson;
    }
 
    // Setters
    public function setName($name)
    {
        $this->name = $name;
    }
 
    public function setAge($age)
    {
        $this->age = $age;
    }
 
    public function setSportsperson($sportsperson)
    {
        $this->sportsperson = $sportsperson;
    }
 
    public function setCreatedAt($createdAt)
    {
        $this->createdAt = $createdAt;
    }
}

Now, if you want to serialize this object into JSON, you only need touse the Serializer service created before:

$person = new App\Model\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

The first parameter of the serialize()is the object to be serialized and the second is used to choose the proper encoder,in this case JsonEncoder.

Deserializing an Object

You'll now learn how to do the exact opposite. This time, the informationof the Person class would be encoded in XML format:

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');

In this case, deserialize()needs three parameters:

• The information to be decoded
• The name of the class this information will be decoded to
• The encoder used to convert that information into an arrayBy default, additional attributes that are not mapped to the denormalized objectwill be ignored by the Serializer component. If you prefer to throw an exceptionwhen this happens, set the allow_extra_attributes context option tofalse and provide an object that implements ClassMetadataFactoryInterfacewhen constructing the normalizer:

$data = <<<EOF
<person>
    <name>foo</name>
    <age>99</age>
    <city>Paris</city>
</person>
EOF;
 
// $loader is any of the valid loaders explained later in this article
$classMetadataFactory = new ClassMetadataFactory($loader);
$normalizer = new ObjectNormalizer($classMetadataFactory);
$serializer = new Serializer([$normalizer]);
 
// this will throw a Symfony\Component\Serializer\Exception\ExtraAttributesException
// because "city" is not an attribute of the Person class
$person = $serializer->deserialize($data, 'App\Model\Person', 'xml', [
    'allow_extra_attributes' => false,
]);

Deserializing in an Existing Object

The serializer can also be used to update an existing object:

// ...
$person = new Person();
$person->setName('bar');
$person->setAge(99);
$person->setSportsperson(true);
 
$data = <<<EOF
<person>
    <name>foo</name>
    <age>69</age>
</person>
EOF;
 
$serializer->deserialize($data, Person::class, 'xml', ['object_to_populate' => $person]);
// $person = App\Model\Person(name: 'foo', age: '69', sportsperson: true)

This is a common need when working with an ORM.

The OBJECT_TO_POPULATE is only used for the top level object. If that objectis the root of a tree structure, all child elements that exist in thenormalized data will be re-created with new instances.

When the AbstractObjectNormalizer::DEEP_OBJECT_TO_POPULATE option is set totrue, existing children of the root OBJECT_TO_POPULATE are updated from thenormalized data, instead of the denormalizer re-creating them. Note thatDEEP_OBJECT_TO_POPULATE only works for single child objects, but not forarrays of objects. Those will still be replaced when present in the normalizeddata.

New in version 4.3: The AbstractObjectNormalizer::DEEP_OBJECT_TO_POPULATE option wasintroduced in Symfony 4.3.

Attributes Groups

Sometimes, you want to serialize different sets of attributes from yourentities. Groups are a handy way to achieve this need.

Assume you have the following plain-old-PHP object:

namespace Acme;
 
class MyObj
{
    public $foo;
 
    private $bar;
 
    public function getBar()
    {
        return $this->bar;
    }
 
    public function setBar($bar)
    {
        return $this->bar = $bar;
    }
}

The definition of serialization can be specified using annotations, XMLor YAML. The ClassMetadataFactorythat will be used by the normalizer must be aware of the format to use.

The following code shows how to initialize the ClassMetadataFactoryfor each format:

• Annotations in PHP files:

use Doctrine\Common\Annotations\AnnotationReader;
use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;
 
$classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));

• YAML files:

use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
use Symfony\Component\Serializer\Mapping\Loader\YamlFileLoader;
 
$classMetadataFactory = new ClassMetadataFactory(new YamlFileLoader('/path/to/your/definition.yaml'));

• XML files:

use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
use Symfony\Component\Serializer\Mapping\Loader\XmlFileLoader;
 
$classMetadataFactory = new ClassMetadataFactory(new XmlFileLoader('/path/to/your/definition.xml'));

Then, create your groups definition:

• Annotations

namespace Acme;
 
use Symfony\Component\Serializer\Annotation\Groups;
 
class MyObj
{
    /**
     * @Groups({"group1", "group2"})
     */
    public $foo;
 
    /**
     * @Groups("group3")
     */
    public function getBar() // is* methods are also supported
    {
        return $this->bar;
    }
 
    // ...
}

• YAML

Acme\MyObj:
    attributes:
        foo:
            groups: ['group1', 'group2']
        bar:
            groups: ['group3']

• XML

<?xml version="1.0" ?>
<serializer xmlns="http://symfony.com/schema/dic/serializer-mapping"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/serializer-mapping
        https://symfony.com/schema/dic/serializer-mapping/serializer-mapping-1.0.xsd"
>
    <class name="Acme\MyObj">
        <attribute name="foo">
            <group>group1</group>
            <group>group2</group>
        </attribute>
 
        <attribute name="bar">
            <group>group3</group>
        </attribute>
    </class>
</serializer>

You are now able to serialize only attributes in the groups you want:

use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
use Symfony\Component\Serializer\Serializer;
 
$obj = new MyObj();
$obj->foo = 'foo';
$obj->setBar('bar');
 
$normalizer = new ObjectNormalizer($classMetadataFactory);
$serializer = new Serializer([$normalizer]);
 
$data = $serializer->normalize($obj, null, ['groups' => 'group1']);
// $data = ['foo' => 'foo'];
 
$obj2 = $serializer->denormalize(
    ['foo' => 'foo', 'bar' => 'bar'],
    'MyObj',
    null,
    ['groups' => ['group1', 'group3']]
);
// $obj2 = MyObj(foo: 'foo', bar: 'bar')

Selecting Specific Attributes

It is also possible to serialize only a set of specific attributes:

use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
use Symfony\Component\Serializer\Serializer;
 
class User
{
    public $familyName;
    public $givenName;
    public $company;
}
 
class Company
{
    public $name;
    public $address;
}
 
$company = new Company();
$company->name = 'Les-Tilleuls.coop';
$company->address = 'Lille, France';
 
$user = new User();
$user->familyName = 'Dunglas';
$user->givenName = 'Kévin';
$user->company = $company;
 
$serializer = new Serializer([new ObjectNormalizer()]);
 
$data = $serializer->normalize($user, null, ['attributes' => ['familyName', 'company' => ['name']]]);
// $data = ['familyName' => 'Dunglas', 'company' => ['name' => 'Les-Tilleuls.coop']];

Only attributes that are not ignored (see below) are available.If some serialization groups are set, only attributes allowed by those groups can be used.

As for groups, attributes can be selected during both the serialization and deserialization process.

Ignoring Attributes

As an option, there's a way to ignore attributes from the origin object.To remove those attributes provide an array via the ignored_attributeskey in the context parameter of the desired serializer method:

use Acme\Person;
use Symfony\Component\Serializer\Encoder\JsonEncoder;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
use Symfony\Component\Serializer\Serializer;
 
$person = new Person();
$person->setName('foo');
$person->setAge(99);
 
$normalizer = new ObjectNormalizer();
$encoder = new JsonEncoder();
 
$serializer = new Serializer([$normalizer], [$encoder]);
$serializer->serialize($person, 'json', ['ignored_attributes' => ['age']]); // Output: {"name":"foo"}

Deprecated since version 4.2: The setIgnoredAttributes()method that was used as an alternative to the ignored_attributes optionwas deprecated in Symfony 4.2.

Converting Property Names when Serializing and Deserializing

Sometimes serialized attributes must be named differently than propertiesor getter/setter methods of PHP classes.

The Serializer component provides a handy way to translate or map PHP fieldnames to serialized names: The Name Converter System.

Given you have the following object:

class Company
{
    public $name;
    public $address;
}

And in the serialized form, all attributes must be prefixed by org_ likethe following:

{"org_name": "Acme Inc.", "org_address": "123 Main Street, Big City"}

A custom name converter can handle such cases:

use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
 
class OrgPrefixNameConverter implements NameConverterInterface
{
    public function normalize($propertyName)
    {
        return 'org_'.$propertyName;
    }
 
    public function denormalize($propertyName)
    {
        // removes 'org_' prefix
        return 'org_' === substr($propertyName, 0, 4) ? substr($propertyName, 4) : $propertyName;
    }
}

The custom name converter can be used by passing it as second parameter of anyclass extending AbstractNormalizer,including GetSetMethodNormalizerand PropertyNormalizer:

use Symfony\Component\Serializer\Encoder\JsonEncoder;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
use Symfony\Component\Serializer\Serializer;
 
$nameConverter = new OrgPrefixNameConverter();
$normalizer = new ObjectNormalizer(null, $nameConverter);
 
$serializer = new Serializer([$normalizer], [new JsonEncoder()]);
 
$company = new Company();
$company->name = 'Acme Inc.';
$company->address = '123 Main Street, Big City';
 
$json = $serializer->serialize($company, 'json');
// {"org_name": "Acme Inc.", "org_address": "123 Main Street, Big City"}
$companyCopy = $serializer->deserialize($json, Company::class, 'json');
// Same data as $company

Note

You can also implementAdvancedNameConverterInterfaceto access to the current class name, format and context.

CamelCase to snake_case

In many formats, it's common to use underscores to separate words (also knownas snake_case). However, in Symfony applications is common to use CamelCase toname properties (even though the PSR-1 standard doesn't recommend anyspecific case for property names).

Symfony provides a built-in name converter designed to transform betweensnake_case and CamelCased styles during serialization and deserializationprocesses:

use Symfony\Component\Serializer\NameConverter\CamelCaseToSnakeCaseNameConverter;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
 
$normalizer = new ObjectNormalizer(null, new CamelCaseToSnakeCaseNameConverter());
 
class Person
{
    private $firstName;
 
    public function __construct($firstName)
    {
        $this->firstName = $firstName;
    }
 
    public function getFirstName()
    {
        return $this->firstName;
    }
}
 
$kevin = new Person('Kévin');
$normalizer->normalize($kevin);
// ['first_name' => 'Kévin'];
 
$anne = $normalizer->denormalize(['first_name' => 'Anne'], 'Person');
// Person object with firstName: 'Anne'

Configure name conversion using metadata

When using this component inside a Symfony application and the class metadatafactory is enabled as explained in the Attributes Groups section,this is already set up and you only need to provide the configuration. Otherwise:

// ...
use Symfony\Component\Serializer\Encoder\JsonEncoder;
use Symfony\Component\Serializer\NameConverter\MetadataAwareNameConverter;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
use Symfony\Component\Serializer\Serializer;
 
$classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
 
$metadataAwareNameConverter = new MetadataAwareNameConverter($classMetadataFactory);
 
$serializer = new Serializer(
    [new ObjectNormalizer($classMetadataFactory, $metadataAwareNameConverter)],
    ['json' => new JsonEncoder()]
);

Now configure your name conversion mapping. Consider an application thatdefines a Person entity with a firstName property:

• Annotations

namespace App\Entity;
 
use Symfony\Component\Serializer\Annotation\SerializedName;
 
class Person
{
    /**
     * @SerializedName("customer_name")
     */
    private $firstName;
 
    public function __construct($firstName)
    {
        $this->firstName = $firstName;
    }
 
    // ...
}

• YAML

App\Entity\Person:
    attributes:
        firstName:
            serialized_name: customer_name

• XML

<?xml version="1.0" ?>
<serializer xmlns="http://symfony.com/schema/dic/serializer-mapping"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/serializer-mapping
        https://symfony.com/schema/dic/serializer-mapping/serializer-mapping-1.0.xsd"
>
    <class name="App\Entity\Person">
        <attribute name="firstName" serialized-name="customer_name"/>
    </class>
</serializer>

This custom mapping is used to convert property names when serializing anddeserializing objects:

$serialized = $serializer->serialize(new Person("Kévin"));
// {"customer_name": "Kévin"}

Serializing Boolean Attributes

If you are using isser methods (methods prefixed by is, likeApp\Model\Person::isSportsperson()), the Serializer component willautomatically detect and use it to serialize related attributes.

The ObjectNormalizer also takes care of methods starting with has, addand remove.

Using Callbacks to Serialize Properties with Object Instances

Deprecated since version 4.2: The setCallbacks()method is deprecated since Symfony 4.2. Use the callbackskey of the context instead.

When serializing, you can set a callback to format a specific object property:

use App\Model\Person;
use Symfony\Component\Serializer\Encoder\JsonEncoder;
use Symfony\Component\Serializer\Normalizer\GetSetMethodNormalizer;
use Symfony\Component\Serializer\Serializer;
 
$encoder = new JsonEncoder();
 
// all callback parameters are optional (you can omit the ones you don't use)
$dateCallback = function ($innerObject, $outerObject, string $attributeName, string $format = null, array $context = []) {
    return $innerObject instanceof \DateTime ? $innerObject->format(\DateTime::ISO8601) : '';
};
 
$defaultContext = [
    AbstractNormalizer::CALLBACKS => [
        'createdAt' => $dateCallback,
    ],
];
 
$normalizer = new GetSetMethodNormalizer(null, null, null, null, null, $defaultContext);
 
$serializer = new Serializer([$normalizer], [$encoder]);
 
$person = new Person();
$person->setName('cordoval');
$person->setAge(34);
$person->setCreatedAt(new \DateTime('now'));
 
$serializer->serialize($person, 'json');
// Output: {"name":"cordoval", "age": 34, "createdAt": "2014-03-22T09:43:12-0500"}

Deprecated since version 4.2: The setCallbacks() is deprecated sinceSymfony 4.2, use the "callbacks" key of the context instead.

Normalizers

There are several types of normalizers available:

• ObjectNormalizer
• This normalizer leverages the PropertyAccess Componentto read and write in the object. It means that it can access to propertiesdirectly and through getters, setters, hassers, adders and removers. It supportscalling the constructor during the denormalization process.

Objects are normalized to a map of property names and values (names aregenerated removing the get, set, has, is or remove prefix fromthe method name and lowercasing the first letter; e.g. getFirstName() ->firstName).

The ObjectNormalizer is the most powerful normalizer. It is configured bydefault in Symfony applications with the Serializer component enabled.

• GetSetMethodNormalizer
• This normalizer reads the content of the class by calling the "getters"(public methods starting with "get"). It will denormalize data by callingthe constructor and the "setters" (public methods starting with "set").

Objects are normalized to a map of property names and values (names aregenerated removing the get prefix from the method name and lowercasingthe first letter; e.g. getFirstName() -> firstName).

• PropertyNormalizer
• This normalizer directly reads and writes public properties as well asprivate and protected properties (from both the class and all of itsparent classes). It supports calling the constructor during the denormalization process.

Objects are normalized to a map of property names to property values.

• JsonSerializableNormalizer
• This normalizer works with classes that implement JsonSerializable.

It will call the JsonSerializable::jsonSerialize() method andthen further normalize the result. This means that nestedJsonSerializable classes will also be normalized.

This normalizer is particularly helpful when you want to gradually migratefrom an existing codebase using simple json_encode to the SymfonySerializer by allowing you to mix which normalizers are used for which classes.

Unlike with json_encode circular references can be handled.

• DateTimeNormalizer
• This normalizer converts DateTimeInterface objects (e.g.DateTime and DateTimeImmutable) into strings.By default, it uses the RFC3339 format.
• DateTimeZoneNormalizer
• This normalizer converts DateTimeZone objects into strings thatrepresent the name of the timezone according to the list of PHP timezones.

New in version 4.3: The DateTimeZoneNormalizer was introduced in Symfony 4.3.

• DataUriNormalizer
• This normalizer converts SplFileInfo objects into a data URIstring (data:…) such that files can be embedded into serialized data.
• DateIntervalNormalizer
• This normalizer converts DateInterval objects into strings.By default, it uses the P%yY%mM%dDT%hH%iM%sS format.
• ConstraintViolationListNormalizer
• This normalizer converts objects that implementConstraintViolationListInterfaceinto a list of errors according to the RFC 7807 standard.

Encoders

Encoders turn arrays into formats and vice versa. They implementEncoderInterfacefor encoding (array to format) andDecoderInterface for decoding(format to array).

You can add new encoders to a Serializer instance by using its second constructor argument:

use Symfony\Component\Serializer\Encoder\JsonEncoder;
use Symfony\Component\Serializer\Encoder\XmlEncoder;
use Symfony\Component\Serializer\Serializer;
 
$encoders = [new XmlEncoder(), new JsonEncoder()];
$serializer = new Serializer([], $encoders);

Built-in Encoders

The Serializer component provides several built-in encoders:

• JsonEncoder
• This class encodes and decodes data in JSON.
• XmlEncoder
• This class encodes and decodes data in XML.
• YamlEncoder
• This encoder encodes and decodes data in YAML. This encoder requires theYaml Component.
• CsvEncoder
• This encoder encodes and decodes data in CSV.All these encoders are enabled by default when using the Serializer componentin a Symfony application.

The JsonEncoder

The JsonEncoder encodes to and decodes from JSON strings, based on the PHPjson_encode and json_decode functions.

The CsvEncoder

The CsvEncoder encodes to and decodes from CSV.

You can pass the context key as_collection in order to have the resultsalways as a collection.

Deprecated since version 4.2: Relying on the default value false is deprecated since Symfony 4.2.

The XmlEncoder

This encoder transforms arrays into XML and vice versa.

For example, take an object normalized as following:

['foo' => [1, 2], 'bar' => true];

The XmlEncoder will encode this object like that:

<?xml version="1.0"?>
<response>
    <foo>1</foo>
    <foo>2</foo>
    <bar>1</bar>
</response>

Be aware that this encoder will consider keys beginning with @ as attributes, and will usethe key #comment for encoding XML comments:

$encoder = new XmlEncoder();
$encoder->encode([
    'foo' => ['@bar' => 'value'],
    'qux' => ['#comment' => 'A comment'],
], 'xml');
// will return:
// <?xml version="1.0"?>
// <response>
//     <foo bar="value"/>
//     <qux><!-- A comment --!><qux>
// </response>

You can pass the context key as_collection in order to have the resultsalways as a collection.

Tip

XML comments are ignored by default when decoding contents, but thisbehavior can be changed with the optional $decoderIgnoredNodeTypes argument ofthe XmlEncoder class constructor.

Data with #comment keys are encoded to XML comments by default. This can bechanged with the optional $encoderIgnoredNodeTypes argument of theXmlEncoder class constructor.

The YamlEncoder

This encoder requires the Yaml Component andtransforms from and to Yaml.

Skipping null Values

By default, the Serializer will preserve properties containing a null value.You can change this behavior by setting the skip_null_values context optionto true:

$dummy = new class {
    public $foo;
    public $bar = 'notNull';
};
 
$normalizer = new ObjectNormalizer();
$result = $normalizer->normalize($dummy, 'json', ['skip_null_values' => true]);
// ['bar' => 'notNull']

Handling Circular References

Circular references are common when dealing with entity relations:

class Organization
{
    private $name;
    private $members;
 
    public function setName($name)
    {
        $this->name = $name;
    }
 
    public function getName()
    {
        return $this->name;
    }
 
    public function setMembers(array $members)
    {
        $this->members = $members;
    }
 
    public function getMembers()
    {
        return $this->members;
    }
}
 
class Member
{
    private $name;
    private $organization;
 
    public function setName($name)
    {
        $this->name = $name;
    }
 
    public function getName()
    {
        return $this->name;
    }
 
    public function setOrganization(Organization $organization)
    {
        $this->organization = $organization;
    }
 
    public function getOrganization()
    {
        return $this->organization;
    }
}

To avoid infinite loops, GetSetMethodNormalizeror ObjectNormalizerthrow a CircularReferenceExceptionwhen such a case is encountered:

$member = new Member();
$member->setName('Kévin');
 
$organization = new Organization();
$organization->setName('Les-Tilleuls.coop');
$organization->setMembers([$member]);
 
$member->setOrganization($organization);
 
echo $serializer->serialize($organization, 'json'); // Throws a CircularReferenceException

The key circular_reference_limit in the default context sets the number oftimes it will serialize the same object before considering it a circularreference. The default value is 1.

Instead of throwing an exception, circular references can also be handledby custom callables. This is especially useful when serializing entitieshaving unique identifiers:

$encoder = new JsonEncoder();
$defaultContext = [
    AbstractNormalizer::CIRCULAR_REFERENCE_HANDLER => function ($object, $format, $context) {
        return $object->getName();
    },
];
$normalizer = new ObjectNormalizer(null, null, null, null, null, null, $defaultContext);
 
$serializer = new Serializer([$normalizer], [$encoder]);
var_dump($serializer->serialize($org, 'json'));
// {"name":"Les-Tilleuls.coop","members":[{"name":"K\u00e9vin", organization: "Les-Tilleuls.coop"}]}

Deprecated since version 4.2: The setCircularReferenceHandler()method is deprecated since Symfony 4.2. Use the circular_reference_handlerkey of the context instead.

Handling Serialization Depth

The Serializer component is able to detect and limit the serialization depth.It is especially useful when serializing large trees. Assume the following datastructure:

namespace Acme;
 
class MyObj
{
    public $foo;
 
    /**
     * @var self
     */
    public $child;
}
 
$level1 = new MyObj();
$level1->foo = 'level1';
 
$level2 = new MyObj();
$level2->foo = 'level2';
$level1->child = $level2;
 
$level3 = new MyObj();
$level3->foo = 'level3';
$level2->child = $level3;

The serializer can be configured to set a maximum depth for a given property.Here, we set it to 2 for the $child property:

• Annotations

namespace Acme;
 
use Symfony\Component\Serializer\Annotation\MaxDepth;
 
class MyObj
{
    /**
     * @MaxDepth(2)
     */
    public $child;
 
    // ...
}

• YAML

Acme\MyObj:
    attributes:
        child:
            max_depth: 2

• XML

<?xml version="1.0" ?>
<serializer xmlns="http://symfony.com/schema/dic/serializer-mapping"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/serializer-mapping
        https://symfony.com/schema/dic/serializer-mapping/serializer-mapping-1.0.xsd"
>
    <class name="Acme\MyObj">
        <attribute name="child" max-depth="2"/>
    </class>
</serializer>

The metadata loader corresponding to the chosen format must be configured inorder to use this feature. It is done automatically when using the Serializer componentin a Symfony application. When using the standalone component, refer tothe groups documentation tolearn how to do that.

The check is only done if the enable_max_depth key of the serializer contextis set to true. In the following example, the third level is not serializedbecause it is deeper than the configured maximum depth of 2:

$result = $serializer->normalize($level1, null, ['enable_max_depth' => true]);
/*
$result = [
    'foo' => 'level1',
    'child' => [
        'foo' => 'level2',
        'child' => [
            'child' => null,
        ],
    ],
];
*/

Instead of throwing an exception, a custom callable can be executed when themaximum depth is reached. This is especially useful when serializing entitieshaving unique identifiers:

use Doctrine\Common\Annotations\AnnotationReader;
use Symfony\Component\Serializer\Annotation\MaxDepth;
use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
use Symfony\Component\Serializer\Serializer;
 
class Foo
{
    public $id;
 
    /**
     * @MaxDepth(1)
     */
    public $child;
}
 
$level1 = new Foo();
$level1->id = 1;
 
$level2 = new Foo();
$level2->id = 2;
$level1->child = $level2;
 
$level3 = new Foo();
$level3->id = 3;
$level2->child = $level3;
 
$classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
 
// all callback parameters are optional (you can omit the ones you don't use)
$maxDepthHandler = function ($innerObject, $outerObject, string $attributeName, string $format = null, array $context = []) {
    return '/foos/'.$innerObject->id;
};
 
$defaultContext = [
    AbstractObjectNormalizer::MAX_DEPTH_HANDLER => $maxDepthHandler,
];
$normalizer = new ObjectNormalizer($classMetadataFactory, null, null, null, null, null, $defaultContext);
 
$serializer = new Serializer([$normalizer]);
 
$result = $serializer->normalize($level1, null, [ObjectNormalizer::ENABLE_MAX_DEPTH => true]);
/*
$result = [
    'id' => 1,
    'child' => [
        'id' => 2,
        'child' => '/foos/3',
    ],
];
*/

Deprecated since version 4.2: The setMaxDepthHandler()method is deprecated since Symfony 4.2. Use the max_depth_handlerkey of the context instead.

Handling Arrays

The Serializer component is capable of handling arrays of objects as well.Serializing arrays works just like serializing a single object:

use Acme\Person;
 
$person1 = new Person();
$person1->setName('foo');
$person1->setAge(99);
$person1->setSportsman(false);
 
$person2 = new Person();
$person2->setName('bar');
$person2->setAge(33);
$person2->setSportsman(true);
 
$persons = [$person1, $person2];
$data = $serializer->serialize($persons, 'json');
 
// $data contains [{"name":"foo","age":99,"sportsman":false},{"name":"bar","age":33,"sportsman":true}]

If you want to deserialize such a structure, you need to add theArrayDenormalizerto the set of normalizers. By appending [] to the type parameter of thedeserialize() method,you indicate that you're expecting an array instead of a single object:

use Symfony\Component\Serializer\Encoder\JsonEncoder;
use Symfony\Component\Serializer\Normalizer\ArrayDenormalizer;
use Symfony\Component\Serializer\Normalizer\GetSetMethodNormalizer;
use Symfony\Component\Serializer\Serializer;
 
$serializer = new Serializer(
    [new GetSetMethodNormalizer(), new ArrayDenormalizer()],
    [new JsonEncoder()]
);
 
$data = ...; // The serialized data from the previous example
$persons = $serializer->deserialize($data, 'Acme\Person[]', 'json');

The XmlEncoder

This encoder transforms arrays into XML and vice versa. For example, take anobject normalized as following:

['foo' => [1, 2], 'bar' => true];

The XmlEncoder encodes this object as follows:

<?xml version="1.0"?>
<response>
    <foo>1</foo>
    <foo>2</foo>
    <bar>1</bar>
</response>

The array keys beginning with @ are considered XML attributes:

['foo' => ['@bar' => 'value']];

// is encoded as follows:
// <?xml version="1.0"?>
// <response>
//     <foo bar="value"/>
// </response>

Use the special # key to define the data of a node:

['foo' => ['@bar' => 'value', '#' => 'baz']];

// is encoded as follows:
// <?xml version="1.0"?>
// <response>
//     <foo bar="value">
//        baz
//     </foo>
// </response>

Context

The encode() method defines a third optional parameter called contextwhich defines the configuration options for the XmlEncoder an associative array:

$xmlEncoder->encode($array, 'xml', $context);

These are the options available:

• xml_format_output
• If set to true, formats the generated XML with line breaks and indentation.
• xml_version
• Sets the XML version attribute (default: 1.1).
• xml_encoding
• Sets the XML encoding attribute (default: utf-8).
• xml_standalone
• Adds standalone attribute in the generated XML (default: true).
• xml_root_node_name
• Sets the root node name (default: response).
• remove_empty_tags
• If set to true, removes all empty tags in the generated XML.

Handling Constructor Arguments

If the class constructor defines arguments, as usually happens withValue Objects, the serializer won't be able to create the object if somearguments are missing. In those cases, use the default_constructor_argumentscontext option:

use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
use Symfony\Component\Serializer\Serializer;

class MyObj
{
    private $foo;
    private $bar;

    public function __construct($foo, $bar)
    {
        $this->foo = $foo;
        $this->bar = $bar;
    }
}

$normalizer = new ObjectNormalizer($classMetadataFactory);
$serializer = new Serializer([$normalizer]);

$data = $serializer->denormalize(
    ['foo' => 'Hello'],
    'MyObj',
    ['default_constructor_arguments' => [
        'MyObj' => ['foo' => '', 'bar' => ''],
    ]]
);
// $data = new MyObj('Hello', '');

Recursive Denormalization and Type Safety

The Serializer component can use the PropertyInfo Component to denormalizecomplex types (objects). The type of the class' property will be guessed using the providedextractor and used to recursively denormalize the inner data.

When using this component in a Symfony application, all normalizers are automatically configured to use the registered extractors.When using the component standalone, an implementation of PropertyTypeExtractorInterface,(usually an instance of PropertyInfoExtractor) must be passed as the 4thparameter of the ObjectNormalizer:

namespace Acme;

use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
use Symfony\Component\Serializer\Normalizer\DateTimeNormalizer;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
use Symfony\Component\Serializer\Serializer;

class ObjectOuter
{
    private $inner;
    private $date;

    public function getInner()
    {
        return $this->inner;
    }

    public function setInner(ObjectInner $inner)
    {
        $this->inner = $inner;
    }

    public function setDate(\DateTimeInterface $date)
    {
        $this->date = $date;
    }

    public function getDate()
    {
        return $this->date;
    }
}

class ObjectInner
{
    public $foo;
    public $bar;
}

$normalizer = new ObjectNormalizer(null, null, null, new ReflectionExtractor());
$serializer = new Serializer([new DateTimeNormalizer(), $normalizer]);

$obj = $serializer->denormalize(
    ['inner' => ['foo' => 'foo', 'bar' => 'bar'], 'date' => '1988/01/21'],
    'Acme\ObjectOuter'
);

dump($obj->getInner()->foo); // 'foo'
dump($obj->getInner()->bar); // 'bar'
dump($obj->getDate()->format('Y-m-d')); // '1988-01-21'

When a PropertyTypeExtractor is available, the normalizer will also check that the data to denormalizematches the type of the property (even for primitive types). For instance, if a string is provided, butthe type of the property is int, an UnexpectedValueExceptionwill be thrown. The type enforcement of the properties can be disabled by settingthe serializer context option ObjectNormalizer::DISABLE_TYPE_ENFORCEMENTto true.

Serializing Interfaces and Abstract Classes

When dealing with objects that are fairly similar or share properties, you mayuse interfaces or abstract classes. The Serializer component allows you toserialize and deserialize these objects using a "discriminator class mapping".

The discriminator is the field (in the serialized string) used to differentiatebetween the possible objects. In practice, when using the Serializer component,pass a ClassDiscriminatorResolverInterfaceimplementation to the ObjectNormalizer.

The Serializer component provides an implementation of ClassDiscriminatorResolverInterfacecalled ClassDiscriminatorFromClassMetadatawhich uses the class metadata factory and a mapping configuration to serializeand deserialize objects of the correct class.

When using this component inside a Symfony application and the class metadata factory is enabledas explained in the Attributes Groups section,this is already set up and you only need to provide the configuration. Otherwise:

// ...
use Symfony\Component\Serializer\Encoder\JsonEncoder;
use Symfony\Component\Serializer\Mapping\ClassDiscriminatorFromClassMetadata;
use Symfony\Component\Serializer\Mapping\ClassDiscriminatorMapping;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
use Symfony\Component\Serializer\Serializer;

$classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));

$discriminator = new ClassDiscriminatorFromClassMetadata($classMetadataFactory);

$serializer = new Serializer(
    [new ObjectNormalizer($classMetadataFactory, null, null, null, $discriminator)],
    ['json' => new JsonEncoder()]
);

Now configure your discriminator class mapping. Consider an application thatdefines an abstract CodeRepository class extended by GitHubCodeRepositoryand BitBucketCodeRepository classes:

• Annotations

namespace App;

use Symfony\Component\Serializer\Annotation\DiscriminatorMap;

/**
 * @DiscriminatorMap(typeProperty="type", mapping={
 *    "github"="App\GitHubCodeRepository",
 *    "bitbucket"="App\BitBucketCodeRepository"
 * })
 */
interface CodeRepository
{
    // ...
}

• YAML

App\CodeRepository:
    discriminator_map:
        type_property: type
        mapping:
            github: 'App\GitHubCodeRepository'
            bitbucket: 'App\BitBucketCodeRepository'

• XML

<?xml version="1.0" ?>
<serializer xmlns="http://symfony.com/schema/dic/serializer-mapping"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/serializer-mapping
        https://symfony.com/schema/dic/serializer-mapping/serializer-mapping-1.0.xsd"
>
    <class name="App\CodeRepository">
        <discriminator-map type-property="type">
            <mapping type="github" class="App\GitHubCodeRepository"/>
            <mapping type="bitbucket" class="App\BitBucketCodeRepository"/>
        </discriminator-map>
    </class>
</serializer>

Once configured, the serializer uses the mapping to pick the correct class:

$serialized = $serializer->serialize(new GitHubCodeRepository());
// {"type": "github"}

$repository = $serializer->deserialize($serialized, CodeRepository::class, 'json');
// instanceof GitHubCodeRepository

Performance

To figure which normalizer (or denormalizer) must be used to handle an object,the Serializer class will call thesupportsNormalization()(or supportsDenormalization())of all registered normalizers (or denormalizers) in a loop.

The result of these methods can vary depending on the object to serialize, theformat and the context. That's why the result is not cached by default andcan result in a significant performance bottleneck.

However, most normalizers (and denormalizers) always return the same result whenthe object's type and the format are the same, so the result can be cached. Todo so, make those normalizers (and denormalizers) implement theCacheableSupportsMethodInterfaceand return true whenhasCacheableSupportsMethod()is called.

Note

All built-in normalizers and denormalizersas well the ones included in API Platform natively implement this interface.

Learn more

• How to Use the Serializer

Normalizers for the Symfony Serializer Component supporting popular web API formats(JSON-LD, GraphQL, OpenAPI, HAL, JSON:API) are available as part of the API Platform project.

A popular alternative to the Symfony Serializer component is the third-partylibrary, JMS serializer (versions before v1.12.0 were released underthe Apache license, so incompatible with GPLv2 projects).