Doctrine2 export entité vers tableau

J'ai Product entité à plusieurs-à-un à Category entité. J'ai besoin de stocker Product dans la session. Tout d'abord, je cherche à mettre en œuvre \Serializable de l'interface du Produit. Comment dois-je sérialiser mes Category entité? Dois-je également mettre en œuvre \Serializable interface?

J'ai lu, que la sérialisation dans la doctrine est très mal opération et je pense à ce sujet:

Pouvons-nous obtenir les valeurs brutes de l'entité? Exactement ce que les données, stockées dans la base de données. Si on peut obtenir ces valeurs, on peut stocker n'importe où et de recréer l'objet!

J'ai lu doctrine2 code et de trouver la méthode Doctrine\ORM\Internal\Hydration\ObjectHydrator:hydrateRowData mais il est protégé. Est-il une api publique pour faire cela?

Mise à jour:

Je viens de copypaste et d'intégrer du code de BasicEntityPersister et il semble fonctionner.

    $product = $productsRepository->find($id);
if (!$product) {
throw $this->createNotFoundException('No product found for id ' . $id);
}
$uow = $em->getUnitOfWork();
$entityPersister = $uow->getEntityPersister(get_class($product));
$classMetadata = $entityPersister->getClassMetadata();
$originalData = $uow->getOriginalEntityData($product);
$result = array();
foreach ($originalData as $field => $value) {
if (isset($classMetadata->associationMappings[$field])) {
$assoc = $classMetadata->associationMappings[$field];
//Only owning side of x-1 associations can have a FK column.
if ( ! $assoc['isOwningSide'] || ! ($assoc['type'] & \Doctrine\ORM\Mapping\ClassMetadata::TO_ONE)) {
continue;
}
if ($value !== null) {
$newValId = $uow->getEntityIdentifier($value);
}
$targetClass = $em->getClassMetadata($assoc['targetEntity']);
$owningTable = $entityPersister->getOwningTable($field);
foreach ($assoc['joinColumns'] as $joinColumn) {
$sourceColumn = $joinColumn['name'];
$targetColumn = $joinColumn['referencedColumnName'];
if ($value === null) {
$result[$owningTable][$sourceColumn] = null;
} else if ($targetClass->containsForeignIdentifier) {
$result[$owningTable][$sourceColumn] = $newValId[$targetClass->getFieldForColumn($targetColumn)];
} else {
$result[$owningTable][$sourceColumn] = $newValId[$targetClass->fieldNames[$targetColumn]];
}
}
} elseif (isset($classMetadata->columnNames[$field])) {
$columnName = $classMetadata->columnNames[$field];
$result[$entityPersister->getOwningTable($field)][$columnName] = $value;
}
}
print_r($result);

Dans $result nous avons des valeurs brutes. Maintenant nous avons besoin d'une façon de créer un objet par ce tableau

source d'informationauteur striker

  1. 7
    <?php
namespace Acme\ServiceBundle\Services;
use Doctrine\ORM\EntityManager;
class EntitySerializer
{
protected $em;
public function __construct(EntityManager $em)
{
$this->em = $em;
}
public function serialize($entity)
{
$className = get_class($entity);
$uow = $this->em->getUnitOfWork();
$entityPersister = $uow->getEntityPersister($className);
$classMetadata = $entityPersister->getClassMetadata();
$result = array();
foreach ($uow->getOriginalEntityData($entity) as $field => $value) {
if (isset($classMetadata->associationMappings[$field])) {
$assoc = $classMetadata->associationMappings[$field];
//Only owning side of x-1 associations can have a FK column.
if ( ! $assoc['isOwningSide'] || ! ($assoc['type'] & \Doctrine\ORM\Mapping\ClassMetadata::TO_ONE)) {
continue;
}
if ($value !== null) {
$newValId = $uow->getEntityIdentifier($value);
}
$targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
$owningTable = $entityPersister->getOwningTable($field);
foreach ($assoc['joinColumns'] as $joinColumn) {
$sourceColumn = $joinColumn['name'];
$targetColumn = $joinColumn['referencedColumnName'];
if ($value === null) {
$result[$sourceColumn] = null;
} else if ($targetClass->containsForeignIdentifier) {
$result[$sourceColumn] = $newValId[$targetClass->getFieldForColumn($targetColumn)];
} else {
$result[$sourceColumn] = $newValId[$targetClass->fieldNames[$targetColumn]];
}
}
} elseif (isset($classMetadata->columnNames[$field])) {
$columnName = $classMetadata->columnNames[$field];
$result[$columnName] = $value;
}
}
return array($className, $result);
}
public function deserialize(Array $data)
{
list($class, $result) = $data;
$uow = $this->em->getUnitOfWork();
return $uow->createEntity($class, $result);
}
}
  2. 6

    J'ai eu le même problème, je voulais aussi avoir pour associés les données de la matrice. Donc, je suis venu avec les éléments suivants:

    $serializer = new Serializer($this->em); //Pass the EntityManager object
$array = $serializer->serialize($message); //Returns the array (with associations!)

    Source:

    <?php
/**
* Class Serializer
*
* @author Steffen Brem
*/
class Serializer
{
/**
* @var Doctrine\ORM\EntityManager
*/
private $_em;
/**
* Constructor
*
* @param \Doctrine\ORM\EntityManager $em
*/
public function __construct(\Doctrine\ORM\EntityManager $em)
{
$this->_em = $em;
}
/**
* Serialize entity to array
*
* @param $entityObject
* @return array
*/
public function serialize($entityObject)
{
$data = array();
$className = get_class($entityObject);
$metaData = $this->_em->getClassMetadata($className);
foreach ($metaData->fieldMappings as $field => $mapping)
{
$method = "get" . ucfirst($field);
$data[$field] = call_user_func(array($entityObject, $method));
}
foreach ($metaData->associationMappings as $field => $mapping)
{
//Sort of entity object
$object = $metaData->reflFields[$field]->getValue($entityObject);
$data[$field] = $this->serialize($object);
}
return $data;
}
}