How to Create your Custom Normalizer

The Serializer component uses normalizers to transform any data into an array. The component provides several ref:`built-in normalizers <serializer-built-in-normalizers>` but you may need to create your own normalizer to transform an unsupported data structure.

Creating a New Normalizer

Imagine you want add, modify, or remove some properties during the serialization process. For that you'll have to create your own normalizer. But it's usually preferable to let Symfony normalize the object, then hook into the normalization to customize the normalized data. To do that, leverage the ObjectNormalizer:

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
        // src/Serializer/TopicNormalizer.php
namespace App\Serializer;

use App\Entity\Topic;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Serializer\Normalizer\NormalizerAwareInterface;
use Symfony\Component\Serializer\Normalizer\NormalizerAwareTrait;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;

class TopicNormalizer implements NormalizerInterface
{
    public function __construct(
        private UrlGeneratorInterface $router,
        private ObjectNormalizer $normalizer,
    ) {
    }

    public function normalize($topic, ?string $format = null, array $context = []): array
    {
        $data = $this->normalizer->normalize($topic, $format, $context);

        // Here, add, edit, or delete some data:
        $data['href']['self'] = $this->router->generate('topic_show', [
            'id' => $topic->getId(),
        ], UrlGeneratorInterface::ABSOLUTE_URL);

        return $data;
    }

    public function supportsNormalization($data, ?string $format = null, array $context = []): bool
    {
        return $data instanceof Topic;
    }
}
    

6.1

Injecting an ObjectNormalizer in your custom normalizer is deprecated since Symfony 6.1. Implement the NormalizerAwareInterface and use the NormalizerAwareTrait instead to inject the $normalizer property.

Registering it in your Application

Before using this normalizer in a Symfony application it must be registered as a service and tagged with serializer.normalizer. If you're using the default services.yaml configuration, this is done automatically!

If you're not using autoconfigure, you have to tag the service with serializer.normalizer. You can also use this method to set a priority (higher means it's called earlier in the process):

        1
2
3
4
5
6
7
8
        # config/services.yaml
services:
    # ...

    App\Serializer\TopicNormalizer:
        tags:
            # register the normalizer with a high priority (called earlier)
            - { name: 'serializer.normalizer', priority: 500 }
    

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
        <!-- config/services.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd">

    <services>
        <!-- ... -->

        <service id="App\Serializer\TopicNormalizer">
            <!-- register the normalizer with a high priority (called earlier) -->
            <tag name="serializer.normalizer"
                priority="500"
            />
        </service>
    </services>
</container>
    

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
        // config/services.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

use App\Serializer\TopicNormalizer;

return function(ContainerConfigurator $container) {
    // ...

    // if you're using autoconfigure, the tag will be automatically applied
    $services->set(TopicNormalizer::class)
        // register the normalizer with a high priority (called earlier)
        ->tag('serializer.normalizer', [
            'priority' => 500,
        ])
    ;
};
    

Performance

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

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

However, most normalizers (and denormalizers) always return the same result when the object's type and the format are the same, so the result can be cached. To do so, make those normalizers (and denormalizers) implement the CacheableSupportsMethodInterface and return true when hasCacheableSupportsMethod() is called.

Note

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

6.3

The CacheableSupportsMethodInterface interface is deprecated since Symfony 6.3. You should implement the getSupportedTypes() method instead, as shown in the section below.

Improving Performance of Normalizers/Denormalizers

6.3

The getSupportedTypes() method was introduced in Symfony 6.3.

Both NormalizerInterface and DenormalizerInterface contain a new method getSupportedTypes(). This method allows normalizers or denormalizers to declare the type of objects they can handle, and whether they are cacheable. With this info, even if the supports*() call is not cacheable, the Serializer can skip a ton of method calls to supports*() improving performance substantially in some cases.

The getSupportedTypes() method should return an array where the keys represent the supported types, and the values indicate whether the result of the supports*() method call can be cached or not. The format of the returned array is as follows:

The special key object can be used to indicate that the normalizer or denormalizer supports any classes or interfaces.
The special key * can be used to indicate that the normalizer or denormalizer might support any types.
The other keys in the array should correspond to specific types that the normalizer or denormalizer supports.
The values associated with each type should be a boolean indicating if the result of the supports*() method call for that type can be cached or not. A value of true means that the result is cacheable, while false means that the result is not cacheable.
A null value for a type means that the normalizer or denormalizer does not support that type.

Here is an example of how to use the getSupportedTypes() method:

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
        use Symfony\Component\Serializer\Normalizer\NormalizerInterface;

class MyNormalizer implements NormalizerInterface
{
    // ...

    public function getSupportedTypes(?string $format): array
    {
        return [
            'object' => null,             // Doesn't support any classes or interfaces
            '*' => false,                 // Supports any other types, but the result is not cacheable
            MyCustomClass::class => true, // Supports MyCustomClass and result is cacheable
        ];
    }
}
    

Note

The supports*() method implementations should not assume that getSupportedTypes() has been called before.

This work, including the code samples, is licensed under a Creative Commons BY-SA 3.0 license.

TOC

Version