Using Spring+Hibernate for testing purposes

Question

I want to clarify my problem a bit more:

1. I understand the purposes of using SPring Framework (i.e. container-managed object lifecycle) and also Hibernate (using ORM between Javaobjects and relational database systems - impedance mismatch resolution).

2. I understand how we autowire an object and Spring takes over the creation and destruction of the object during runtime by looking at the applicationContext.xml file (in addition to persistence.xml file if using Hibernate or any other persistence provider).

What I want to do is the following:

1. I would like to implement my own shopping service. I already have entity (item) annotated with @Table, @Id, @Column, etc. to tell JPA that this is what will be stored in the database.

2. I already have a DAO interface (currently only add and delete methods) implemented by a DaoImpl class where I have done the following:

   @Repository
   @Transactional
   public class MyShopDbDaoImpl implements MyShopDbDao {
       // The following named unit will be in my persistence.xml file
       // Which will be placed in src/main/resources/META-INF folder
       @PersistenceContext(unitName="myShopDbDao")
       private EntityManager em;
   
       // Getters for em (simply returns em)
   
       // Setters for em (simply assigns an em supplied in the args.)
   
   
       // Other query method
   }
   

3. I also have a ShopDbController controller class that uses:

   @Autowired
   // defined in the applicationContext.xml file
   private MyShopDbDao myShopDbDaoImpl
   

What I am struggling with is the "Understanding" of EntityManagerFactory and EntityManager relationships along with how the transactions must be managed. I know that the following hierarchy is the main starting point to understand this:

1. Client talks to a controller.

2. Controller maps the request and gets the entitymanager to do queries and stuff to the database (either a test/local database with JUNIT test etc. or an actual SQL-type database).

What I do know is that transactions can be managed either manually (i.e. beginning, committing, and closing a session) or through Spring container (i.e. using bean defs in applicationContext.xml file). How can I get more information about the entitymanagers and entitymanagerfactory in order to setup my system?

I didn't find the online documentation from Oracle/Spring/Hibernate very helpful. I need an example and the explanation on the relationship between entitymanagerfactory, sessionfactory, entitymanager, and transactionmanager. Could someone please help me with this?

I don't need people to hold my hand, but just put me in a right direction. I have done Spring projects before, but never got to the bottom of some stuff. Any help is appreciated.

Answer 1

To be very very general:

• an entitymanagerfactory is an object responsible of the creation of the entitymanager and it comes from the JPA specifications.
• SessionFactory is the hibernate implementation of entitymanagerfactory
• session is the hibernate implementation of entitymanager
• A transacation manager is an object who manages transaction when you want to define a transaction manually.

So if you want to use hibernate, use SessionFactory and session. And if you want you to stay "generic" use the EntityManagerFactory.

http://www.javabeat.net/jpa-entitymanager-vs-hibernate-sessionfactory/ http://www.theserverside.com/tip/How-to-get-the-Hibernate-Session-from-the-JPA-20-EntityManager

Answer 2

EntityManagerFactory will obtain java.sql.Connection objects, through opening/closing new physical connections to the database or using a connection pool (c3p0, bonecp, hikari or whatever implementation you like). After obtaining a Connection, it will use it to create a new EntityManager. The EntityManager can interact with your objects and your database using this Connection and can manage the transaction through calling EntityManager#getTransaction and then calling EntityTransaction#begin, EntityTransaction#commit and EntityTransaction#rollback that internally works with Connection#begin, Connection#commit and Connection#rollback respectively. This is plain vanilla JPA and Spring has nothing to do up to this point.

For transaction management, Spring helps you to avoid opening/closing the transactions manually by using a transaction manager, specifically a class called JpaTransactionManager. This transaction manager will make use of your EntityManagerFactory to open and close a transaction for the EntityManager created for a set of operations. This can be done either using XML configuration or @Transactional annotation on your classes/methods. When using this approach, you won't directly work with your specific classes anymore, instead Spring will create proxies for your classes using cglib and make use of the transaction manager class to open the transaction, call your specific method(s) and execute a commit or rollback at the end, depending on your configuration. Apart of this, Spring provides other configurations like read-only transactions (no data modification operation allowed).

Here's a basic configuration of the elements explained above using Spring/Hibernate/JPA:

<!--
    Declare the datasource.
    Look for your datasource provider like c3p0 or HikariCP.
    Using most basic parameters. It's up to you to tune this config.
-->
<bean id="jpaDataSource"
    class="..."
    destroy-method="close"
    driverClass="${app.jdbc.driverClassName}"
    jdbcUrl="${app.jdbc.url}"
    user="${app.jdbc.username}"
    password="${app.jdbc.password}" />

<!--
    Specify the ORM vendor. This is, the framework implementing JPA.
-->
<bean id="hibernateVendor"
    class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"
    showSql="false"/>

<!--
    Declare the JPA EntityManagerFactory.
    Spring provides a class implementation for it.
-->
<bean id="entityManagerFactory"
    class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
    persistenceXmlLocation="classpath*:META-INF/persistence.xml"
    persistenceUnitName="hibernatePersistenceUnit"
    dataSource-ref="jpaDataSource"
    jpaVendorAdapter-ref="hibernateVendor"/>

<!--
    Declare a transaction manager.
    Spring uses the transaction manager on top of EntityManagerFactory.
-->
<bean id="transactionManager"
    class="org.springframework.orm.jpa.JpaTransactionManager"
    entityManagerFactory-ref="entityManagerFactory"/>

Answer 3

From what i see, your em reference should be a functioning proxy object to your database (this EntityManager is the thing that should be a spring bean, having configured everything, like DB url, driver, etc. Apart from this none of your code should depend on what DB you have). You don't need to know about the classes you mention (entitymanagerfactory sessionfactory transactionmanager). Easy example is:

List<MyBean> bean = (List<MyBean>)em.createNamedQuery("select * from mydb").getResultList();

It should be this easy to run a select * query and get your MyBean typed objects straight ahead, without any explicit conversion by you (this is what hibernate is for).

Similar for insert:

em.persist(myBean);

where myBean is something annotated for Hibernate.

Briefly about transactions, i found best to annotate @Transactional on service METHODS (you did it on a whole dao).