I went down this rathole today and wanted to write it down.
In CDI, let’s say you have an injection point like this:
@Inject @Flabrous // qualifier, let's say private Instance<Frobnicator> flabrousFrobnicators;
The container is obligated to provide a built-in bean, whatever that is, that can satisfy any injection point whose raw type is
If you think about this for a moment or two you’ll realize that this is really weird. The container cannot possibly know “in advance” what injection points there will be, and so can’t actually create one bean for a
@Default Instance<Frobnicator> and another for a
@Flabrous Instance<Frobnicator>. So somehow its built-in bean has to be findable and appropriate for any possible combination of parameterized type (whose raw type is
Instance) and sets of qualifiers.
Weld solves this problem by rewriting your injection point quietly on the fly (or at least this is one way to look at it). This was quite surprising and I was glad to finally find out how this machinery works.
For example, in the code above, as part of my injection point resolution request I have effectively said: “Hey, Weld, find me a contextual reference to a contextual instance of the appropriate bean found among all beans that are assignable to an
Instance<Frobnicator>-typed injection point and that have the
@Flabrous qualifier among their qualifiers.” Of course, Weld cannot actually issue the bean-finding part of this request as-is, because there is no such bean (how could it possibly pre-create an
Instance<Frobnicator>-typed bean with
@Flabrous among its qualifiers?). So how does this work, exactly? Something must be going on with
@Any but it’s nowhere to be seen here and isn’t applied by default to injection points.
It turns out Weld recognizes a class of beans that they call façade beans for which all injection requests are effectively rewritten (during the bean-finding part of the resolution process).
Instance is one kind;
Event is another;
Provider is another and so on—you can see why they’ve decided these are special sorts of things.
At any rate, when you ask for a façade bean, the request that is made for the bean itself uses only the
@Any qualifier, no matter what you’ve annotated your injection point with. All beans, including built-in ones, have the
@Any qualifier, so the one true container-provided
Instance bean will be found. And there’s our answer.
OK, that’s fine, but in the example above now we have a qualifier,
@Flabrous, that we actually want to use, or we wouldn’t have gone to all this trouble. How does that get applied, given that it is ignored in the bean sourcing part of the injection resolution request?
Weld has tricked its own innards into supplying what is technically an inappropriate bean—it pretended that we asked for an
Instance<Frobnicator> bean even though we didn’t—but now that it has it, it can ignore whatever qualifiers the bean bears (
@Any, as it turns out, and none other) because they’re no longer relevant once the bean is found. All that matters now is contextual instance mechanics.
Provider and other façade beans are required to be in
@Dependent scope, it turns out that the current injection point is available and can be used internally by the bean itself to find out what qualifiers are in effect so that it can create an appropriate contextual instance. And that’s exactly what happens: the bean supplied by Weld is an extension of
AbstractFacade which uses the injection point to determine what qualifiers are in effect.
This whole process is of course deeply weird and I’d imagine that it or derivative effects rely on a hard-coded list of façade beans somewhere. Sure enough, here’s an example of the sort of thing I mean.
Another way to approach this sort of thing might be to introduce a super-qualifier or something instead that says, hey, if a bean is qualified with this super-qualifier then it matches all qualifier comparison requests (which is really what’s going on here).
Anyway, I hate magic and am glad to have found out how this works!