How to use (chain?) multiple normalizers with Symfony Serializer?

Question

can somebody try to explain me how to use multiple normalizers when serializing data from multiple classes with the Symfony serializer?

Lets say that I have the following classes:

class User
{
    private $name;
    private $books;

    public function __construct()
    {
        $this->books = new ArrayCollection();
    }

    // getters and setters
}

class Book
{
    private $title;

    public function getTitle()
    {
        return $this->title;
    }    

    public function setTitle($title)
    {
        $this->title = $title;
    }
}

And I want to serialize an user who has multiple books.

$first = new Book();
$first->setTitle('First book');

$second = new Book();
$second->setTitle('Second book');

$user = new User();
$user->setName('Person name');
$user->addBook($first);
$user->addBook($second);

dump($this->get('serializer')->serialize($user, 'json'));
die();

Let's say that I also want to include a hash when serializing a book, so I have the following normalizer:

class BookNormalizer implements NormalizerInterface
{
    public function normalize($object, $format = null, array $context = array())
    {
        return [
            'title' => $object->getTitle(),
            'hash' => md5($object->getTitle())
        ];
    }

    public function supportsNormalization($data, $format = null)
    {
        return $data instanceof Book;
    }
}

And I am getting the expected result: {"name":"Person name","books":[{"title":"First book","hash":"a9c04245e768bc5bedd57ebd62a6309e"},{"title":"Second book","hash":"c431a001cb16a82a937579a50ea12e51"}]}

The problem comes when I also add a normalizer for the User class:

class UserNormalizer implements NormalizerInterface
{
    public function normalize($object, $format = null, array $context = array())
    {
        return [
            'name' => $object->getName(),
            'books' => $object->getBooks()
        ];
    }

    public function supportsNormalization($data, $format = null)
    {
        return $data instanceof User;
    }
}

Now, the books aren't normalized using the previously given normalizer, and i get the following: {"name":"Person name","books":[{},{}]}

I tried to find a way (documentation and other articles) to always call the normalizers for the given types (eg. always call the book normalizer when the type is Book, even if the data is nested and used in another normalizer) but could not succeed.

I think i have misunderstood something about normalizers but don't know what. Can somebody explain to is what i want possible and how to do it?

Answer 1

You have to use the NormalizerAwareTrait so you can access the normalizer for books

• add interface
• use trait
• call normalize() method for books

code:

class UserNormalizer implements NormalizerInterface, NormalizerAwareInterface
{
    use NormalizerAwareTrait;

    public function normalize($object, $format = null, array $context = array())
    {
        return [
            'name' => $object->getName(),
            'books' => $this->normalizer->normalize($object->getBooks(), $format, $context)
        ];
    }

    public function supportsNormalization($data, $format = null)
    {
        return $data instanceof User;
    }
}