PHP Serializer\SerializerInterface类代码示例

 public function deserializeData(SerializerInterface $serializer, $getModel)
 {
     foreach ($this->data as $objectArray) {
         $obj = $serializer->deserialize($objectArray, $getModel, 'array');
         $this->objects[] = $obj;
     }
 }

 /**
  * @param $id
  * @return Result
  */
 protected function call($method, $resource, $body = null, $acceptedCodes = array(200))
 {
     try {
         $response = $this->client->request($method, $resource, array('body' => $body));
         $responseBody = (string) $response->getBody();
         if ($responseBody) {
             /** @var Result $result */
             $result = $this->serializer->deserialize($responseBody, $this->getResultClass(), 'json');
             $result->deserializeData($this->serializer, $this->getModel());
         } else {
             $result = new Result();
         }
         $result->setSuccess(in_array($response->getStatusCode(), $acceptedCodes))->setMessage($response->getReasonPhrase());
         return $result;
     } catch (GuzzleException $ge) {
         if ($ge->getCode() == \Symfony\Component\HttpFoundation\Response::HTTP_TOO_MANY_REQUESTS && php_sapi_name() == "cli") {
             sleep(5);
             return $this->call($method, $resource, $body, $acceptedCodes);
         } else {
             $result = new Result();
             $result->setSuccess(false)->setMessage(sprintf("Client error: %s", $ge->getMessage()));
             return $result;
         }
     } catch (\Exception $e) {
         $result = new Result();
         $result->setSuccess(false)->setMessage(sprintf("General error: %s", $e->getMessage()));
         return $result;
     }
 }

 /**
  * @param array $data
  * @param string|null|array $serializationLevel
  * @return Response
  */
 public function createResponse(array $data, $serializationLevel = null)
 {
     $responseData = [static::KEY_STATUS => static::STATUS_SUCCESS, static::KEY_DATA => $data];
     $serializedData = $this->serializer->serialize($responseData, self::STANDARD_RESPONSE_FORMAT, $serializationLevel ? SerializationContext::create()->setGroups($serializationLevel) : SerializationContext::create());
     $response = $this->getJsonResponse($serializedData);
     return $response;
 }

 /**
  * {@inheritdoc}
  */
 public function notifyCallback($callbackUrl, $statusResponse)
 {
     $requestBody = $this->serializer->serialize($statusResponse, 'json');
     $request = new \cURL\Request($callbackUrl);
     $request->getOptions()->set(CURLOPT_FILE, fopen('/dev/null', 'w'))->set(CURLOPT_TIMEOUT, 5)->set(CURLOPT_RETURNTRANSFER, false)->set(CURLOPT_CUSTOMREQUEST, 'POST')->set(CURLOPT_POSTFIELDS, $requestBody)->set(CURLOPT_HTTPHEADER, array('Content-Type: application/json', sprintf('Content-Length: %d', strlen($requestBody))));
     $request->send();
 }

 /**
  * @param $data
  * @param int $status
  * @param array $headers
  * @return \Symfony\Component\HttpFoundation\Response|static
  */
 protected function success($data, $status = 200, $headers = [])
 {
     $serialized_data = $this->serializer->serialize($data, 'json');
     $response = $this->jsonResponse;
     $response->setContent($serialized_data)->setStatusCode($status)->headers->add($headers);
     return $response;
 }

 /**
  * @param string|array $serialized
  * @param int          $format
  *
  * @return GameInterface
  */
 public function deserialize($serialized, $format)
 {
     if ($format === self::FORMAT_ARRAY) {
         $serialized = json_encode($serialized, true);
     }
     return $this->serializer->deserialize($serialized, Game::class, self::FORMAT_JSON, $this->deserializationContext);
 }

 public function testSerializationToJson()
 {
     $subject = new Message('to', 'from', 'subject', 'message');
     $data = $this->serializer->serialize($subject, 'json');
     $object = $this->serializer->deserialize($data, get_class($subject), 'json');
     $this->assertEquals($subject, $object);
 }

 /**
  * @param $track
  * @param $debug
  *
  * @throws RussianPostApiException
  * @throws InvalidTrackException
  *
  * @return OperationHistoryData
  */
 public function getTrackOperationHistory($track, &$debug, $language = "RUS")
 {
     if (!TrackValidator::validateTrack($track)) {
         throw new InvalidTrackException();
     }
     $track = TrackValidator::filterTrack($track);
     $client = $this->initClient();
     $AuthorizationHeader = self::createAuthorizationHeader($this->login, $this->password);
     $historyRequest = self::createOperationHistoryRequest($track, 0, $language);
     $parameters = ["AuthorizationHeader" => $this->serializer->serialize($AuthorizationHeader, 'array'), "historyRequest" => $this->serializer->serialize($historyRequest, 'array')];
     //($operation, $params=array(), $namespace='http://tempuri.org', $soapAction='', $headers=false, $rpcParams=null, $style='rpc', $use='encoded')
     $result = $client->call('GetOperationHistory', $parameters, 'http://russianpost.org/operationhistory');
     $debug = array("Request" => $client->request, "Response" => $client->response, "Debug" => $client->debug_str);
     if ($client->fault) {
         throw new RussianPostApiException(print_r($result, true));
     } else {
         $err = $client->getError();
         if ($err) {
             throw new RussianPostApiException($err);
         } else {
             /** @var OperationHistoryData $object */
             $object = $this->serializer->deserialize($result, 'a3mg\\RussianPostBundle\\Model\\OperationHistoryData', 'array');
             return $object;
         }
     }
 }

 /**
  * {@inheritdoc}
  */
 public function publish(Event $event)
 {
     try {
         $this->client->post(self::PUBLISH_URL, ['body' => $this->serializer->serialize($event, 'json')]);
     } catch (BadResponseException $exception) {
         throw new PublishException($exception->getMessage());
     }
 }

 public function testSerializationToJson()
 {
     $exception = new \Exception('foobar', 100);
     $subject = new ExceptionResponse($exception);
     $data = $this->serializer->serialize($subject, 'json');
     $object = $this->serializer->deserialize($data, ExceptionResponse::class, 'json');
     $this->assertEquals($subject, $object);
 }

 /**
  * Deserialize XML into a BaseResponse
  *
  * @param $xml
  * @return BaseResponse
  * @throws SerializationException
  */
 public function deserialize($xml)
 {
     try {
         return $this->serializer->deserialize($xml, 'SMH\\Enom\\Response\\BaseResponse', 'xml');
     } catch (\RuntimeException $ex) {
         throw new SerializationException($ex->getMessage(), null, $ex);
     }
 }

 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 post($uri, $data = null, array $options = array())
 {
     if (is_array($data)) {
         $options = array_merge($data, $options);
         $data = new \StdClass();
     }
     $this->request('post', $uri, array('body' => $this->serializer->serialize($data, 'json', SerializationContext::create()->setAttribute('options', $options))));
 }

 /**
  * {@inheritdoc}
  */
 public function createCampaignSuppressionImport($campaignId, $source, $location, $data)
 {
     try {
         return $this->client->getCommand('createCampaignSuppressionImport', array('campaignId' => $campaignId, 'suppression_import' => array('source' => $source, 'location' => $location, 'data' => $data)))->execute();
     } catch (ClientErrorResponseException $e) {
         return $this->serializer->deserialize($e->getResponse()->getBody(), 'EBC\\AdvertiserClient\\Campaign\\InvalidImportResponse', 'json');
     }
 }

 /**
  * @param ApiResponse $apiResponse to convert to a Symfony Response.
  * @param Request $request that needs this Response.
  *
  * @return Response
  */
 public function toSymfonyResponse(ApiResponse $apiResponse, Request $request)
 {
     $format = $request->getRequestFormat($this->defaultResponseFormat);
     $serialized = $this->serializer->serialize($apiResponse->getData(), $format);
     $response = new Response($serialized, $apiResponse->getStatusCode(), $apiResponse->getHeaders());
     $response->headers->set('Content-Type', $request->getMimeType($format));
     return $response;
 }