PHP ContainerBuilder::register方法代码示例

 /**
  * {@inheritdoc}
  */
 public function load(array $config, ContainerBuilder $container)
 {
     // checker
     $container->register('bravesheep_active_link.checker', 'Bravesheep\\ActiveLinkBundle\\ActiveChecker')->addArgument(new Reference('kernel'))->addArgument(new Reference('request_stack'));
     // twig extension
     $container->register('bravesheep_active_link.twig', 'Bravesheep\\ActiveLinkBundle\\Twig\\BravesheepActiveLinkExtension')->addArgument(new Reference('bravesheep_active_link.checker'))->addTag('twig.extension');
 }

 /**
  * {@inheritdoc}
  */
 public function setUp()
 {
     $this->container_builder = new ContainerBuilder();
     $this->container_builder->register('foo', 'My/Class');
     $this->container_builder->setAlias('bar', 'foo');
     $this->dumper = new PhpArrayDumper($this->container_builder);
 }

 /**
  * @param array            $configs
  * @param ContainerBuilder $container
  */
 public function load(array $configs, ContainerBuilder $container)
 {
     $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
     $loader->load('services.yml');
     $configuration = new Configuration();
     $config = $this->processConfiguration($configuration, $configs);
     $container->setParameter('chebur_sphinx_config', $config);
     //Filling in Registry with managers
     $names = array();
     $nameDefault = null;
     $loggerRef = new Reference('chebur.sphinx.profiler.logger');
     foreach ($config['connections'] as $connectionName => $val) {
         $container->register('chebur.sphinx.connection.' . $connectionName, $container->getParameter('chebur.sphinx.connection.class'))->addArgument($connectionName)->addArgument($loggerRef)->addArgument($val['driver'])->addArgument($val['host'])->addArgument($val['port'])->addArgument($val['port_api']);
         $container->register('chebur.sphinx.manager.' . $connectionName, $container->getParameter('chebur.sphinx.manager.class'))->addArgument(new Reference('chebur.sphinx.connection.' . $connectionName));
         $names[] = $connectionName;
         if ($val['default']) {
             $nameDefault = $connectionName;
         }
     }
     if (!$nameDefault) {
         $nameDefault = $names[array_keys($names)[0]];
     }
     $container->setAlias('chebur.sphinx.manager', 'chebur.sphinx.manager.' . $nameDefault);
     $container->register('chebur.sphinx', $container->getParameter('chebur.sphinx.registry.class'))->addArgument(new Reference('service_container'))->addArgument($names)->addArgument($nameDefault);
 }

 public function testExceptionWhenNameAttributeIsMissing()
 {
     $this->setExpectedException('RuntimeException');
     $this->container->register('test_receiver', 'stdClass')->addTag('bernard.receiver', []);
     $pass = new ReceiverPass();
     $pass->process($this->container);
 }

 public function configureApiServices(ContainerBuilder $container, array $apiServices, array $cache)
 {
     $serviceFactoryRef = new Reference('api_service.factory');
     // Register decoder
     $definition = $container->register('api_service.decoder.symfony', ChainDecoder::class);
     $definition->setArguments([[new Reference('serializer.encoder.json'), new Reference('serializer.encoder.xml')]]);
     $definition = $container->register('api_service.decoder', SymfonyDecoderAdapter::class);
     $definition->setArguments([new Reference('api_service.decoder.symfony')]);
     // Register validator
     $validator = $container->register('api_service.json_schema_validator', Validator::class);
     $validator->setPublic(false);
     // Configure schema factory
     $schemaFactoryId = 'api_service.schema_factory.swagger';
     if ($cache['enabled']) {
         $schemaFactory = $container->getDefinition('api_service.schema_factory.cached_factory');
         $schemaFactory->replaceArgument(0, new Reference($cache['service']));
         $schemaFactory->replaceArgument(1, new Reference($schemaFactoryId));
         $schemaFactoryId = 'api_service.schema_factory.cached_factory';
     }
     $container->setAlias('api_service.schema_factory', $schemaFactoryId);
     // Configure each api services
     foreach ($apiServices as $name => $arguments) {
         $container->register('api_service.api.' . $name, ApiService::class)->setFactory([$serviceFactoryRef, 'getService'])->addArgument(new Reference($arguments['client']))->addArgument(new Reference($schemaFactoryId))->addArgument($arguments['schema'])->addArgument($arguments['config']);
     }
 }

 public function testProcessIgnoresMethodCalls()
 {
     $container = new ContainerBuilder();
     $container->register('a')->addArgument(new Reference('b'));
     $container->register('b')->addMethodCall('setA', array(new Reference('a')));
     $this->process($container);
 }

 /**
  * @param null $configPath
  * @param array $configFilenames
  */
 function __construct($configPath = null, $configFilenames = array())
 {
     $configPath = $configPath == null ? __DIR__ . '/../../../../../../app/config' : $configPath;
     $this->container = new ContainerBuilder();
     // Load app parameters and config files into container
     $loader = new YamlFileLoader($this->container, new FileLocator($configPath));
     $loader->load('parameters.yml');
     foreach ($configFilenames as $filename) {
         $loader->load($filename);
     }
     $appName = $this->container->getParameter('application_name');
     $appVersion = $this->container->getParameter('application_version');
     parent::__construct($appName, $appVersion);
     // Set dispatcher definition, register listeners and subscribers
     $dispatcherDef = $this->container->register('event_dispatcher', 'Symfony\\Component\\EventDispatcher\\ContainerAwareEventDispatcher');
     $dispatcherDef->addArgument($this->container);
     $this->registerEventListeners();
     $this->container->compile();
     // Once container is compiled we can get the event_dispatcher from dic
     $this->dispatcher = $this->container->get('event_dispatcher');
     // Add console commands (services console.command tagged)
     foreach ($this->getTaggedCommands() as $id) {
         $command = $this->container->get($id);
         $this->add($command);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function process(ContainerBuilder $container)
 {
     $botCommands = [];
     /** @var BundleInterface[] $modules */
     $modules = $container->getParameter('kernel.modules');
     foreach ($modules as $name => $module) {
         $ref = new \ReflectionClass($module);
         $dir = dirname($ref->getFileName());
         $finder = new Finder();
         $finder->files()->name('*BotCommand.php')->in($dir);
         $moduleCommands = [];
         $prefix = $ref->getNamespaceName();
         /** @var SplFileInfo $file */
         foreach ($finder as $file) {
             $ns = $prefix;
             if ($relativePath = $file->getRelativePath()) {
                 $ns .= '\\' . str_replace('/', '\\', $relativePath);
             }
             $class = $ns . '\\' . $file->getBasename('.php');
             $reflection = new \ReflectionClass($class);
             if ($this->isValidBotCommand($reflection)) {
                 $id = 'bot.command.' . strtolower(str_replace('\\', '_', $class));
                 $container->register($id, $class)->addArgument(new Reference('service_container'))->addTag('bot_command');
                 $botCommands[] = new Reference($id);
                 $moduleCommands[] = $id;
             }
         }
         $container->setParameter('bot.' . $ref->getShortName() . '.commands', $moduleCommands);
     }
     $container->register('repository.command', BotCommandRepository::class)->setArguments([$botCommands]);
 }

 public function test_accessing_service_by_alias()
 {
     $this->containerBuilder->register('service', new SymfonyDefinition(\stdClass::class));
     $this->containerBuilder->setAlias('service_alias', 'service');
     $this->assertTrue($this->serviceContainer->definitionExists('service_alias'));
     $this->assertSame(\stdClass::class, $this->serviceContainer->definitionClass('service_alias'));
 }

 /**
  * Load balancer service
  *
  * @param array            $config
  * @param ContainerBuilder $container
  */
 protected function loadBalancer(array $config, ContainerBuilder $container)
 {
     $container->register('meup_geo_location.balancer.random_strategy', 'Meup\\Bundle\\GeoLocationBundle\\Domain\\BalancingStrategy\\RandomStrategy');
     $container->setAlias('meup_geo_location.balancer.strategy', $config['balancer']['strategy']);
     $container->register('meup_geo_location.balancer_factory.default', 'Meup\\Bundle\\GeoLocationBundle\\Domain\\BalancerFactory')->addArgument('Meup\\Bundle\\GeoLocationBundle\\Domain\\Balancer')->addArgument(new Reference('meup_geo_location.balancer.strategy'));
     $container->setAlias('meup_geo_location.balancer_factory', $config['balancer']['factory']);
 }

 /**
  * @covers Symfony\Component\DependencyInjection\ContainerBuilder::createService
  */
 public function testCreateServiceFactoryService()
 {
     $builder = new ContainerBuilder();
     $builder->register('baz_service')->setFactoryService('baz_factory')->setFactoryMethod('getInstance');
     $builder->register('baz_factory', 'BazClass');
     $this->assertInstanceOf('BazClass', $builder->get('baz_service'));
 }

 public function testProcess()
 {
     $container = new ContainerBuilder();
     $container->register('a')->addArgument(new Reference('b'));
     $container->register('b');
     $this->process($container);
 }

 /**
  * {@inheritdoc}
  */
 public function process(ContainerBuilder $container)
 {
     if (!$container->hasDefinition('cache.data_collector')) {
         return;
     }
     // Create a factory service
     $factoryId = 'cache.recorder_factory';
     $factory = $container->register($factoryId, Factory::class);
     // Check if logging support is enabled
     if ($container->hasParameter('cache.logging')) {
         $config = $container->getParameter('cache.logging');
         $factory->addArgument(new Reference($config['logger']));
         $factory->addArgument($config['level']);
     }
     $collectorDefinition = $container->getDefinition('cache.data_collector');
     $serviceIds = $container->findTaggedServiceIds('cache.provider');
     foreach (array_keys($serviceIds) as $id) {
         // Get the pool definition and rename it.
         $poolDefinition = $container->getDefinition($id);
         $poolDefinition->setPublic(false);
         $container->setDefinition($id . '.inner', $poolDefinition);
         // Create a recording pool with a factory
         $recorderDefinition = $container->register($id, DummyAdapter::class);
         $recorderDefinition->setFactory([new Reference($factoryId), 'create']);
         $recorderDefinition->addArgument($id);
         $recorderDefinition->addArgument(new Reference($id . '.inner'));
         $recorderDefinition->setTags($poolDefinition->getTags());
         // Tell the collector to add the new instance
         $collectorDefinition->addMethodCall('addInstance', [$id, new Reference($id)]);
     }
 }

 public function process(ContainerBuilder $container)
 {
     $container->setParameter('json_api.controller_listener.class', ControllerListener::class);
     $container->setParameter('json_api.symfony_integration.class', SymfonyIntegration::class);
     $container->register('json_api.symfony_integration', '%json_api.symfony_integration.class%')->addMethodCall('setContainer', array(new Reference('service_container')));
     $container->register('json_api.controller_listener', '%json_api.controller_listener.class%')->addMethodCall('setContainer', array(new Reference('service_container')))->addTag('kernel.event_listener', ['event' => 'kernel.controller', 'method' => 'onKernelController']);
 }

 /**
  * @param array            $configs
  * @param ContainerBuilder $container
  */
 private function registerPagers(array $configs, ContainerBuilder $container)
 {
     $shouldDisableRedirector = true;
     foreach ($configs as $name => $config) {
         $serviceId = sprintf("%s.%s", self::PREFIX_PAGER, $name);
         $definition = $container->register($serviceId, $container->getParameter('kg_pager.class'));
         // Sets the default items per page for the given pager.
         if (isset($config['per_page'])) {
             $definition->addArgument($config['per_page']);
         }
         // Changes the strategy, if this pager should merge last two pages
         // given the following threshold.
         if (isset($config['merge']) && $config['merge'] > 0) {
             $strategyDefinition = new Definition($container->getParameter('kg_pager.strategy.last_page_merged.class'));
             $strategyDefinition->addArgument($config['merge']);
             $definition->addArgument($strategyDefinition);
         }
         // Wraps the pager inside a request decorator to have it automatically
         // infer the current page from the request.
         if ($config['key']) {
             $definition = $container->register($serviceId, $container->getParameter('kg_pager.request_decorator.class'))->setArguments(array($definition, new Reference('request_stack'), $config['key']));
         }
         if ($config['redirect']) {
             $shouldDisableRedirector = false;
             $definition = $container->register($serviceId, $container->getParameter('kg_pager.bounds_check_decorator.class'))->setArguments(array($definition));
             if ($config['key']) {
                 $definition->addArgument($config['key']);
             }
         }
     }
     if ($shouldDisableRedirector) {
         $container->removeDefinition('kg_pager.out_of_bounds_redirector');
     }
 }