[webbeans-dev] Creating instances of managed beans (including EJBs) in EE6 (was Re: non-contextual managed bean creation)

Here we need to address a slightly different aspect of managed bean lifecycles when CDI is enabled. This has the most impact on EJBs, as they are currently the only other direct instantiator of managed beans. After speaking to Gavin yesterday, and closely reading the latest CDI spec, I've noticed that CDI now expects EJB to delegate EJB instance creation to CDI, when CDI is enabled in the application. The reason for this is to allow EJBs to support constructor injection. IMO there are three extremely strong reasons why we need to support this: 1) Constructor injection is a (very) good thing, because it allows you to make a class fully immutable. This will make EJBs a more attractive programming model. 2) For a developer, it makes adding EJB services to your EJB (or removing them) more transparent as constructor injections don't have to be altered 3) it's required by the 330 and 299 specs CDI provides an SPI specifically for this purpose with InjectionTarget.produce(), so I propose we add a requirement that Web Beans integrators have their EJB container call injectionTarget.produce() when CDI is enabled in an application to create a bean instance. Clearly, an integrator wouldn't want to hardcode this into their EJB container, so a logical way to implement this would be for the EJB container to provide a (non-portable) SPI that defines lifecycle control for bean instances, along with a default implementation. The SPI could look something like this - default implementation also described: * newInstance() - create a new bean instance as required by EJB spec * inject() - perform Java EE style injection * postConstruct() - call the @PostConstruct method * preDestroy() - call the @PreDestroy method When Web Beans is present, an alternative implementation, which instead hooks into the injectionTarget and calls: * newInstance() - construct an instance, using constructor injection via injectionTarget.produce() * inject() - inject the instance with CDI-style dependencies and EE- style dependencies via injectionTarget().inject() * postConstruct() - call @PostConstruct via injectionTarget.postConstruct() * @PreDestroy - call @PreDestroy via injectionTarget.preDestroy() As we are discussing in the other email, inject() will then delegate back to the container to actually perform the EE style injections Thoughts? On 12 Aug 2009, at 23:02, Pete Muir wrote: