CDI Inject in Stateless Session Beans requests

Currently we have an elaborate POJO object structure for handling a webservice request, called a 'processor'.

Remote and Local EJB's and PersistenceContext called during serving this request are initialized in the statless bean and handed to this 'processors' constructor which is re-created during each webservice request.

If I do not want to revert to JNDI lookups deep down in my 'processor' I keep on dragging around all these EJB's through my code.

Enter CDI. I would like to be able to inject these EJB's whenever I need them in this 'processor'.

However, I also noticed this means that the current 'processor' has to become a CDI bean itselve: so, using the @Inject in the Stateless Session Bean that implements the webservice.

When I do this the entiry lifecycle of the processor becomes bound to the bean and not to the request its serving.

Suddenly I have to take into consideration that I should not retain state (other than the injected objects) in the processor, since this state will be shared between multiple webservice invocations. As a programmer, this is not making my life more easy.

So: how should I go about doing this? I've read about the scoping but I'm not sure how / if this would be helping me.

Example, stateless bean:

@Stateless
@WebService
public class ExampleBean {

    @Inject
    Processor requestScopedInstance;

    int beanDependentScopeCounter;

    public String sayHello() {
        System.out.println( "bean object id: " + this.toString() );
        return requestScopedInstance.sayHello(beanDependentScopeCounter++);
    }
}

interface:

public interface Processor {

    String sayHello(int beanScopedCounter);
}

Implementation:

public class ProcessorImpl implements Processor {

    private int requestScopedCounter = 0;

    @Override
    public String sayHello(int beanScopedCounter) {
        return "test, requestScoped: " + requestScopedCounter++ + ", beansScoped: " + beanScopedCounter;
    }

}

When I do this the entiry lifecycle of the processor becomes bound to the bean and not to the request its serving that is not correct. That is only the case if you don't use @ApplicationScoped, @SessionScoped, @RequestScoped.

So:

• Annotate your processor with @RequestScoped.
• You don't need to hand over the EJBs, you can just inject them, where needed.
• Use @PostConstruct annotated methods for constructor-code which uses injected objects.
• stateless POJOs can be annotated @ApplicationScoped, not stateless POJOs can stay dependent-scoped which is default.

That is made possible because proxies are injected, not actual beans. Using these proxies CDI makes sure that the correct scope is used for your particular calls.