Free download of spring orm hibernate jar file

Welcome to the Spring ORM Example Tutorial. Today we will look into Spring ORM example using Hibernate JPA transaction management. I will show you a very simple example of Spring standalone application with following features.

• Dependency Injection (@Autowired annotation)
• JPA EntityManager (provided by Hibernate)
• Annotated transactional methods (@Transactional annotation)

Spring ORM Example

I have used in-memory database for Spring ORM example, so no need for any database setup (but you can change it to any other database in the rushbrookrathbone.co.uk datasource section). This is a Spring ORM standalone application to minimize all dependencies (but you can easily change it to a web project by configuration if you get familiar with spring).

NOTE: For Spring AOP based Transactional (without @Transactional annotation) method resolution approach please check this tutorial: Spring ORM AOP Transaction Management.

Below image shows our final Spring ORM example project.

Let&#;s go through each of the Spring ORM example project components one by one.

Spring ORM Maven dependencies

Below is our final rushbrookrathbone.co.uk file having Spring ORM dependencies. We have used Spring 4 and Hibernate 4 in our Spring ORM example.

• We need and as Spring dependencies.
• We use for Hibernate as JPA implementation. is dependent on this why we don&#;t have to put hibernate-core in rushbrookrathbone.co.uk explicitly. It&#;s being pulled into our project through maven transitive dependencies.
• We also need JDBC driver as dependency for database access. We are using HSQLDB that contains the JDBC driver and a working in memory database.

Spring ORM Model Class

We can use standard JPA annotations for mapping in our model beans because Hibernate provides JPA implementation.

We use and JPA annotations to qualify our POJO as an Entity and to define it&#;s primary key.

Spring ORM DAO Class

We create a very simple DAO class that provides persist and findALL methods.

• @Component is Spring annotation that tell the Spring container that we can use this class through Spring IoC (Dependency Injection).
• We use JPA annotation that indicate dependency injection to an EntityManager. Spring injects a proper instance of EntityManager according to the rushbrookrathbone.co.uk configuration.

Spring ORM Service Class

Our simple service class has 2 write and 1 read methods &#; add, addAll and listAll.

• We use Spring @Autowired annotation to inject ProductDao in our service class.
• We want to use transaction management, so methods are annotated with Spring annotation. The listAll method only reads the database so we set the @Transactional annotation to read-only for optimisation.

Spring ORM Example Bean Configuration XML

Our spring ORM example project java classes are ready, let&#;s look at our spring bean configuration file now.

1. First we tell spring that we want to use classpath scanning for Spring components (Services, DAOs) rather than defining them one by one in spring xml. We have also enabled Spring annotation detection.
2. Adding the datasource, that is currently HSQLDB in-memory database.
3. We set up a JPA that will used by the application to obtain an EntityManager. Spring supports 3 different ways to do this, we have used for full JPA capabilities.

   We set attributes as:

   1. packagesToScan attribute that points to our model classes package.
   2. datasource defined earlier in spring configuration file.
   3. jpaVendorAdapter as Hibernate and setting some hibernate properties.
4. We create Spring PlatformTransactionManager instance as a JpaTransactionManager. This transaction manager is appropriate for applications that use a single JPA EntityManagerFactory for transactional data access.
5. We enable the configuration of transactional behavior based on annotations, and we set the transactionManager we created.

Spring ORM Hibernate JPA Example Test Program

Our spring ORM JPA Hibernate example project is ready, so let&#;s write a test program for our application.

You can see how easily we can start the Spring container from a main method. We are getting our first dependency injected entry point, the service class instance. class reference injected to the class after the spring context is initialized.

After we got instance, we can test it&#;s methods, all method call will be transactional due to Spring&#;s proxy mechanism. We also test rollback in this example.

If you run above spring ORM example test program, you will get below logs.

Note that the second transaction is rolled back, this why product list didn&#;t changed.

If you use file from attached source, you can see what&#;s going on under the hood.

References:
rushbrookrathbone.co.uk

You can download the final Spring ORM JPA Hibernate Example project from below link and play around with it to learn more.