使用JMS序列化器将实体关系仅序列化到Id

是的，您可以使用@VirtualProperty注释:

/**
 * @VirtualProperty
 * @SerializedName("foo")
 */
public function bar()
{
    return $this->country->getCode();
}

但是当涉及到反序列化时要注意:

@VirtualProperty这个注释可以定义在一个方法上指示该方法返回的数据应该显示为属性。

>注意:这只适用于序列化，完全被忽略在反序列化。

只是遵循已回答的问题:

如果你不喜欢为每个关系都写一个方法——那就写你自己的处理程序吧。很简单，就像

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;
    }
}

注册处理程序

  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}

这允许你用' Type("Relation")代替虚getter方法。

如果你也不想反序列化关系-你应该告诉每个@Type("Relation")的类名(@Type("Relation<FQCN>"))，它应该反序列化或包装元数据驱动与一个为你做的。

    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;
    }

我知道这个问题已经有了答案，但是您也可以使用@Accessor。这可能(可能，我不能确定)也适用于反序列化。

/**
 * @Type("Acme'SearchBundle'Entity'Country")
 * @Groups({"manage"})
 * 
 * @var 'Acme'SearchBundle'Entity'Country
 *
 * @Serializer'Accessor(getter="getCountryMinusId",setter="setCountryWithId")
 */
private $country;
/**
 * @return string|null
 */
public function getCountryMinusId()
{
    if (is_array($this->country) && isset($this->country['id'])) {
        return $this->country['id'];
    }
    return null;
}
/**
 * @param string $country
 * @return $this
 */
public function setCountryWithId($country)
{
    if (!is_array($this->country)) {
        $this->country = array();
    )
    $this->country['id'] = $country;
    return $this;
}

您可以使用@Type和@Accessor注释:

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

作者希望保留属性名，这不适用于接受的答案。据我所知，ScayTrase的答案将保留原始属性名称，但根据评论有另一个缺点:如果您使用Doctrine ORM @ManyToOne，则将获取相关对象，从而降低性能。

如果你想保持原来的属性名，你必须在类级别定义@VirtualProperty和@Exclude原来的属性。否则，序列化的属性名将从getter方法(在本例中为countryId)派生:

/**
 * @Serializer'VirtualProperty(
 *     "country",
 *     exp="object.getCountryId()",
 *     options={@Serializer'SerializedName("country")}
 * )
 */
class Ad {
    /**
     * @Serializer'Exclude
     */
    private $country;
    public function getCountryId() {
        return $this->country === null ? null : $this->country->getId();
    }
}

或者，您可以将@inline $country将其属性序列化到父关系中。然后将国家$id设置为@Expose，并将其@SerializedName设置为"country"。与Virtual属性不同，的序列化和反序列化都适用于内联属性。

要做到这一点，您需要在每个类上使用@ExclusionPolicy("All")，并明智地将您在任何组中需要的属性@Expose。这是一个更安全的策略。

/**
 * @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;
    }
}