Cover of the book Symfony 5: The Fast Track

Symfony 5: The Fast Track is the best book to learn modern Symfony development, from zero to production. +300 pages in full color showing how to combine Symfony with Docker, APIs, queues & async tasks, Webpack, Single-Page Applications, etc.

Buy printed version
Buy PDF version
  1. Home
  2. Documentation
  3. Configuration
  4. Using Parameters within a Dependency Injection Class

Using Parameters within a Dependency Injection Class

3.4 version
Maintained
4.4 5.1 current 5.2 master
Unmaintained
2.7 2.8 3.0 3.1 3.2 3.3 4.0 4.1 4.2 4.3 5.0
edit this page

Using Parameters within a Dependency Injection Class

You have seen how to use configuration parameters within Symfony service containers. There are special cases such as when you want, for instance, to use the %kernel.debug% parameter to make the services in your bundle enter debug mode. For this case there is more work to do in order to make the system understand the parameter value. By default, your parameter %kernel.debug% will be treated as a simple string. Consider the following example:

// inside Configuration class
$rootNode
    ->children()
        ->booleanNode('logging')->defaultValue('%kernel.debug%')->end()
        // ...
    ->end()
;

// inside the Extension class
$config = $this->processConfiguration($configuration, $configs);
var_dump($config['logging']);

Now, examine the results to see this closely:

  • YAML
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
    my_bundle:
    logging: true
    # true, as expected

my_bundle:
    logging: '%kernel.debug%'
    # true/false (depends on 2nd parameter of AppKernel),
    # as expected, because %kernel.debug% inside configuration
    # gets evaluated before being passed to the extension

my_bundle: ~
# passes the string "%kernel.debug%".
# Which is always considered as true.
# The Configurator does not know anything about
# "%kernel.debug%" being a parameter.
  • XML
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
    <?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:my-bundle="http://example.org/schema/dic/my_bundle"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://example.org/schema/dic/my_bundle
        https://example.org/schema/dic/my_bundle/my_bundle-1.0.xsd">

    <my-bundle:config logging="true"/>
    <!-- true, as expected -->

    <my-bundle:config logging="%kernel.debug%"/>
    <!-- true/false (depends on 2nd parameter of AppKernel),
         as expected, because %kernel.debug% inside configuration
         gets evaluated before being passed to the extension -->

    <my-bundle:config/>
    <!-- passes the string "%kernel.debug%".
         Which is always considered as true.
         The Configurator does not know anything about
         "%kernel.debug%" being a parameter. -->
</container>
  • PHP
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
    $container->loadFromExtension('my_bundle', [
        'logging' => true,
        // true, as expected
    )
];

$container->loadFromExtension('my_bundle', [
        'logging' => "%kernel.debug%",
        // true/false (depends on 2nd parameter of AppKernel),
        // as expected, because %kernel.debug% inside configuration
        // gets evaluated before being passed to the extension
    )
];

$container->loadFromExtension('my_bundle');
// passes the string "%kernel.debug%".
// Which is always considered as true.
// The Configurator does not know anything about
// "%kernel.debug%" being a parameter.

In order to support this use case, the Configuration class has to be injected with this parameter via the extension as follows:

namespace AppBundle\DependencyInjection;

use Symfony\Component\Config\Definition\Builder\TreeBuilder;
use Symfony\Component\Config\Definition\ConfigurationInterface;

class Configuration implements ConfigurationInterface
{
    private $debug;

    public function  __construct($debug)
    {
        $this->debug = (bool) $debug;
    }

    public function getConfigTreeBuilder()
    {
        $treeBuilder = new TreeBuilder();
        $rootNode = $treeBuilder->root('my_bundle');

        $rootNode
            ->children()
                // ...
                ->booleanNode('logging')->defaultValue($this->debug)->end()
                // ...
            ->end()
        ;

        return $treeBuilder;
    }
}

And set it in the constructor of Configuration via the Extension class:

namespace AppBundle\DependencyInjection;

use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\HttpKernel\DependencyInjection\Extension;

class AppExtension extends Extension
{
    // ...

    public function getConfiguration(array $config, ContainerBuilder $container)
    {
        return new Configuration($container->getParameter('kernel.debug'));
    }
}

Setting the Default in the Extension

There are some instances of %kernel.debug% usage within a Configurator class in TwigBundle and AsseticBundle. However, this is because the default parameter value is set by the Extension class. For example in AsseticBundle, you can find:

$container->setParameter('assetic.debug', $config['debug']);

The string %kernel.debug% passed here as an argument handles the interpreting job to the container which in turn does the evaluation. Both ways accomplish similar goals. AsseticBundle will not use %kernel.debug% but rather the new %assetic.debug% parameter.

This work, including the code samples, is licensed under a Creative Commons BY-SA 3.0 license.