It's not a secret anymore!
The moose likes EJB Certification (SCBCD/OCPJBCD) and the fly likes DI doubt in Session Bean Big Moose Saloon
  Search | Java FAQ | Recent Topics | Flagged Topics | Hot Topics | Zero Replies
Register / Login

Win a copy of Introducing JavaFX 8 Programming this week in the JavaFX forum!
JavaRanch » Java Forums » Certification » EJB Certification (SCBCD/OCPJBCD)
Bookmark "DI doubt in Session Bean" Watch "DI doubt in Session Bean" New topic

DI doubt in Session Bean

Joe Harry
Ranch Hand

Joined: Sep 26, 2006
Posts: 9967


The following lines are from the EJB 3.0 in Action book,

What do we mean here by JNDI?? It is almost the same isn't it?

SCJP 1.4, SCWCD 1.4 - Hints for you, Certified Scrum Master
Did a rm -R / to find out that I lost my entire Linux installation!
Marco Ehrentreich
best scout

Joined: Mar 07, 2007
Posts: 1294

Hi Jothi,

JNDI is not really the same. You can use it to obtain a reference to some dependencies or resources but it works just the other way round than dependency injection. You actively look up the things you want in the case of JNDI and with DI the container (or another framework) injects it. That's why it's a principle of IoC (= inversion of control).

I'm not 100% sure why it's not allowed to inject a stateful component into a stateless but I guess with injection it would be injected into a member variable which would then be shared by multiple threads accessing the same stateless bean object. This would in turn make it unpredictable which thread would see which injected resources. The container simply couldn't handle that every client sees the correct injected resources in this scenario. If you use JNDI to look up a stateful component and save it into a local variable within a method no concurrency conflicts can happen because local variable are thread-safe per definition. That's just a guess, but it makes sense, I think.

Jaikiran Pai

Joined: Jul 20, 2005
Posts: 10441

The reason why you must not inject a SFSB in a SLSB is simple. Since you have injected an SFSB into SLSB, you are expecting the state to be maintained in the SLSB, which is not what the SLSB contract mandates.

Consider SLSB-A and SFSB-B. A client gets hold of an instance of SLSB-A (let's call it SLSB-A(1)). When the injection happens in SLSB-A(1) an instance of SFSB-B(1) gets injected into it. Client does some operation on SLSB-A(1) which internally sets some state on the SFSB-B(1). The control then returns back to the client. Now the client does some other operation on SLSB-A. Remember that since SLSBs are pooled and as per the contract are not guaranteed to store state across calls, the container can forward the call to a different instance of the SLSB. So the second call might go to SLSB-A(2) which means that the state stored in SLSB-A(1) isn't available to SLSB-A(2).

[My Blog] [JavaRanch Journal]
Duran Harris
Ranch Hand

Joined: Nov 09, 2008
Posts: 603

But doesn't this:

1. Keep in mind that you must not inject a stateful session bean into a stateless
2. object, such as a stateless session bean or servlet that may be shared by multiple
3. concurrent clients (you should use JNDI in such cases instead).

hold true ,just because with JNDI you could lookup the stateful bean and assign it a a local variable to store in the HTTPSession later.Whereas DI doesn't allow injection into local variables?

===>SCJP 1.5(72%)<===
I agree. Here's the link:
subject: DI doubt in Session Bean
It's not a secret anymore!