Symfony 2.0 AJAX 애플리케이션에서 Doctrine 엔티티를 JSON으로 인코딩하는 방법은 무엇입니까?

게임 앱을 개발 중이며 Symfony 2.0을 사용하고 있습니다. 백엔드에 많은 AJAX 요청이 있습니다. 그리고 더 많은 응답이 엔티티를 JSON으로 변환하고 있습니다. 예를 들면 :

class DefaultController extends Controller
{           
    public function launchAction()
    {   
        $user = $this->getDoctrine()
                     ->getRepository('UserBundle:User')                
                     ->find($id);

        // encode user to json format
        $userDataAsJson = $this->encodeUserDataToJson($user);
        return array(
            'userDataAsJson' => $userDataAsJson
        );            
    }

    private function encodeUserDataToJson(User $user)
    {
        $userData = array(
            'id' => $user->getId(),
            'profile' => array(
                'nickname' => $user->getProfile()->getNickname()
            )
        );

        $jsonEncoder = new JsonEncoder();        
        return $jsonEncoder->encode($userData, $format = 'json');
    }
}

그리고 모든 컨트롤러는 동일한 작업을 수행합니다. 엔터티를 가져 와서 일부 필드를 JSON으로 인코딩합니다. 노멀 라이저를 사용하고 모든 엔터티를 인코딩 할 수 있다는 것을 알고 있습니다. 그러나 한 엔티티가 다른 엔티티에 대한 링크를 순환했다면 어떻게 될까요? 아니면 엔티티 그래프가 매우 큽니까? 의견 있으십니까?

엔터티에 대한 인코딩 스키마에 대해 생각합니다 ... 또는 NormalizableInterface순환을 피하기 위해 사용 합니다 ..,

또 다른 옵션은 JMSSerializerBundle 을 사용하는 것 입니다. 컨트롤러에서 다음을 수행하십시오.

$serializer = $this->container->get('serializer');
$reports = $serializer->serialize($doctrineobject, 'json');
return new Response($reports); // should be $reports as $doctrineobject is not serialized

엔티티 클래스의 주석을 사용하여 직렬화가 수행되는 방법을 구성 할 수 있습니다. 위 링크의 문서를 참조하십시오. 예를 들어, 연결된 항목을 제외하는 방법은 다음과 같습니다.

 /**
* Iddp\RorBundle\Entity\Report
*
* @ORM\Table()
* @ORM\Entity(repositoryClass="Iddp\RorBundle\Entity\ReportRepository")
* @ExclusionPolicy("None")
*/
....
/**
* @ORM\ManyToOne(targetEntity="Client", inversedBy="reports")
* @ORM\JoinColumn(name="client_id", referencedColumnName="id")
* @Exclude
*/
protected $client;

이제 php5.4로 다음을 수행 할 수 있습니다.

use JsonSerializable;

/**
* @Entity(repositoryClass="App\Entity\User")
* @Table(name="user")
*/
class MyUserEntity implements JsonSerializable
{
    /** @Column(length=50) */
    private $name;

    /** @Column(length=50) */
    private $login;

    public function jsonSerialize()
    {
        return array(
            'name' => $this->name,
            'login'=> $this->login,
        );
    }
}

그리고 전화

json_encode(MyUserEntity);

다음을 사용하여 복잡한 엔터티 인 Json으로 자동으로 인코딩 할 수 있습니다.

use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Serializer\Normalizer\GetSetMethodNormalizer;
use Symfony\Component\Serializer\Encoder\JsonEncoder;

$serializer = new Serializer(array(new GetSetMethodNormalizer()), array('json' => new 
JsonEncoder()));
$json = $serializer->serialize($entity, 'json');

답을 완성하기 위해 : Symfony2는 json_encode를 둘러싼 래퍼와 함께 제공됩니다 : Symfony / Component / HttpFoundation / JsonResponse

컨트롤러의 일반적인 사용 :

...
use Symfony\Component\HttpFoundation\JsonResponse;
...
public function acmeAction() {
...
return new JsonResponse($array);
}

도움이 되었기를 바랍니다

제이

엔티티 직렬화 문제에 대한 해결책은 다음과 같습니다.

#config/config.yml

services:
    serializer.method:
        class: Symfony\Component\Serializer\Normalizer\GetSetMethodNormalizer
    serializer.encoder.json:
        class: Symfony\Component\Serializer\Encoder\JsonEncoder
    serializer:
        class: Symfony\Component\Serializer\Serializer
        arguments:
            - [@serializer.method]
            - {json: @serializer.encoder.json }

내 컨트롤러에서 :

$serializer = $this->get('serializer');

$entity = $this->get('doctrine')
               ->getRepository('myBundle:Entity')
               ->findOneBy($params);


$collection = $this->get('doctrine')
               ->getRepository('myBundle:Entity')
               ->findBy($params);

$toEncode = array(
    'response' => array(
        'entity' => $serializer->normalize($entity),
        'entities' => $serializer->normalize($collection)
    ),
);

return new Response(json_encode($toEncode));

다른 예 :

$serializer = $this->get('serializer');

$collection = $this->get('doctrine')
               ->getRepository('myBundle:Entity')
               ->findBy($params);

$json = $serializer->serialize($collection, 'json');

return new Response($json);

http://api.symfony.com/2.0 에서 배열을 직렬화 해제하도록 구성 할 수도 있습니다.

동일한 문제를 해결해야했습니다. 하나의 엔티티 ( "사용자")가 다른 엔티티 ( "위치")와 일대 다 양방향 연관성을 갖는 json 인코딩입니다.

여러 가지를 시도해 보았는데 이제 가장 적합한 솔루션을 찾은 것 같습니다. 아이디어는 David가 작성한 것과 동일한 코드를 사용하는 것이었지만 노멀 라이저에게 특정 지점에서 중지하도록 지시하여 어떻게 든 무한 재귀를 가로 챌 수 있습니다.

이 GetSetMethodNormalizer는 제 생각에 (반사 등에 기반한) 좋은 접근 방식이므로 사용자 지정 노멀 라이저를 구현하고 싶지 않았습니다. 그래서 속성 (isGetMethod)을 포함할지 여부를 말하는 메서드가 비공개이기 때문에 처음에는 사소하지 않은 하위 클래스로 결정했습니다.

그러나 정규화 메서드를 재정의 할 수 있으므로이 시점에서 "Location"을 참조하는 속성을 설정 해제하여 가로 채었습니다. 따라서 inifinite 루프가 중단됩니다.

코드에서는 다음과 같습니다.

class GetSetMethodNormalizer extends \Symfony\Component\Serializer\Normalizer\GetSetMethodNormalizer {

    public function normalize($object, $format = null)
    {
        // if the object is a User, unset location for normalization, without touching the original object
        if($object instanceof \Leonex\MoveBundle\Entity\User) {
            $object = clone $object;
            $object->setLocations(new \Doctrine\Common\Collections\ArrayCollection());
        }

        return parent::normalize($object, $format);
    }

} 

나는 같은 문제가 있었고 재귀에 스스로 대처할 자체 인코더를 만들기로 결정했습니다.

구현하는 클래스 Symfony\Component\Serializer\Normalizer\NormalizerInterface와 모든 NormalizerInterface.

#This is the NormalizerService

class NormalizerService 
{

   //normalizer are stored in private properties
   private $entityOneNormalizer;
   private $entityTwoNormalizer;

   public function getEntityOneNormalizer()
   {
    //Normalizer are created only if needed
    if ($this->entityOneNormalizer == null)
        $this->entityOneNormalizer = new EntityOneNormalizer($this); //every normalizer keep a reference to this service

    return $this->entityOneNormalizer;
   }

   //create a function for each normalizer



  //the serializer service will also serialize the entities 
  //(i found it easier, but you don't really need it)
   public function serialize($objects, $format)
   {
     $serializer = new Serializer(
            array(
                $this->getEntityOneNormalizer(),
                $this->getEntityTwoNormalizer()
            ),
            array($format => $encoder) );

     return $serializer->serialize($response, $format);
}

노멀 라이저의 예 :

use Symfony\Component\Serializer\Normalizer\NormalizerInterface;

class PlaceNormalizer implements NormalizerInterface {

private $normalizerService;

public function __construct($normalizerService)
{
    $this->service = normalizerService;

}

public function normalize($object, $format = null) {
    $entityTwo = $object->getEntityTwo();
    $entityTwoNormalizer = $this->service->getEntityTwoNormalizer();

    return array(
        'param' => object->getParam(),
        //repeat for every parameter
        //!!!! this is where the entityOneNormalizer dealt with recursivity
        'entityTwo' => $entityTwoNormalizer->normalize($entityTwo, $format.'_without_any_entity_one') //the 'format' parameter is adapted for ignoring entity one - this may be done with different ways (a specific method, etc.)
    );
}

}

컨트롤러에서 :

$normalizerService = $this->get('normalizer.service'); //you will have to configure services.yml
$json = $normalizerService->serialize($myobject, 'json');
return new Response($json);

완전한 코드는 여기에 있습니다 : https://github.com/progracqteur/WikiPedale/tree/master/src/Progracqteur/WikipedaleBundle/Resources/Normalizer

Symfony 2.3에서

/app/config/config.yml

framework:
    # сервис конвертирования объектов в массивы, json, xml и обратно
    serializer:
        enabled: true

services:
    object_normalizer:
        class: Symfony\Component\Serializer\Normalizer\GetSetMethodNormalizer
        tags:
        # помечаем к чему относится этот сервис, это оч. важно, т.к. иначе работать не будет
          - { name: serializer.normalizer }

컨트롤러의 예 :

/**
 * Поиск сущности по ИД объекта и ИД языка
 * @Route("/search/", name="orgunitSearch")
 */
public function orgunitSearchAction()
{
    $array = $this->get('request')->query->all();

    $entity = $this->getDoctrine()
        ->getRepository('IntranetOrgunitBundle:Orgunit')
        ->findOneBy($array);

    $serializer = $this->get('serializer');
    //$json = $serializer->serialize($entity, 'json');
    $array = $serializer->normalize($entity);

    return new JsonResponse( $array );
}

그러나 필드 유형 \ DateTime의 문제는 남아 있습니다.

이것은 업데이트 (Symfony v : 2.7+ 및 JmsSerializer v : 0.13. * @ dev의 경우) 에 가깝기 때문에 Jms가 전체 객체 그래프를로드하고 직렬화하지 않도록 방지합니다 (또는 순환 관계의 경우 ..).

모델:

use Doctrine\ORM\Mapping as ORM;
use JMS\Serializer\Annotation\ExclusionPolicy;  
use JMS\Serializer\Annotation\Exclude;  
use JMS\Serializer\Annotation\MaxDepth; /* <=== Required */
/**
 * User
 *
 * @ORM\Table(name="user_table")
///////////////// OTHER Doctrine proprieties //////////////
 */
 public class User
{
    /**
     * @var integer
     *
     * @ORM\Column(name="id", type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected   $id;

    /**
     * @ORM\ManyToOne(targetEntity="FooBundle\Entity\Game")
     * @ORM\JoinColumn(nullable=false)
     * @MaxDepth(1)
     */
    protected $game;
   /*
      Other proprieties ....and Getters ans setters
      ......................
      ......................
   */

액션 내부 :

use JMS\Serializer\SerializationContext;
  /* Necessary include to enbale max depth */

  $users = $this
              ->getDoctrine()
              ->getManager()
              ->getRepository("FooBundle:User")
              ->findAll();

  $serializer = $this->container->get('jms_serializer');
  $jsonContent = $serializer
                   ->serialize(
                        $users, 
                        'json', 
                        SerializationContext::create()
                                 ->enableMaxDepthChecks()
                  );

  return new Response($jsonContent);

Symfony 2.7 이상을 사용 하고 있고 직렬화를위한 추가 번들을 포함하지 않으려는 경우이 방법을 따라 교리 엔티티를 json으로 seialize 할 수 있습니다.

1. 내 (공통, 부모) 컨트롤러에는 직렬 변환기를 준비하는 기능이 있습니다.

   use Symfony\Component\Serializer\Encoder\JsonEncoder;
   use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
   use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;
   use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
   use Symfony\Component\Serializer\Serializer;
   
   // -----------------------------
   
   /**
    * @return Serializer
    */
   protected function _getSerializer()
   {  
       $classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
       $normalizer           = new ObjectNormalizer($classMetadataFactory);
   
       return new Serializer([$normalizer], [new JsonEncoder()]);
   }
   

2. 그런 다음이를 사용하여 엔터티를 JSON으로 직렬화합니다.

   $this->_getSerializer()->normalize($anEntity, 'json');
   $this->_getSerializer()->normalize($arrayOfEntities, 'json');
   

끝난!

그러나 미세 조정이 필요할 수 있습니다. 예를 들면-

• 엔티티에 순환 참조가있는 경우 처리 방법을 확인하십시오 .
• 일부 속성을 무시하려면 할 수 있습니다.
• 더 좋은 점은 선택적 속성 만 직렬화 할 수 있다는 것 입니다.

Symfony에서 많은 REST API 엔드 포인트를 생성해야하는 경우 가장 좋은 방법은 다음 번들 스택을 사용하는 것입니다.

1. Doctrine 엔티티의 직렬화를위한 JMSSerializerBundle
2. 응답보기 리스너를위한 FOSRestBundle 번들. 또한 컨트롤러 / 액션 이름을 기반으로 경로 정의를 생성 할 수 있습니다.
3. NelmioApiDocBundle 은 온라인 문서 및 Sandbox (외부 도구없이 엔드 포인트를 테스트 할 수 있음) 를 자동 생성합니다.

모든 것을 올바르게 구성하면 엔티티 코드는 다음과 같습니다.

use Doctrine\ORM\Mapping as ORM;
use JMS\Serializer\Annotation as JMS;

/**
 * @ORM\Table(name="company")
 */
class Company
{

    /**
     * @var string
     *
     * @ORM\Column(name="name", type="string", length=255)
     *
     * @JMS\Expose()
     * @JMS\SerializedName("name")
     * @JMS\Groups({"company_overview"})
     */
    private $name;

    /**
     * @var Campaign[]
     *
     * @ORM\OneToMany(targetEntity="Campaign", mappedBy="company")
     * 
     * @JMS\Expose()
     * @JMS\SerializedName("campaigns")
     * @JMS\Groups({"campaign_overview"})
     */
    private $campaigns;
}

그런 다음 컨트롤러에서 코드를 작성합니다.

use Nelmio\ApiDocBundle\Annotation\ApiDoc;
use FOS\RestBundle\Controller\Annotations\View;

class CompanyController extends Controller
{

    /**
     * Retrieve all companies
     *
     * @View(serializerGroups={"company_overview"})
     * @ApiDoc()
     *
     * @return Company[]
     */
    public function cgetAction()
    {
        return $this->getDoctrine()->getRepository(Company::class)->findAll();
    }
}

이러한 설정의 이점은 다음과 같습니다.

• 엔티티의 @JMS \ Expose () 주석은 단순 필드 및 모든 유형의 관계에 추가 할 수 있습니다. 또한 일부 메서드 실행의 결과를 노출 할 가능성이 있습니다 (이에 대해서는 @JMS \ VirtualProperty () 주석 사용).
• 직렬화 그룹을 사용하면 다양한 상황에서 노출 된 필드를 제어 할 수 있습니다.
• 컨트롤러는 매우 간단합니다. 액션 메서드는 엔티티 또는 엔티티 배열을 직접 반환 할 수 있으며 자동으로 직렬화됩니다.
• 그리고 @ApiDoc ()을 사용하면 REST 클라이언트 또는 JavaScript 코드없이 브라우저에서 직접 엔드 포인트를 테스트 할 수 있습니다.

이제 Doctrine ORM Transformations 를 사용 하여 엔티티를 스칼라의 중첩 배열로 변환하고 다시