EJB3: When do Entities get detached in practice?

Question

Hi,
I am currently improving my first EJB3 / JSF prototype in order to get a good feeling for that new technology. I am using Sun Appserver 9, NetBeans 5.5.
I have the followiong design-setup:
JSF-BackingBean ===uses===> @Remote Stateless Session Bean ===fetches==> EntityBeans
The general question is: 1.) Where do EntityBeans get detached in a JSF setup and 2.) does detaching mean, that I cannot traverse the relations anymore, even if I have eager fetching configured`?
Let me also ask some more detailed questions:
The Backing Bean stores the Entity Bean "A" in an attribute. So far so good. My Entity A has a 1:n association to Entity B with eager fetching configured in the annotation. When I now want to access the relation getBs() from within a JSF forEach statement, I keep getting an error from the persistence layer.
I found out, that if my Stateless Session Bean accesses getBs() after having retrieved A before it returns, then it works also from the JSF page. From my current understanding, eager fetching should have had the same effect....???!!!
Anyway, I read the EJB persistence specs and in chapter 5.6.3 it says, that:
Propagation of persistence contexts only applies within a local
environment. Persistence contexts are not propagated to remote tiers.Does this mean, that Entities get detached at this point? But why does it then work even remotely, when I access getBs() from the SLSB?
Furthermore, if I used a Local Interface for the SLSB, can I then expect this to work without the call to getBs()?
Would it have an impact to inject an EntityManager into the BackingBean? From my current understanding, container-managed transactions are demarcated through the SLSB, so the transaction would end there anyway, so I suppose injecting the EntityManager into the BackingBean does NOT have an impact. Can anybody confirm this?
Many Thanks in advance,
Stephan

Answer 1

Hi,
Hi Stephan. Great questions. Answers inline.
I am currently improving my first EJB3 / JSF
prototype in order to get a good feeling for that new
technology. I am using Sun Appserver 9, NetBeans
5.5.
I have the followiong design-setup:
JSF-BackingBean ===uses===> @Remote Stateless Session
Bean ===fetches==> EntityBeans
The general question is: 1.) Where do EntityBeans get
detached in a JSF setup It's independent of JSF itself. The detaching behavior depends on what kind of interface (local vs. remote) is used to access the Stateless Session bean and what the transactional settings are for the invocation. First off, any Java Persitence API entities passed through a Remote interface become detached when received by the caller, even if the caller is in the same application as the callee.
If the related entities were not fetched before the detachment, they will not be available after detachment.
If you use a Local interface to access the Stateless Session Bean, detachment will occur when the transaction within which the entities were fetched commits or rolls back. My guess is you're using the default tx behavior (CMT/TX_REQUIRED) for the SLSB business method and not demarcating transactions in the JSF bean, so the entities will become attached when the SLSB method returns.
and 2.) does detaching mean,
that I cannot traverse the relations anymore, even if
I have eager fetching configured`?You can try traversing afterwards but there's no guarantee the requested
entities will be there. If they happened to have been fetched before
the detachment, they will be returned. Otherwise, they won't be found and
since the entities are no longer associated with an entity manager, it's too
late for them to be fetched.
>
Let me also ask some more detailed questions:
The Backing Bean stores the Entity Bean "A" in an
attribute. So far so good. My Entity A has a 1:n
association to Entity B with eager fetching
configured in the annotation. When I now want to
access the relation getBs() from within a JSF forEach
statement, I keep getting an error from the
persistence layer.
I found out, that if my Stateless Session Bean
accesses getBs() after having retrieved A before it
returns, then it works also from the JSF page. From
my current understanding, eager fetching should have
had the same effect....???!!!That only applies to a managed entity. When it's in the
detached state, the eager fetching doesn't apply since
it's not associated with an EntityManager.
Anyway, I read the EJB persistence specs and in
chapter 5.6.3 it says, that:
Propagation of persistence contexts only applieswithin a local
environment. Persistence contexts are not propagatedto remote tiers.Persistence context propagation refers to the case where
two different Java EE components within the same transaction both access a
container-managed transactional EntityManager. If both components are within
the same application and running on the same JVM, they will "see" the same
persistence context. This is magic performed by the container to preserve
the transactional semantics from the Entity Bean model in J2EE 1.4 and earlier.
E.g, if your JSF bean had a container-managed entity manager and started
a global transaction, then invoked a Stateless Session Bean method with
TX_REQUIRED, the JSF bean's EntityManager would have the same
state as the Stateless Session Bean's EntityManager, without having to explicitly
pass references to entity classes between them.
>
Furthermore, if I used a Local Interface for the
SLSB, can I then expect this to work without the call
to getBs()? Only if you start a global transaction before invoking the SLSB and call
getBs() before committing the tx.
Would it have an impact to inject an EntityManager
into the BackingBean? Yes, that's one way to do it, but you also need to ensure that the same tx is being used. See below.
From my current understanding,
container-managed transactions are demarcated through
the SLSB, so the transaction would end there anyway,It depends on which transaction attribute is used. For the default tx attribute (TX_REQUIRED), if there is an existing transaction when the SLSB is accessed that will be used instead of the container starting a new one, which means it will not be committed by the container when the SLSB method returns.
so I suppose injecting the EntityManager into the
BackingBean does NOT have an impact. Can anybody
confirm this?Not true. See above. There's a good JavaOne talk on the topic of web-tier use of the Java Persistence API given by Linda Demichiel, Gavin King, and Craig McClanahan.
You can find it here :
http://developers.sun.com/learning/javaoneonline/2006/webtier/TS-1887.html
--ken
>
Many Thanks in advance,
Stephan