PHP Definition::setProperty方法代码示例

 private function getAllParameters()
 {
     $service = new Definition();
     $service->setClass('stdClass');
     $service->setAbstract(true);
     $service->setFactoryClass('stdClass');
     $service->setFactoryMethod('get');
     $service->setFactoryService('service.fact');
     $service->setFile('/file.php');
     $service->setLazy(true);
     $service->addMethodCall('methodCall1');
     $service->addMethodCall('methodCall2', array('arg1', 'arg2'));
     $service->addMethodCall('methodCall3', array(new Reference('arg.one')));
     $service->setProperty('prop1', 'val1');
     $service->setProperty('prop2', new Reference('prop.one'));
     $service->setPublic(false);
     $service->setScope('request');
     $service->setSynchronized(true);
     $service->setSynthetic(true);
     return new ServiceElement('service.two', $service);
 }

 private function convertObjectDefinition(ContainerBuilder $container, ObjectDefinitionInterface $definition)
 {
     $symfonyDefinition = new Definition();
     $symfonyDefinition->setClass($definition->getClassName());
     $symfonyDefinition->setArguments($this->convertArguments($container, $definition->getConstructorArguments()));
     foreach ($definition->getPropertyAssignments() as $propertyAssignment) {
         $symfonyDefinition->setProperty($propertyAssignment->getPropertyName(), $this->convertArguments($container, $propertyAssignment->getValue()));
     }
     foreach ($definition->getMethodCalls() as $methodCall) {
         $symfonyDefinition->addMethodCall($methodCall->getMethodName(), $this->convertArguments($container, $methodCall->getArguments()));
     }
     return $symfonyDefinition;
 }

 /**
  * @param ContainerBuilder $container
  * @param $config
  */
 protected function configureReader(ContainerBuilder $container, $config)
 {
     $container->setParameter('evlz_php_exif.type', $config['type']);
     foreach (array('native', 'exiftool') as $reader) {
         if ($container->hasParameter('evlz_php_exif.reader.' . $reader . '.class')) {
             $class = $container->getParameter('evlz_php_exif.reader.' . $reader . '.class');
             $definition = new Definition($class);
             $definition->setProperty('private', true);
             $container->setDefinition('evlz_php_exif.reader.' . $reader, $definition);
         }
     }
     $container->setAlias('evlz_php_exif.reader.default', 'evlz_php_exif.reader.' . $container->getParameter('evlz_php_exif.type'));
 }

 /**
  * {@inheritDoc}
  */
 public function load(array $configs, ContainerBuilder $container)
 {
     $this->container = $container;
     $configuration = new Configuration();
     $this->config = $this->processConfiguration($configuration, $configs);
     $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
     $loader->load('services.yml');
     // create pipeline definition and store it into a PipelineProvider
     $pipeline = (new PipelineFactory())->buildPipeline($this->config);
     $pipelineProviderDefinition = new Definition('Wizbii\\PipelineBundle\\Service\\PipelineProvider', [$this->config]);
     $container->setDefinition("pipeline.provider", $pipelineProviderDefinition);
     // Load Connection
     $this->loadConnection();
     // create global producer
     $internalProducerDefinition = new Definition("%pipeline.producer.class%");
     $pipelineExchangeName = $pipeline->getName();
     $internalProducerDefinition->addTag('old_sound_rabbit_mq.base_amqp')->addTag('old_sound_rabbit_mq.producer')->addMethodCall('setExchangeOptions', [["name" => $pipelineExchangeName, "type" => "direct", "passive" => false, "durable" => true]])->addMethodCall('setQueueOptions', [["name" => null]])->addArgument(new Reference('old_sound_rabbit_mq.connection.default'))->setProperty("logger", new Reference("monolog.logger.pipeline"));
     $internalProducerId = 'old_sound_rabbit_mq.internal_pipeline_producer';
     $this->container->setDefinition($internalProducerId, $internalProducerDefinition);
     // create event consumers for each incoming event
     foreach ($pipeline->getIncomingEvents() as $event) {
         $frontConsumerDefinition = new Definition("%pipeline.consumer.front.class%");
         $frontConsumerDefinition->setProperty("eventName", $event->getName())->setProperty("producer", new Reference($internalProducerId))->setPublic(false);
         $frontConsumerId = sprintf('pipeline.consumer.front.%s_consumer', $event->getName());
         $this->container->setDefinition($frontConsumerId, $frontConsumerDefinition);
         $amqpConsumer = new Definition('%pipeline.consumer.command.class%');
         $amqpConsumer->addTag('old_sound_rabbit_mq.base_amqp')->addTag('old_sound_rabbit_mq.consumer')->addTag('pipeline.front.consumer')->addMethodCall('setExchangeOptions', [["name" => $event->getName(), "type" => "direct"]])->addMethodCall('setQueueOptions', [["name" => $event->getName()]])->addMethodCall('setCallback', [[new Reference($frontConsumerId), "execute"]])->addArgument(new Reference('old_sound_rabbit_mq.connection.default'));
         $name = sprintf('old_sound_rabbit_mq.%s_consumer', $event->getName());
         $this->container->setDefinition($name, $amqpConsumer);
     }
     // create event producers for each outgoing event
     foreach ($pipeline->getOutgoingEvents() as $event) {
         $producerDefinition = new Definition("%pipeline.producer.class%");
         $producerDefinition->setProperty("logger", new Reference("monolog.logger.pipeline"))->addTag('old_sound_rabbit_mq.producer')->addTag('pipeline.back.producer')->addMethodCall('setExchangeOptions', [["name" => $event->getName(), "type" => "direct", "passive" => false, "durable" => true]])->addMethodCall('setQueueOptions', [["name" => null]])->addArgument(new Reference('old_sound_rabbit_mq.connection.default'));
         $producerId = sprintf('pipeline.producer.%s', $event->getName());
         $this->container->setDefinition($producerId, $producerDefinition);
     }
     // create backend consumer
     $pipelineQueueName = $pipeline->getName();
     $backConsumer = new Definition('%old_sound_rabbit_mq.consumer.class%');
     $backConsumer->addTag('old_sound_rabbit_mq.base_amqp')->addTag('old_sound_rabbit_mq.consumer')->addMethodCall('setExchangeOptions', [["name" => $pipelineExchangeName, "type" => "direct"]])->addMethodCall('setQueueOptions', [["name" => $pipelineQueueName]])->addMethodCall('setCallback', [[new Reference("pipeline.consumer.back"), "execute"]])->addArgument(new Reference('old_sound_rabbit_mq.connection.default'));
     $this->container->setDefinition("old_sound_rabbit_mq.pipeline_back_consumer", $backConsumer);
 }

//.........这里部分代码省略.........
         $container->setDefinition($parent, $parentDef);
         $this->currentId = $id;
     }
     $this->compiler->addLogMessage($this->formatter->formatResolveInheritance($this, $this->currentId, $parent));
     $def = new Definition();
     // merge in parent definition
     // purposely ignored attributes: scope, abstract, tags
     $def->setClass($parentDef->getClass());
     $def->setArguments($parentDef->getArguments());
     $def->setMethodCalls($parentDef->getMethodCalls());
     $def->setProperties($parentDef->getProperties());
     $def->setAutowiringTypes($parentDef->getAutowiringTypes());
     if ($parentDef->getFactoryClass(false)) {
         $def->setFactoryClass($parentDef->getFactoryClass(false));
     }
     if ($parentDef->getFactoryMethod(false)) {
         $def->setFactoryMethod($parentDef->getFactoryMethod(false));
     }
     if ($parentDef->getFactoryService(false)) {
         $def->setFactoryService($parentDef->getFactoryService(false));
     }
     if ($parentDef->isDeprecated()) {
         $def->setDeprecated(true, $parentDef->getDeprecationMessage('%service_id%'));
     }
     $def->setFactory($parentDef->getFactory());
     $def->setConfigurator($parentDef->getConfigurator());
     $def->setFile($parentDef->getFile());
     $def->setPublic($parentDef->isPublic());
     $def->setLazy($parentDef->isLazy());
     // overwrite with values specified in the decorator
     $changes = $definition->getChanges();
     if (isset($changes['class'])) {
         $def->setClass($definition->getClass());
     }
     if (isset($changes['factory_class'])) {
         $def->setFactoryClass($definition->getFactoryClass(false));
     }
     if (isset($changes['factory_method'])) {
         $def->setFactoryMethod($definition->getFactoryMethod(false));
     }
     if (isset($changes['factory_service'])) {
         $def->setFactoryService($definition->getFactoryService(false));
     }
     if (isset($changes['factory'])) {
         $def->setFactory($definition->getFactory());
     }
     if (isset($changes['configurator'])) {
         $def->setConfigurator($definition->getConfigurator());
     }
     if (isset($changes['file'])) {
         $def->setFile($definition->getFile());
     }
     if (isset($changes['public'])) {
         $def->setPublic($definition->isPublic());
     }
     if (isset($changes['lazy'])) {
         $def->setLazy($definition->isLazy());
     }
     if (isset($changes['deprecated'])) {
         $def->setDeprecated($definition->isDeprecated(), $definition->getDeprecationMessage('%service_id%'));
     }
     if (isset($changes['decorated_service'])) {
         $decoratedService = $definition->getDecoratedService();
         if (null === $decoratedService) {
             $def->setDecoratedService($decoratedService);
         } else {
             $def->setDecoratedService($decoratedService[0], $decoratedService[1], $decoratedService[2]);
         }
     }
     // merge arguments
     foreach ($definition->getArguments() as $k => $v) {
         if (is_numeric($k)) {
             $def->addArgument($v);
             continue;
         }
         if (0 !== strpos($k, 'index_')) {
             throw new RuntimeException(sprintf('Invalid argument key "%s" found.', $k));
         }
         $index = (int) substr($k, strlen('index_'));
         $def->replaceArgument($index, $v);
     }
     // merge properties
     foreach ($definition->getProperties() as $k => $v) {
         $def->setProperty($k, $v);
     }
     // append method calls
     if (count($calls = $definition->getMethodCalls()) > 0) {
         $def->setMethodCalls(array_merge($def->getMethodCalls(), $calls));
     }
     // merge autowiring types
     foreach ($definition->getAutowiringTypes() as $autowiringType) {
         $def->addAutowiringType($autowiringType);
     }
     // these attributes are always taken from the child
     $def->setAbstract($definition->isAbstract());
     $def->setScope($definition->getScope(false), false);
     $def->setShared($definition->isShared());
     $def->setTags($definition->getTags());
     return $def;
 }

 /**
  * Resolves the definition
  *
  * @param string              $id         The definition identifier
  * @param DefinitionDecorator $definition
  *
  * @return Definition
  */
 private function resolveDefinition($id, DefinitionDecorator $definition)
 {
     if (!$this->container->hasDefinition($parent = $definition->getParent())) {
         throw new RuntimeException(sprintf('The parent definition "%s" defined for definition "%s" does not exist.', $parent, $id));
     }
     $parentDef = $this->container->getDefinition($parent);
     if ($parentDef instanceof DefinitionDecorator) {
         $parentDef = $this->resolveDefinition($parent, $parentDef);
     }
     $this->compiler->addLogMessage($this->formatter->formatResolveInheritance($this, $id, $parent));
     $def = new Definition();
     // merge in parent definition
     // purposely ignored attributes: scope, abstract, tags
     $def->setClass($parentDef->getClass());
     $def->setArguments($parentDef->getArguments());
     $def->setMethodCalls($parentDef->getMethodCalls());
     $def->setProperties($parentDef->getProperties());
     $def->setFactoryClass($parentDef->getFactoryClass());
     $def->setFactoryMethod($parentDef->getFactoryMethod());
     $def->setFactoryService($parentDef->getFactoryService());
     $def->setConfigurator($parentDef->getConfigurator());
     $def->setFile($parentDef->getFile());
     $def->setPublic($parentDef->isPublic());
     // overwrite with values specified in the decorator
     $changes = $definition->getChanges();
     if (isset($changes['class'])) {
         $def->setClass($definition->getClass());
     }
     if (isset($changes['factory_class'])) {
         $def->setFactoryClass($definition->getFactoryClass());
     }
     if (isset($changes['factory_method'])) {
         $def->setFactoryMethod($definition->getFactoryMethod());
     }
     if (isset($changes['factory_service'])) {
         $def->setFactoryService($definition->getFactoryService());
     }
     if (isset($changes['configurator'])) {
         $def->setConfigurator($definition->getConfigurator());
     }
     if (isset($changes['file'])) {
         $def->setFile($definition->getFile());
     }
     if (isset($changes['public'])) {
         $def->setPublic($definition->isPublic());
     }
     // merge arguments
     foreach ($definition->getArguments() as $k => $v) {
         if (is_numeric($k)) {
             $def->addArgument($v);
             continue;
         }
         if (0 !== strpos($k, 'index_')) {
             throw new RuntimeException(sprintf('Invalid argument key "%s" found.', $k));
         }
         $index = (int) substr($k, strlen('index_'));
         $def->replaceArgument($index, $v);
     }
     // merge properties
     foreach ($definition->getProperties() as $k => $v) {
         $def->setProperty($k, $v);
     }
     // append method calls
     if (count($calls = $definition->getMethodCalls()) > 0) {
         $def->setMethodCalls(array_merge($def->getMethodCalls(), $calls));
     }
     // these attributes are always taken from the child
     $def->setAbstract($definition->isAbstract());
     $def->setScope($definition->getScope());
     $def->setTags($definition->getTags());
     // set new definition on container
     $this->container->setDefinition($id, $def);
     return $def;
 }

 /**
  * @param Bean $bean
  * @return mixed
  */
 public function create(Bean $bean)
 {
     $useConfigurator = true;
     $originalClass = $class = ltrim($bean->class, '\\');
     if ($bean->factoryMethod) {
         // We don't have a clue what what the real class is, fake it and hope nothing breaks;
         $class = "stdClass";
     } else {
         if (class_exists($class)) {
             $rClass = new \ReflectionClass($class);
             if (!$rClass->implementsInterface('MooDev\\Bounce\\Config\\Configurable')) {
                 // The class definitely doesn't need the configurator, so we can disable it.
                 $useConfigurator = false;
             }
         }
     }
     $usesLookupMethods = false;
     if ($bean->lookupMethods) {
         if (!$this->proxyGeneratorFactory) {
             throw new BounceException("Proxy generator not configured, cannot use lookup-method");
         }
         // If we have lookup methods then the class is actually a generated proxy.
         $class = ltrim($this->proxyGeneratorFactory->loadProxy($bean), '\\');
         $usesLookupMethods = true;
     }
     $def = new Definition($class);
     if ($usesLookupMethods) {
         // The proxy will take an additional, first, constructor arg which is expected to be a bean factory.
         $def->addArgument($this->getBeanFactory());
     }
     if ($useConfigurator) {
         // We use the configurator if we know the class of the bean and it implements Configurable
         // or if we have no idea what the class of the bean is (there's a factory method.)
         $def->setConfigurator($this->getConfigurator());
     }
     if ($bean->scope) {
         // This is getting killed off in Symfony 3. Sigh.
         // TODO: deal with Symfony 3.
         switch ($bean->scope) {
             case "singleton":
                 $def->setScope(ContainerBuilder::SCOPE_CONTAINER);
                 break;
             case "prototype":
                 $def->setScope(ContainerBuilder::SCOPE_PROTOTYPE);
                 break;
             default:
                 $def->setScope($bean->scope);
         }
     }
     foreach ($bean->constructorArguments as $constructorArgument) {
         $def->addArgument($this->convertValueProviderToValue($constructorArgument));
     }
     foreach ($bean->properties as $name => $property) {
         // TODO: Could support setter injection using Reflection here?
         $def->setProperty($name, $this->convertValueProviderToValue($property));
     }
     if ($bean->factoryBean) {
         $def->setFactoryService($bean->factoryBean);
         $def->setFactoryMethod($bean->factoryMethod);
     } elseif ($bean->factoryMethod) {
         $def->setFactoryClass($originalClass);
         $def->setFactoryMethod($bean->factoryMethod);
     }
     return $def;
 }

 /**
  * Set a property on the service.
  *
  * @param string $name The property name.
  * @param mixed $value The property value.
  *
  * @api
  * @since 4.0.0
  */
 public function setProperty($name, $value)
 {
     $this->_underlyingSymfonyDefinition->setProperty($name, $value);
     return $this;
 }

 /**
  * @param string $className
  * @param ReflectionClass $reflectionClass
  * @param Definition $definition
  * @param string $fastAnnotationChecksRegex
  * @param string[] $preferredServices
  * @param ParameterBagInterface $parameterBag
  */
 private function autowireClass($className, ReflectionClass $reflectionClass, Definition $definition, $fastAnnotationChecksRegex, $preferredServices, ParameterBagInterface $parameterBag)
 {
     // constructor - autowire always
     if ($reflectionClass->getConstructor()) {
         $definition->setArguments($this->autowireMethod($className, $reflectionClass->getConstructor(), $definition->getArguments(), $preferredServices));
     }
     if ($fastAnnotationChecksRegex === null || $reflectionClass->getDocComment() && preg_match($fastAnnotationChecksRegex, $reflectionClass->getDocComment())) {
         // method calls @Autowired
         foreach ($reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC) as $reflectionMethod) {
             if ($reflectionMethod->getName() === "__construct") {
                 continue;
             }
             if ($definition->hasMethodCall($reflectionMethod->getName())) {
                 continue;
             }
             if (strpos($reflectionMethod->getDocComment(), "@Autowired") === false) {
                 continue;
             }
             /** @var Autowired $annotation */
             $annotation = $this->annotationReader->getMethodAnnotation($reflectionMethod, "Skrz\\Bundle\\AutowiringBundle\\Annotation\\Autowired");
             if ($annotation === null) {
                 continue;
             }
             if ($annotation->name !== null) {
                 throw new AutowiringException(sprintf("@Autowired parameter can be used only on properties. %s::%s(...)", $className, $reflectionMethod->getName()));
             }
             $definition->addMethodCall($reflectionMethod->getName(), $this->autowireMethod($className, $reflectionMethod, [], $preferredServices));
         }
         // properties @Autowired, @Value
         $manualProperties = $definition->getProperties();
         foreach ($reflectionClass->getProperties() as $reflectionProperty) {
             if (isset($manualProperties[$reflectionProperty->getName()])) {
                 continue;
             }
             if (strpos($reflectionProperty->getDocComment(), "@Autowired") === false && strpos($reflectionProperty->getDocComment(), "@Value") === false) {
                 continue;
             }
             $annotations = $this->annotationReader->getPropertyAnnotations($reflectionProperty);
             $autowiredAnnotation = false;
             $valueAnnotation = false;
             $incorrectUsage = false;
             foreach ($annotations as $annotation) {
                 if ($annotation instanceof Autowired) {
                     if ($valueAnnotation) {
                         $incorrectUsage = true;
                         break;
                     }
                     $autowiredAnnotation = true;
                     try {
                         if ($annotation->name !== null) {
                             $definition->setProperty($reflectionProperty->getName(), new Reference($annotation->name));
                         } else {
                             $definition->setProperty($reflectionProperty->getName(), $this->getValue($reflectionProperty->getDeclaringClass(), $reflectionProperty->getDocComment(), null, null, false, null, $preferredServices));
                         }
                     } catch (AutowiringException $exception) {
                         throw new AutowiringException(sprintf("%s (Property %s::\$%s)", $exception->getMessage(), $className, $reflectionProperty->getName()), $exception->getCode(), $exception);
                     }
                 } elseif ($annotation instanceof Value) {
                     if ($autowiredAnnotation) {
                         $incorrectUsage = true;
                         break;
                     }
                     try {
                         $definition->setProperty($reflectionProperty->getName(), $parameterBag->resolveValue($annotation->value));
                     } catch (RuntimeException $exception) {
                         throw new AutowiringException(sprintf("%s (Property %s::\$%s)", $exception->getMessage(), $className, $reflectionProperty->getName()), $exception->getCode(), $exception);
                     }
                 }
             }
             if ($incorrectUsage) {
                 throw new AutowiringException(sprintf("Property can have either @Autowired, or @Value annotation, not both. (Property %s::\$%s)", $className, $reflectionProperty->getName()));
             }
         }
     }
 }