PHP SerializerBuilder::build方法代码示例

 public function build()
 {
     $this->setObjectManager($this->createEntityManager());
     $this->serializerBuilder = BreezeSerializerBuilder::create($this->getObjectManager());
     $this->validatorBuilder = new ValidatorBuilder();
     if ($this->annotationsEnabled) {
         $this->validatorBuilder->enableAnnotationMapping();
     }
     foreach ($this->mappings as $mapping) {
         if (isset($mapping['serializer'])) {
             $this->serializerBuilder->addMetadataDir($mapping['serializer']);
         }
         if (isset($mapping['validation'])) {
             if ($mapping['type'] == 'xml') {
                 $this->validatorBuilder->addXmlMapping($mapping['validation']);
             } else {
                 if ($mapping['type'] == 'yaml') {
                     $this->validatorBuilder->addYamlMapping($mapping['validation']);
                 }
             }
             //                else if ($mapping['type'] == 'annotation') {
             //                    $this->validatorBuilder->enableAnnotationMapping();
             //                }
         }
     }
     $serializer = $this->serializerBuilder->build();
     $this->setSerializer($serializer);
     $validator = $this->validatorBuilder->getValidator();
     $this->setValidator($validator);
 }

 /**
  * Usado para fazer um lazy load do serializer.
  * Ele vai pegar a configuração prévia do builder e criar um
  * serializer novo com elas.
  *
  * @return Serializer
  */
 protected function getSerializer()
 {
     if (null === $this->serializer) {
         $this->serializer = $this->serializerBuilder->build();
     }
     return $this->serializer;
 }

 /**
  * Build a configured Hateoas instance.
  *
  * @return Hateoas
  */
 public function build()
 {
     $metadataFactory = $this->buildMetadataFactory();
     $relationProvider = new RelationProvider($metadataFactory, $this->chainResolver);
     $relationsRepository = new RelationsRepository($metadataFactory, $relationProvider);
     $expressionEvaluator = new ExpressionEvaluator($this->getExpressionLanguage());
     $linkFactory = new LinkFactory($expressionEvaluator, $this->urlGeneratorRegistry);
     $exclusionManager = new ExclusionManager($expressionEvaluator);
     $linksFactory = new LinksFactory($relationsRepository, $linkFactory, $exclusionManager);
     $embeddedMapFactory = new EmbedsFactory($relationsRepository, $expressionEvaluator, $exclusionManager);
     $linkHelper = new LinkHelper($linkFactory, $relationsRepository);
     // Register Hateoas core functions
     $expressionEvaluator->registerFunction(new LinkExpressionFunction($linkHelper));
     if (null === $this->xmlSerializer) {
         $this->setDefaultXmlSerializer();
     }
     if (null === $this->jsonSerializer) {
         $this->setDefaultJsonSerializer();
     }
     $inlineDeferrers = array();
     $eventSubscribers = array(new XmlEventSubscriber($this->xmlSerializer, $linksFactory, $embeddedMapFactory), new JsonEventSubscriber($this->jsonSerializer, $linksFactory, $embeddedMapFactory, $inlineDeferrers[] = new InlineDeferrer(), $inlineDeferrers[] = new InlineDeferrer()));
     $this->serializerBuilder->addDefaultListeners()->configureListeners(function (EventDispatcherInterface $dispatcher) use($eventSubscribers) {
         foreach ($eventSubscribers as $eventSubscriber) {
             $dispatcher->addSubscriber($eventSubscriber);
         }
     });
     $jmsSerializer = $this->serializerBuilder->build();
     foreach (array_merge($inlineDeferrers, array($this->jsonSerializer, $this->xmlSerializer)) as $serializer) {
         if ($serializer instanceof JMSSerializerMetadataAwareInterface) {
             $serializer->setMetadataFactory($jmsSerializer->getMetadataFactory());
         }
     }
     return new Hateoas($jmsSerializer, $linkHelper);
 }

 /**
  * @param array $config
  * @param bool  $debug
  *
  * @return Serializer
  */
 protected function createSerializer(array $config, $debug)
 {
     $builder = new SerializerBuilder();
     if (isset($config['cache_dir'])) {
         $builder->setCacheDir($config['cache_dir']);
     }
     if (isset($config['default_handlers'])) {
         $builder->addDefaultHandlers();
     }
     if (isset($config['handlers'])) {
         foreach ($config['handlers'] as $handler) {
             $builder->configureHandlers($handler);
         }
     }
     if (isset($config['event_listeners'])) {
         foreach ($config['event_listeners'] as $handler) {
             $builder->configureListeners($handler);
         }
     }
     $builder->addMetadataDirs(array_get($config, 'paths', [base_path('app')]));
     $builder->setDebug($debug);
     return $builder->build();
 }

 /**
  * @param LoggerInterface $logger
  *
  * @return SerializerInterface
  */
 public function build(LoggerInterface $logger)
 {
     $serializerBuilder = new SerializerBuilder();
     return new Serializer($serializerBuilder->build(), new GroupsSpecifier($logger), $logger);
 }

 private function getIncludeInterfaces(SerializerBuilder $builder)
 {
     $factory = $this->getField($builder->build(), 'factory');
     return $this->getField($factory, 'includeInterfaces');
 }

 /**
  * @expectedException RuntimeException
  */
 public function testDoesNotAddOtherVisitorsWhenConfiguredExplicitly()
 {
     $this->assertSame($this->builder, $this->builder->setSerializationVisitor('json', new JsonSerializationVisitor(new CamelCaseNamingStrategy())));
     $this->builder->build()->serialize('foo', 'xml');
 }

 /**
  * Return JMS serializer
  *
  * @return \JMS\Serializer\Serializer
  */
 protected function getSerializer()
 {
     $serializerBuilder = new SerializerBuilder();
     return $serializerBuilder->build();
 }