Show
The Serializer Component
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 between objects and serialized contents. This way, encoders will only deal with turning specific formats into arrays and vice versa. The same way, Normalizers will 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. InstallationNote If you install this component outside of a Symfony application, you must require the To use
the UsageSee also This article explains the philosophy of the Serializer and gets you familiar with the concepts of normalizers and encoders. The code examples assume that you use the Serializer as an independent component. If you are using the Serializer in a Symfony application, read How to Use the Serializer after you finish this article. To use the Serializer component, set up the Serializer specifying which encoders and normalizer are going to be available: The preferred
normalizer is the ObjectNormalizer, but other normalizers are available. All the examples shown below use the Serializing an ObjectFor the sake of this example, assume the following class already exists in your project: Now, if you want to serialize this object into JSON, you only need to use the Serializer service created before: 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 ObjectYou'll now learn how to do the exact
opposite. This time, the information of the In this case, deserialize() needs three parameters:
By default, additional attributes that are not mapped to the denormalized object will be ignored by the Serializer component. If you prefer to throw an exception when this happens, set the Deserializing in an Existing ObjectThe serializer can also be used to update an existing object: This is a common need when working with an ORM. The When the Attributes GroupsSometimes, you want to serialize different sets of attributes from your entities. Groups are a handy way to achieve this need. Assume you have the following plain-old-PHP object: The definition of serialization can be specified using annotations, XML or YAML. The ClassMetadataFactory that will be used by the normalizer must be aware of the format to use. The following code shows how to initialize the ClassMetadataFactory for each format:
Then, create your groups definition:
You are now able to serialize only attributes in the groups you want: Selecting Specific AttributesIt is also possible to serialize only a set of specific attributes: 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 AttributesAll attributes are included by default when serializing objects. There are two options to ignore some of those attributes. Option 2: Using the ContextPass an array with the names of the attributes to ignore using the Converting Property Names when Serializing and DeserializingSometimes serialized attributes must be named differently than properties or getter/setter methods of PHP classes. The Serializer component provides a handy way to translate or map PHP field names to serialized names: The Name Converter System. Given you have the following object: And in the serialized form, all attributes must be prefixed by A custom name converter can handle such cases: The custom name converter can be used by passing it as second parameter of any class extending AbstractNormalizer, including GetSetMethodNormalizer and PropertyNormalizer: CamelCase to snake_caseIn many formats, it's common to use underscores to separate words (also known as snake_case). However, in Symfony applications is common to use CamelCase to name properties (even though the PSR-1 standard doesn't recommend any specific case for property names). Symfony provides a built-in name converter designed to transform between snake_case and CamelCased styles during serialization and deserialization processes: Configure name conversion using metadataWhen using this component inside a Symfony application and the class metadata factory is enabled as explained in the Attributes Groups section, this is already set up and you only need to provide the configuration. Otherwise: Now configure your name conversion mapping. Consider an application that defines a
This custom mapping is used to convert property names when serializing and deserializing objects: Serializing Boolean AttributesIf you are using isser methods (methods prefixed by The 6.1 The support of canners (methods prefixed by NormalizersNormalizers turn objects into arrays and vice versa. They implement NormalizerInterface for normalizing (object to array) and DenormalizerInterface for denormalizing (array to object). Normalizers are enabled in the serializer passing them as its first argument: Built-in NormalizersThe Serializer component provides several built-in normalizers: ObjectNormalizerThis normalizer leverages the PropertyAccess Component to read and write in the object. It means that it can access to properties directly and through getters, setters, hassers, issers, canners, adders and removers. It supports calling the constructor during the denormalization process. Objects are normalized to a map of property names and values (names are generated by removing the
The This normalizer reads the content of the class by calling the "getters" (public methods starting with "get"). It will denormalize data by calling the constructor and the "setters" (public methods starting with "set"). Objects are normalized to a map of property names and values (names are generated by removing the This normalizer directly reads and writes public properties as well as private and protected properties (from both the class and all of its parent classes) by using PHP reflection. It supports calling the constructor during the denormalization process. Objects are normalized to a map of property names to property values. JsonSerializableNormalizerThis normalizer works with classes that implement JsonSerializable. It will call the JsonSerializable::jsonSerialize() method and then further normalize the result. This means that nested JsonSerializable classes will also be normalized. This normalizer is particularly helpful when you want to gradually migrate from an existing codebase using simple json_encode to the Symfony Serializer 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 that represent the name of the timezone according to the list of PHP timezones. DataUriNormalizer This normalizer converts SplFileInfo objects into a data URI string (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. BackedEnumNormalizer This normalizer converts a BackedEnum objects into strings or integers. FormErrorNormalizerThis normalizer works with classes that implement FormInterface. It will get errors from the form and normalize them into a normalized array. ConstraintViolationListNormalizer This normalizer converts objects that implement ConstraintViolationListInterface into a list of errors according to the RFC 7807 standard. ProblemNormalizer Normalizes errors according to the API Problem spec RFC 7807. CustomNormalizer Normalizes a PHP object using an object that implements NormalizableInterface. UidNormalizerThis normalizer converts objects that implement
AbstractUid into strings. The default normalization format for objects that implement Uuid is the
RFC 4122 format (example: Also it can denormalize Certain normalizers are enabled by default when using the Serializer component in a Symfony application, additional ones can be enabled by tagging them with serializer.normalizer. Here is an example of how to enable the built-in GetSetMethodNormalizer, a faster alternative to the ObjectNormalizer:
EncodersEncoders turn arrays into formats and vice versa. They implement EncoderInterface for encoding (array to format) and DecoderInterface for decoding (format to array). You can add new encoders to a Serializer instance by using its second constructor argument: Built-in EncodersThe 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 the Yaml Component. CsvEncoder This encoder encodes and decodes data in CSV.All these encoders are enabled by default when using the Serializer component in a Symfony application. The JsonEncoderThe The CsvEncoderThe The |
Option | Description | Default |
---|---|---|
csv_delimiter
| Sets the field delimiter separating values (one character only) | ,
|
csv_enclosure
| Sets the field enclosure (one character only) | "
|
csv_end_of_line
| Sets the character(s) used to mark the end of each line in the CSV file | \n
|
csv_escape_char
| Sets the escape character (at most one character) | empty string |
csv_key_separator
| Sets the separator for array's keys during its flattening | .
|
csv_headers
| Sets the order of the header and data columns E.g.: if $data = ['c' => 3, 'a' => 1, 'b' => 2] and $options = ['csv_headers' => ['a', 'b', 'c']] then serialize($data, 'csv', $options) returns a,b,c\n1,2,3
| [] , inferred from input data's keys
|
csv_escape_formulas
| Escapes fields containing formulas by prepending them with a \t character
| false
|
as_collection
| Always returns results as a collection, even if only one line is decoded. | true
|
no_headers
| Disables header in the encoded CSV | false
|
output_utf8_bom
| Outputs special UTF-8 BOM along with encoded data | false
|
The XmlEncoder
This encoder transforms arrays into XML and vice versa.
For example, take an object normalized as following:
The XmlEncoder
will encode this object like that:
The special #
key can be used to define the data of a node:
Furthermore, keys
beginning with @
will be considered attributes, and the key #comment
can be used for encoding XML comments:
You can pass the context key as_collection
in order to have the results always as a collection.
Tip
XML comments are ignored by default when decoding contents, but this behavior can be changed with the optional context key XmlEncoder::DECODER_IGNORED_NODE_TYPES
.
Data with #comment
keys are encoded to XML comments by default. This can be changed with the optional $encoderIgnoredNodeTypes
argument of the XmlEncoder
class constructor.
The XmlEncoder
Context Options
The encode()
method defines a third optional parameter called context
which defines the configuration options for the XmlEncoder an associative array:
These are the options available:
Option | Description | Default |
---|---|---|
xml_format_output
| If set to true, formats the generated XML with line breaks and indentation | false
|
xml_version
| Sets the XML version attribute | 1.1
|
xml_encoding
| Sets the XML encoding attribute | utf-8
|
xml_standalone
| Adds standalone attribute in the generated XML | true
|
xml_type_cast_attributes
| This provides the ability to forget the attribute type casting | true
|
xml_root_node_name
| Sets the root node name | response
|
as_collection
| Always returns results as a collection, even if only one line is decoded | false
|
decoder_ignored_node_types
| Array of node types (DOM XML_* constants) to be ignored while decoding | [\XML_PI_NODE, \XML_COMMENT_NODE]
|
encoder_ignored_node_types
| Array of node types (DOM XML_* constants) to be ignored while encoding | []
|
load_options
| XML loading options with libxml | \LIBXML_NONET | \LIBXML_NOBLANKS
|
remove_empty_tags
| If set to true, removes all empty tags in the generated XML | false
|
Example with custom context
:
The YamlEncoder
This encoder requires the Yaml Component and transforms from and to Yaml.
The YamlEncoder
Context Options
The encode()
method, like other encoder, uses context
to set configuration options for the YamlEncoder an associative array:
These are the options available:
Option | Description | Default |
---|---|---|
yaml_inline
| The level where you switch to inline YAML | 0
|
yaml_indent
| The level of indentation (used internally) | 0
|
yaml_flags
| A bit field of Yaml::DUMP_* / PARSE_* constants to customize the encoding / decoding YAML string
| 0
|
Context Builders
Instead of passing plain PHP arrays to the serialization context, you can use "context builders" to define the context using a fluent interface:
6.1
Context builders were introduced in Symfony 6.1.
Skipping null Values
By default, the Serializer will preserve properties containing a null
value. You can change this behavior by setting the AbstractObjectNormalizer::SKIP_NULL_VALUES
context option to true
:
Collecting Type Errors While Denormalizing
When denormalizing a payload to an object with typed properties, you'll get an exception if the payload contains properties that don't have the same type as the object.
In those situations, use the COLLECT_DENORMALIZATION_ERRORS
option to collect all
exceptions at once, and to get the object partially denormalized:
Handling Circular References
Circular references are common when dealing with entity relations:
To avoid infinite loops, GetSetMethodNormalizer or ObjectNormalizer throw a CircularReferenceException when such a case is encountered:
The key circular_reference_limit
in the default context sets the number of times it will serialize the same object before considering it a circular reference. The default value is 1
.
Instead of throwing an exception, circular references can also be handled by custom callables. This is especially useful when serializing entities having unique identifiers:
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 data structure:
The serializer can be configured to set a maximum depth for a given property. Here, we set it to 2 for the $child
property:
- Attributes
- YAML
- XML
The metadata loader corresponding to the chosen format must be configured in order to use this feature. It is done automatically when using the Serializer component in a Symfony application. When using the standalone component, refer to the groups documentation to learn how to do that.
The check is only done if the AbstractObjectNormalizer::ENABLE_MAX_DEPTH
key of the serializer context is set to true
. In the following example, the third level is not serialized because
it is deeper than the configured maximum depth of 2:
Instead of throwing an exception, a custom callable can be executed when the maximum depth is reached. This is especially useful when serializing entities having unique identifiers:
Handling Arrays
The Serializer component is capable of handling arrays of objects as well. Serializing arrays works just like serializing a single object:
If you want to deserialize such a structure, you need to add the ArrayDenormalizer to the set of normalizers. By appending []
to the type parameter of the
deserialize() method, you indicate that you're expecting an array instead of a single object:
Handling Constructor Arguments
If the class constructor defines arguments, as usually happens with Value Objects, the serializer won't be able to create the object if some arguments are missing. In those cases, use the default_constructor_arguments
context option:
Recursive Denormalization and Type Safety
The Serializer component can use the PropertyInfo Component to denormalize complex types (objects). The type of the class' property will be guessed using the provided extractor 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 4th parameter of the ObjectNormalizer
:
When a PropertyTypeExtractor
is available, the normalizer will also check that the data to denormalize matches the type of the property (even for primitive types). For instance, if a string
is
provided, but the type of the property is int
, an UnexpectedValueException will be thrown. The type enforcement of the properties can be disabled by setting the serializer context option ObjectNormalizer::DISABLE_TYPE_ENFORCEMENT
to true
.
Serializing Interfaces and Abstract Classes
When dealing with objects that are fairly similar or share properties, you may use interfaces or abstract classes. The Serializer component allows you to serialize and deserialize these objects using a "discriminator class mapping".
The discriminator is the field (in the serialized string) used to differentiate between the possible objects. In practice, when using the Serializer component, pass a ClassDiscriminatorResolverInterface implementation to the ObjectNormalizer.
The Serializer component provides an implementation of ClassDiscriminatorResolverInterface
called
ClassDiscriminatorFromClassMetadata which uses the class metadata factory and a mapping configuration to serialize and deserialize objects of the correct class.
When using this component inside a Symfony application and the class metadata factory is enabled as explained in the Attributes Groups section, this is already set up and you only need to provide the configuration. Otherwise:
Now configure your discriminator class mapping. Consider an application that defines an abstract CodeRepository
class extended by GitHubCodeRepository
and BitBucketCodeRepository
classes:
- Attributes
- YAML
- XML
Once configured, the serializer uses the mapping to pick the correct class:
Learn more
- How to Use the Serializer
See also
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.
See also
A popular alternative to the Symfony Serializer component is the third-party library, JMS serializer (versions before v1.12.0
were released under the Apache license, so incompatible with GPLv2 projects).