Hey,

I create factory by the Persistence class , create entity manager and than bind it to the JNDI.

In the DAO i look up to this EM and join to the transaction (without this it will not commit although that i add this attribute -
<property name="hibernate.transaction.factory_class" value="org.hibernate.ejb.transaction.JoinableCMTTransactionFactory"/>
to the persistence xml file )

Is this ok to bind the EM to the JNDI in the java code?

Thank you

No, this is not OK. The EntityManager is single-threaded and not thread-safe. You can not access the same EntityManager from two threads concurrently.

That bind the entity manager to the JNDI:
jboss.entity.manager.jndi.name

The issue that if i create the entity manager each time i call to the DAO i will not share the same persistence context.

if i call to DAO.save
and after it call to DAO.find

and in the DAO i create entity manager they will have the same persistence context and i will not find this record.

Thank you

That doesn't even exist.

It is documented here though:

http://docs.jboss.org/ejb3/app-server/reference/build/reference/en/html/entityconfig.htm

I am pretty certain it works in 4.0.4GA

Cheers,

Andy

see this link:
http://docs.jboss.org/ejb3/app-server/r ... onfig.html

But i am not sure it is work.

Do you have an idea how to propograte (share) the persistence context (entity manager ) in the same thread.

I can use injection because i create this factory in run - time.

thank you

You propagate it along with the transaction context, by using EJB components that call each other. Your controller calls your DAOs inside the same transaction.

I need to investigate why the documentation says you can bind an EntityManager to JNDI. This is most likely a documentation glitch because it doesn't make any sense.

Due to some restrictions (I need to create schema dynamically) I cant use injection , so I create the factory and bind it to the JNDI.

The issue that immediately after I save an Object I call to find but I get null although that the Object will save to the DB after the transaction will end (the transaction boundaries are in the stateless) .

In case that I use this code to find - em.find(Hotel.class, newHotel.getOrmID()); its okey in both cases , but I cant use this attitude because in the same transaction in another place I can call to another DAO and I want to see the Objects that I already saved .

As you see the persistence context is not propograte to the other DAO's or even to the same DAO if it call again.

I read all the new hibernate book i didnt find any explanation on how to use hibernate as a Jpa provider in a JTA enviroment without injection.

A lot of time you can use injection, like in case of using in a pojo classes.

Thank you.


DAO:

public class TestSimpleDao {

private EntityManager em = null;

public EntityManager getEntityManager(){
EntityManagerFactory emf = null;
try {
emf = (EntityManagerFactory) new InitialContext().lookup("java:/Demo");
} catch (NamingException e) {
e.printStackTrace();
}
em = emf.createEntityManager();
return em;
}

public Hotel saveHotel(Hotel newHotel) {
getEntityManager().persist(newHotel);
newHotel = getEntityManager().find(Hotel.class, newHotel.getOrmID());
return newHotel;
}
}


<persistence>
<persistence-unit name="Demo">
<jta-data-source>java:/DemoDS</jta-data-source>
<properties>
<property name="hibernate.ejb.naming_strategy" value="org.hibernate.cfg.DefaultComponentSafeNamingStrategy" />
<property name="hibernate.transaction.factory_class" value="org.hibernate.ejb.transaction.JoinableCMTTransactionFactory"/>
<property name="hibernate.transaction.manager_lookup_class" value="org.hibernate.transaction.JBossTransactionManagerLookup"/>
</properties>
</persistence-unit>
</persistence>

Hotel:

@Entity
@Table(name = "HOTELS")
public class Hotel implements Serializable {
@Id
@GeneratedValue(generator="system-uuid")
@GenericGenerator(name="system-uuid", strategy = "uuid")
@Column(name="managed_element_id")
protected String ormID = null;

private String name;
private String address;

@OneToMany(cascade=CascadeType.ALL)
@JoinColumn
private List<Room> rooms = new LinkedList<Room>();

private Hotel() {
}

public Hotel(String name, String address) {
this.name = name;
this.address = address;
}
…

I have no idea how this EM binding stuff in JNDI is supposed to work. Complain to Bill Burke (bill@jboss.org) and Carlo de Wolf (carlo.dewolf@jboss.com), who are responsible for it.

And I'm not reading your code until you put it in code tags.

My code:

DAO :

There are no transaction boundaries in your code, I have no idea what you want to actually do. You use two persistence contexts, one does a persist(), the other a find(). As long as the persist() isn't flushed and committed, the find() won't find it.

So it turns out that this magic JBoss property is indeed doing something. What exactly is happening can only be a guess, contact Bill Burke if you like to know more. My guess:

@PersistenceContext(name="MyEntityManager") on a class (session bean) or method (in a session bean) would populate the naming context (ENC) of that bean with a container-managed and transaction-scoped EntityManager. You can look this up through the ENC with java:/comp/env/MyEntityManager as long as you obtain the ENC correctly. AFAIK that means you need to say new InitialContext() inside that beans code.

Now, what the JBoss magic property is doing is apparently binding a container-managed and transaction scoped EntityManager to the java:/ (or global) JNDI namespace. The only difference is that you can populate it with a configuration setting (no annotations on a class) and that you can look it up from anywhere. It's effectively a proxy that will scope itself to the transaction and propagate along with the transaction (usual rules).

Threads.

I dont understand how they did this.

dont forget my DAO is simple class and this is not a good design that the DAO will need to be an Ejb component.

Can you think on solution on how to propograte the persistence context between all the DAO in the same thread.

is there an option to use somthing similar to current session in JPA?


Thank you.

Proxies.



Who says that? This is nonsense, EJB components are plain Java classes. You don't even have to put an annotation on it.



Call your DAOs inside the same UserTransaction scope.



This is _exactly_ what this magical JNDI binding is doing. Instead of sessionFactory.getCurrentSession() you say jndi.lookup("currentEntityManager") and it is magically the right persistence context (scoped and propagated with the transaction).