Skip to content
Switch branches/tags
Go to file

Latest commit


Git stats


Failed to load latest commit information.
Latest commit message
Commit time

Proxy generator for Symfony's DIC

Release Build Status Code Quality Code Coverage Packagist

This package provides a proxy generator for Symfony's dependency injection component that generates super tiny, super simple proxies, especially when compared to Symphony's default implementation. Here are some differences:

  • Can proxy final classes.
  • Can only proxy classes with interfaces.
  • The generated proxies are self-contained.
  • The package is ~10Kb and doesn't have dependencies, other than symfony/dependency-injection of course.
  • The package can be removed once the proxies have been generated.

If you're not familiar with proxy services, better have a look at Symfony's documentation before going any further.

How it works

The generator works with the following assumptions: the service we want to proxy implements an interface, and services using that service expect that interface, following the dependency inversion principle. Now, consider the following code, where an ExceptionHandler service requires a logger implementing LoggerInterface:


use Psr\Log\LoggerInterface;

class ExceptionHandler
    private $logger;

    public function __construct(LoggerInterface $logger)
        $this->logger = $logger;

    // …

Imagine we're using Monolog as logger, and we have an expansive stream to set up. Why waste time building the logger for every request when it's seldom used? That's when we mark our service as lazy.

The following example demonstrates how we can mark our Psr\Log\LoggerInterface service as lazy (we could use PHP code or XML just the same):

    class: Monolog\Logger
    lazy: true

The service can also use a factory:

    factory: 'LoggerFactory::build'
    lazy: true

We don't have to define our service with a class, we could use logger instead of Psr\Log\LoggerInterface just the same, except we would have to define class for the factory one.

Now let's see how to build our container.

Building the dependency injection container

The following code demonstrates how to build, compile, and dump a container:


use olvlvl\SymfonyDependencyInjectionProxy\ProxyDumper;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Dumper\PhpDumper;

$builder = new ContainerBuilder();

// …
// Here we load our config, or build the container using clever PHP calls.
// We might even have some compiler passes to add.
// …


$dumper = new PhpDumper($builder);
$dumper->setProxyDumper(new ProxyDumper());

/* @var string $containerFile */

file_put_contents($containerFile, $dumper->dump());

There you have it. We can use our container as usual and everything is awesome.

What if my lazy service implements multiple interfaces?

The basic interface resolver will have a hard time figuring out which interface to implement if a service implements many. For instance, if a service was an instance of ArrayObject the following exception would be thrown:

Don't know which interface to choose from for ArrayObject: IteratorAggregate, Traversable, ArrayAccess, Serializable, Countable.

We can specify the interface to implement using the lazy attribute:

  lazy: ArrayAccess


The package requires PHP 7.2.5 or later.


The recommended way to install this package is through Composer:

$ composer require olvlvl/symfony-dependency-injection-proxy

Cloning the repository

The package is available on GitHub, its repository can be cloned with the following command line:

$ git clone


The test suite is ran with the make test command. PHPUnit and Composer need to be globally available to run the suite. The command installs dependencies as required. The make test-coverage command runs test suite and also creates an HTML coverage report in build/coverage. If your environment doesn't meet the requirements you can run the tests with a container, run make test-container-72 or make test-container-74 to create it.

The package is continuously tested by Travis CI.

Build Status Code Coverage


olvlvl/symfony-dependency-injection-proxy is licensed under the New BSD License - See the LICENSE file for details.