Improve constructor injection

Similiar to Spring IOC, for a component managed by CDI, if there is only one constructor with parameters, it should be injected automatically without an explicit @Inject.

private final OrderRepository orders; // OrderRepository is a CDI bean

public class OrderService(OrderRepository orders){ //OrderRepository should be injected automatically here.
    this.orders = orders;
}

Similarly the methods of a component should be handled automatically.

[Ladicek]

Actually I realize this is perhaps what you had in mind, so one more clarification.

CDI Lite can’t require build-time implementations to work differently from runtime implementations. Code that works with build-time implementations of CDI Lite must work with runtime implementations of CDI Lite, et vice versa.

Further, CDI Lite can’t even require bytecode manipulation. I’m no expert on Micronaut, but they have very different constraints when it comes to build-time manipulation of existing bytecode than Quarkus.

[Ladicek]

CDI Lite still requires the bean constructor to be annotated @Inject (unless it’s a zero-parameter constructor), and it still requires normal-scoped beans to always have a zero-parameter constructor.

Quarkus does 2 things that are outside of the CDI specification:

1. If the bean class has a single constructor, it is assumed to be the bean constructor.
2. If the bean class is normal-scoped and doesn’t have a zero-parameter constructor, Quarkus transforms the bytecode of the class to add the zero-parameter constructor. (There are certain cases when this is not possible.) This conceptually happens after the item 1 above, so the newly introduced zero-parameter constructor doesn’t affect the “discovery” of the bean constructor.

It is entirely unreasonable to expect that all CDI implementations will want / be able to do what Quarkus does in item 2. Therefore, the CDI specification can’t really “simplify” the lookup of the bean constructor by saying “if there’s only one constructor, then …”, because normal-scoped beans will only have one constructor if it’s the zero-parameter constructor.

My opinion is that explicit is always better than implicit, so I personally don’t really like the “simplification” Quarkus does and I still annotate my bean constructors with @Inject.

(Fun fact: there’s one special case. If the desired bean constructor is the zero-parameter constructor, it doesn’t have to be annotated @Inject. In other words, if there’s multiple constructors and none of them is annotated @Inject, then the zero-parameter constructor is selected. But that’s been like that since CDI 1.0.)