Pros of using getter injection¶

Classes designed with getter injection in mind have several advantages over the other IoC strategies:

1. Using inheritance makes them free from any coupling with any framework/DIC (as opposed to container injection);
2. It makes injected dependencies immutable (as opposed to setter/property injection);
3. By requiring to always use the getter to fetch some dependencies internally, it allows for lazy instantiation of said dependencies (as opposed to constructor/setter/property injection);
4. It doesn't pollute the constructor, which is an advantage for classes designed for extensibility (same as setter/property injection - and as opposed to constructor injection);
5. It plays well with traits-based composition, each trait providing a new set of open getters (same pro for setter/property injection - and as opposed to constructor injection);
6. It makes dependencies explicit and type-hinted/enforced (using the getter return-type);
7. It allows to declare mandatory dependencies by using abstract getters;
8. It allows to have optional dependencies by providing default getters that return null;
9. It allows to have and report missing dependencies that are conditionally required when using some subset of the features provided by the base class (typically a controller or a command) - by throwing a useful exception message when that happens;
10. The proxies required to leverage the injection points are easy to write (see example) or generate;
11. The proxies do not need to change when the injected dependencies change themselves (as opposed to using decorators when dealing with laziness);
12. It adds no performance overhead when using the injected dependencies (as opposed to using decorators when dealing with laziness);
13. When using anonymous or generated proxy classes, it doesn't create any new type to hint for, thus is free from inheritance hell.

Cons of using getter injection¶

1. It requires to write an inheritance proxy, thus adds more boilerplate than the other injection strategies when wiring or testing these classes;
2. By design, it doesn't work with final classes nor with private methods;
3. Since PHP (unlike other languages) doesn't provide any way to create inheritance proxies at runtime, it requires either hand written code, a dumped container, or using eval() for runtime-based DICs;
4. When laziness is a target, it gives the laziness responsibility to the caller-side of dependencies (as opposed to callee-side when using decoration) - thus it should be used only when laziness is part of the core business of the class open to getter injection;
5. It adds indirection, thus can make debugging harder (Why is this class throwing?, "Oh, initialization of this lazy dependency fails at that time");
6. When the inheritance proxy provides laziness, it can create circular dependencies in the PHP object graph, making garbage collection required at some point;
7. If the side-effect-free requirement is not met, it will lead to bugs - when not using abstract getters, this requirement is technically hard to enforce (requires static code analyzes).

Discussion¶

The introduction of "getter injection" was controversial and it generated both positive and negative feedbacks. I tried to sum up all rational arguments, pros and cons, in the lists above.

Having addressed them, I hope for the "surprise effect" to disappear over time and have getter injection be evaluated for its technical merits only. My personal point of view about it is that it fills a few holes with its unique pros/cons balance, and as such deserves being part of the developers' tool chain, with support from Symfony's container.

Envisioned use case in Symfony core¶

This feature is targeted at being used for framework-specific needs first. The target for now is to provide decoupled composable base controller trait(s). See pull request 18193 for what could be the next step on the topic.

FAQ¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

$myDep = new DepClass();
$myConsumer = new class ($myDep) extends ConsumerClass {
    private $dep;

    public function __construct(DepClassInterface $dep)
    {
        $this->dep = $dep;
    }

    protected function getDep(): DepClassInterface
    {
        return $this->dep;
    }
};

1
2
3
4
5
6
7
8
9

$myDep = new DepClass();
$myConsumer = new class () use ($myDep) extends ConsumerClass {
    private $dep = $myDep;

    protected function getDep(): DepClassInterface
    {
        return $this->dep;
    }
};

1
2

$consumer = $this->createMock('ConsumerClass')->setMethods(['getDep'])->getMock();
$consumer->expects($this->any())->method('getDep')->will($this->returnValue($myDep));