PHP SerializationContext::setSerializeNull方法代码示例

 /**
  * @param Serializer $serializer
  * @param SqsClient  $sqsClient
  */
 public function __construct(Serializer $serializer, SqsClient $sqsClient)
 {
     $this->serializer = $serializer;
     $this->sqsClient = $sqsClient;
     $this->serializationContext = new SerializationContext();
     $this->serializationContext->setSerializeNull(true);
 }

 /**
  * @param SerializerInterface $serializer
  */
 public function __construct(SerializerInterface $serializer = null)
 {
     $this->serializer = $serializer ?: SerializerBuilder::create()->build();
     $this->serializationContext = new SerializationContext();
     $this->serializationContext->setSerializeNull(true);
     $this->deserializationContext = new DeserializationContext();
     $this->deserializationContext->setSerializeNull(true);
 }

 /**
  * @param GetResponseForControllerResultEvent $event
  */
 public function serializeResponse(GetResponseForControllerResultEvent $event)
 {
     if ($this->doSerialize) {
         $data = $event->getControllerResult();
         $apiResponse = new ApiResponse(200, $data);
         $data = array_merge($apiResponse->toArray(), $this->data->all());
         $data = array_filter($data);
         if (!isset($data['data'])) {
             $data['data'] = [];
         }
         $context = new SerializationContext();
         $context->setSerializeNull(true);
         if (method_exists($context, 'enableMaxDepthChecks')) {
             $context->enableMaxDepthChecks();
         }
         if ($action = $this->getAction($event)) {
             $context->setGroups($action->getSerializationGroups());
         }
         if ($fields = $event->getRequest()->query->get('fields')) {
             $context->addExclusionStrategy(new FieldsListExclusionStrategy($fields));
         }
         $json = $this->serializer->serialize($data, 'json', $context);
         $response = new Response($json, 200, ['Content-Type' => 'application/json']);
         $event->setResponse($response);
         $event->stopPropagation();
     }
 }

 /**
  * Render the view into a string and return for output
  *
  * @param mixed $input
  * @return string
  * @throws \Exception
  */
 public function render($input = null)
 {
     $context = new SerializationContext();
     $context->setSerializeNull(true);
     $context->enableMaxDepthChecks();
     FrontController::getInstance()->getResponse()->headers->set('Content-Type', 'application/json');
     return $this->serializer->serialize($input, $this->format, $context);
 }

 protected function serializeObject($object)
 {
     $serializer = SerializerBuilder::create()->build();
     $serializationContext = new SerializationContext();
     $serializationContext->setSerializeNull(true);
     $objectJson = $serializer->serialize($object, 'json', $serializationContext);
     return json_decode($objectJson);
 }

 protected function jsonResponse($data)
 {
     $context = new SerializationContext();
     $context->setSerializeNull(true);
     $content = $this->serializer->serialize($data, 'json', $context);
     $this->response->setContent($content);
     return $this->response;
 }

 /**
  * {@inheritdoc}
  */
 public function setData($data = array())
 {
     $this->originalData = $data;
     $context = new SerializationContext();
     $context->setSerializeNull(true);
     $serializer = SerializerBuilder::create()->build();
     $this->data = $serializer->serialize($data, 'json', $context);
     return $this->update();
 }

 /**
  * Create a new serialization context
  *
  * @param array $groups [optional]
  * @return SerializationContext
  */
 protected function createNewContext(array $groups = null)
 {
     $context = new SerializationContext();
     $context->setSerializeNull($this->serializeNull);
     if (null !== $groups) {
         $context->setGroups($groups);
     }
     return $context;
 }

 public function testToArrayUseProvidedSerializationContext()
 {
     $contextFactoryMock = $this->getMockForAbstractClass('JMS\\Serializer\\ContextFactory\\SerializationContextFactoryInterface');
     $context = new SerializationContext();
     $context->setSerializeNull(true);
     $contextFactoryMock->expects($this->once())->method('createSerializationContext')->will($this->returnValue($context));
     $this->serializer->setDefaultSerializationContextFactory($contextFactoryMock);
     $result = $this->serializer->toArray(array('value' => null));
     $this->assertEquals(array('value' => null), $result);
 }

 public function getmailAction()
 {
     try {
         $jsonData = $this->getRequest()->getContent();
         $data = $this->serializer->deserialize($jsonData, "Application\\API\\Canonicals\\Dto\\ThirdPartyEmailTransport", "json");
         $emailRepo = $this->getServiceLocator()->get('EMailSvc');
         $emails = $emailRepo->fetchMail($data->mailapikey);
         $context = new SerializationContext();
         $context->setSerializeNull(true);
         $content = $this->serializer->serialize($emails, 'json', $context);
         $this->response->setContent($content);
         return $this->response;
     } catch (\Exception $ex) {
         error_log($ex->getMessage());
     }
     exit;
 }

 public function processForm(WebsiteOptions $options, array $parameters, $method = 'PUT')
 {
     $form = $this->formFactory->create(new WebsiteOptionsType(), $options, array('method' => $method));
     $form->submit($parameters, 'PATCH' !== $method);
     if ($form->isValid()) {
         $options = $form->getData();
         $this->om->persist($options);
         $this->om->flush();
         $serializationContext = new SerializationContext();
         $serializationContext->setSerializeNull(true);
         return json_decode($this->serializer->serialize($options, 'json', $serializationContext));
     }
     /*else {
           return $this->getErrorMessages($form);
       }*/
     throw new \InvalidArgumentException();
 }

 public function testAbc()
 {
     $client = new Entity\Client();
     $location = new Entity\Location();
     $orders = new Collections\ArrayCollection();
     $orders->add(new Entity\Order('Order 001'));
     $orders->add(new Entity\Order('Order 002'));
     $orders->add(new Entity\Order('Order 003'));
     $session = new Entity\Session('981be8ae41ba4a148f20a04508ab1ab');
     $request = new Request\SaveOrder($session, $orders);
     $context = new SerializationContext();
     $context->setSerializeNull(true);
     $serializer = SerializerBuilder::create()->build();
     // serialize
     $xml = $serializer->serialize($request, 'xml', $context);
     //var_dump($xml);
     // deserialize
     $object = $serializer->deserialize($xml, Request\SaveOrder::class, 'xml');
     var_dump($object);
 }

 public function cgetAction(Request $request)
 {
     $adminCode = $request->get('_sonata_admin');
     if (!$adminCode) {
         throw new \RuntimeException(sprintf('There is no `_sonata_admin` defined for the controller `%s` and the current route `%s`', get_class($this), $request->get('_route')));
     }
     $admin = $this->get('sonata.admin.pool')->getAdminByAdminCode($adminCode);
     if (false === $admin->isGranted('LIST')) {
         throw new AccessDeniedException();
     }
     /** @var MenuItemRepository $menuRepository */
     $menuRepository = $this->get('doctrine.orm.entity_manager')->getRepository('GravityMenuBundle:MenuItem');
     $menus = $menuRepository->findBy(['parent' => null], null, 20, 0);
     $view = new View($menus);
     $context = new SerializationContext();
     $context->setSerializeNull(true);
     $context->setGroups(['gravity_api_read']);
     $view->setSerializationContext($context);
     return $this->get('fos_rest.view_handler')->handle($view);
 }

 /**
  * @param PaginationInterface $pagination
  * @param Request             $request
  * @param Router              $router
  * @param array               $serializationGroups
  *
  * @return mixed
  */
 public function buildMultiObjectResponse(PaginationInterface $pagination, Request $request, Router $router, array $serializationGroups = array())
 {
     if (empty($pagination->getItems())) {
         return $this->handle(View::create(null, Response::HTTP_NO_CONTENT));
     }
     $paginationData = $pagination->getPaginationData();
     $link = $this->buildPaginationLink($paginationData, $request, $router);
     $headers = [];
     if (!empty($link)) {
         $headers['Link'] = $link;
     }
     if (isset($paginationData['totalCount'])) {
         $headers['X-Total-Count'] = $paginationData['totalCount'];
     }
     $view = View::create($pagination->getItems(), Response::HTTP_OK, $headers);
     $context = new SerializationContext();
     $context->setSerializeNull(true);
     if (!empty($serializationGroups)) {
         $context->setGroups($serializationGroups);
     }
     $view->setSerializationContext($context);
     return $this->handle($view);
 }

 /**
  * Create serialization context with settings taken from the controller's annotation
  *
  * @param MappingInterface $mapping
  * @return SerializationContext
  */
 protected function createSerializationContext(MappingInterface $mapping)
 {
     $context = new SerializationContext();
     if ($mapping->getAnnotation()->getSerializerEnableMaxDepthChecks()) {
         $context->enableMaxDepthChecks();
     }
     if ($mapping->getAnnotation()->getSerializerGroups()) {
         $context->setGroups($mapping->getAnnotation()->getSerializerGroups());
     }
     if ($mapping->getAnnotation()->getSerializerSerializeNull()) {
         $context->setSerializeNull(true);
     }
     return $context;
 }