DI Container: inject the right components from a collection of same types?

Question

I'm trying to hack my own dependency injection container in PHP, based on constructor injection. The container instantiates complex objects and inject them with the required objects based on the type hints in the constructor using reflection.

One thing I obviously stumbled upon is the fact that I can register multiple components that can be injected, of the same type (extending same class / implementing same interface(s)). For example, what if two objects both need distinct objects that both implement an Iterator interface. How do DI Containers typically deal with this? How do you let the container decide which of the objects with the ambiguous interfaces need to be injected in which of the complex objects?

Or is a single DI container only ment to be responsible for creating one type of complex object? In other words: for each complex object instantiate a distinct DI container. I can hardly imagine this is the intent, right?

Answer 1

What you're describing isn't DI, per se, but rather autowiring, a step further than plain DI. Normally with DI you explicitly configure which components get wired into what.

Autowired DI is only really desirable with coarse-grained components, where there's only one sensible implementation of the given type (e.g. DAOs). In cases where the type is ambiguous, then you either mark one of them as the "primary", or mark the others as "not candidates", or explicitly mark the dependency with the name of the component you need.

If it helps, you could read up on how Spring handles autowiring here and here

Answer 2

Depending on what you mean by your question, here's what Guice (a DI framework for Java) uses:

If you simply want a distinct object every time you have an injection request for Foo, then when wiring up your application don't bind Foo.class to a particular instance of Foo, but instead bind a Provider<Foo>, which is an object that creates a Foo on demand. Then, every place where Foo is injected will get a new instance. If you just bind Foo to a class instead of a Foo instance (say, Foo is an interface, and you bound it to RealFoo.class which is a class that implements Foo), you also get the same effect - a new instance is created every time. (This is the default, "unscoped" behavior. The behavior of Guice scopes is beyond the scope of this comment)

If however you need to have two instances of Foo that you construct when wiring up your application and then have the ability to say "This instance of Foo gets used when making a Bar or a Baz, whereas this other instance is used when making a Bumble", what you do is annotate the injection points and then when wiring up your app say something like:

Foo foo1 = new Foo("1");
Foo foo2 = new Foo("2");
bind(Foo.class).annotatedWith(Names.named("Bar")).toInstance(foo1);
bind(Foo.class).annotatedWith(Names.named("Baz")).toInstance(foo1);
bind(Foo.class).annotatedWith(Names.named("Bumble")).toInstance(foo2);

Where I assume that you've annotated the arguments to Bar's constructor with something like:

public Bar(@Named("Bar") Foo foo) { ...

And similarly for Baz and Bumble. Of course, if you annotate the constructor of Bar and Baz with the same thing, you can skip one of the bind lines.

I know there are annotation-processing frameworks for php based on reflection, or perhaps you can use a convention based on argument names.