La sérialisation de l'Entité Rapport avec l'Identifiant JMS Sérialiseur

Juste pour suivre répondu à la question:

Si vous n'aimez pas écrire une méthode pour chaque relation que vous avez - il suffit d'écrire votre propre gestionnaire. C'est facile comme

final class RelationsHandler
{
    /**
     * @var EntityManagerInterface
     */
    private $manager;

    /**
     * RelationsHandler constructor.
     *
     * @param EntityManagerInterface $manager
     */
    public function __construct(EntityManagerInterface $manager) { $this->manager = $manager; }


    public function serializeRelation(JsonSerializationVisitor $visitor, $relation, array $type, Context $context)
    {
        if ($relation instanceof \Traversable) {
            $relation = iterator_to_array($relation);
        }

        if (is_array($relation)) {
            return array_map([$this, 'getSingleEntityRelation'], $relation);
        }

        return $this->getSingleEntityRelation($relation);
    }

    /**
     * @param $relation
     *
     * @return array|mixed
     */
    protected function getSingleEntityRelation($relation)
    {
        $metadata = $this->manager->getClassMetadata(get_class($relation));

        $ids = $metadata->getIdentifierValues($relation);
        if (!$metadata->isIdentifierComposite) {
            $ids = array_shift($ids);
        }

        return $ids;
    }
}

Enregistrer le Gestionnaire

  jms_serializer.handler.relation:
      class: MyBundle\RelationsHandler
      arguments:
      - "@doctrine.orm.entity_manager"
      tags:
      - { name: jms_serializer.handler, type: Relation, direction: serialization, format: json, method: serializeRelation}
      - { name: jms_serializer.handler, type: Relation, direction: deserialization, format: json, method: deserializeRelation}
      - { name: jms_serializer.handler, type: Relation<?>, direction: serialization, format: json, method: serializeRelation}
      - { name: jms_serializer.handler, type: Relation<?>, direction: deserialization, format: json, method: deserializeRelation}

Cela vous permet de remplacer virtuel des méthodes de lecture avec "Type" ("Rapport").

Si vous aussi vous voulez pas de désérialiser de relation que vous devez dire à chaque @Type("Relation") la classe ( @Type("Relation<FQCN>") ), à qui il doit désérialiser ou envelopper les métadonnées pilote avec qui le faire pour vous.

    public function deserializeRelation(JsonDeserializationVisitor $visitor, $relation, array $type, Context $context)
    {
        $className = isset($type['params'][0]['name']) ? $type['params'][0]['name'] : null;

        if (!class_exists($className, false)) {
            throw new \InvalidArgumentException('Class name should be explicitly set for deserialization');
        }

        $metadata = $this->manager->getClassMetadata($className);

        if (!is_array($relation)) {
            return $this->manager->getReference($className, $relation);
        }

        $single = false;
        if ($metadata->isIdentifierComposite) {
            $single = true;
            foreach ($metadata->getIdentifierFieldNames() as $idName) {
                $single = $single && array_key_exists($idName, $relation);
            }
        }

        if ($single) {
            return $this->manager->getReference($className, $relation);
        }

        $objects = [];
        foreach ($relation as $idSet) {
            $objects[] = $this->manager->getReference($className, $idSet);
        }

        return $objects;
    }

Vous pouvez utiliser @Type et @Accessor annotations:

/**
 * @Type("string") 
 * @Accessor(getter="serializeType",setter="setType") 
 */
protected $type;
public function serializeType()
{   
  return $this->type->getId();
}

Alternativement, vous pouvez @inline $country qui va sérialiser ses propriétés dans la relation. Ensuite, vous pouvez @Expose le Pays $id et définir sa @SerializedName à "country". À la différence des propriétés Virtuelles, à la fois de la sérialisation et la désérialisation de travail pour les propriétés.

Pour que cela fonctionne, vous devez utiliser le @ExclusionPolicy("All") sur chaque classe et judicieusement @Expose les propriétés que vous avez besoin dans l'un de vos groupes. C'est plus de sécurité la politique de toute façon.

/**
 * @ExclusionPolicy("All")
 */
class Ad
{ 

    //...


    /**
     * @Type("Acme\SearchBundle\Entity\Country")
     * 
     * @Expose()
     * @Inline()
     * @Groups({"manage"})
     *
     * @var \Acme\SearchBundle\Entity\Country
     */
    private $country;


    //...

}

/**
 * @ExclusionPolicy("All")
 */
class Country
{

    //...

    /**
     * Get id
     *
     * @Expose()
     * @Groups({"manage"})
     * @SerializedName("country")
     * @return string 
     */
    public function getId()
    {
        return $this->id;
    }
}