Spring Data JPA Tutorial

Spring Data JPA API gives JpaTemplate class to incorporate spring application with JPA. JPA (Java Persistent API) is the sun particular for continuing items in the undertaking application. It is presently utilized as the swap for complex element beans.

The implementation of JPA specification are provided by many vendors such as:

  • Hibernate
  • Toplink
  • iBatis
  • OpenJPA etc.

Advantage of Spring JpaTemplate

You don't have to compose the previously, then after the fact code for continuing, redesigning, erasing or seeking protest, for example, making Persistence occasion, making EntityManagerFactory occurrence, making EntityTransaction case, making EntityManager case, commiting EntityTransaction case and shutting EntityManager.

Along these lines, it spare a ton of code. In this case, we are going to utilize rest for the execution of JPA.


In this example, we are use hibernate for the implementation of JPA.


Example of Spring and JPA Integration

Let's see the simple steps to integration spring application with JPA:

  1. create Account.java file
  2. create Account.xml file
  3. create AccountDao.java file
  4. create persistence.xml file
  5. create applicationContext.xml file
  6. create AccountsClient.java file

In this example, we are going to integrate the hibernate application with spring. Let's see the directory structure of jpa example with spring.

1) Account.java

It is a simple POJO class.

package com.javatportal;

public class Account {
	private int accountNumber;
	private String owner;
	private double balance;
        //no-arg and parameterized constructor
        //getters and setters
}

2- Account.xml

This mapping file contains all the information of the persistent class.

<entity-mappings version="1.0" 
		xmlns="http://java.sun.com/xml/ns/persistence/orm" 
		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
		xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm 
		http://java.sun.com/xml/ns/persistence/orm_1_0.xsd ">
	
	<entity class="com.javatportal.Account">
		<table name="account100"></table>
		<attributes>
			<id name="accountNumber">
				<column name="accountnumber"/>
			</id>
			<basic name="owner">
				<column name="owner"/>
			</basic>
			<basic name="balance">
				<column name="balance"/>
			</basic>
		</attributes>
	</entity>
</entity-mappings>

3- AccountDao.java
package com.javatportal;
import java.util.List;
import org.springframework.orm.jpa.JpaTemplate;
import org.springframework.transaction.annotation.Transactional;
@Transactional
public class AccountsDao{
	JpaTemplate template;

	public void setTemplate(JpaTemplate template) {
		this.template = template;
	}
	public void createAccount(int accountNumber,String owner,double balance){
		Account account = new Account(accountNumber,owner,balance);
		template.persist(account);
	}
	public void updateBalance(int accountNumber,double newBalance){
		Account account = template.find(Account.class, accountNumber);
		if(account != null){
			account.setBalance(newBalance);
		}
		template.merge(account);
	}
	public void deleteAccount(int accountNumber){
		Account account = template.find(Account.class, accountNumber);
		if(account != null)
			template.remove(account);
	}
	public List <Account> getAllAccounts(){
		List<Account> accounts =template.find("select acc from Account acc");
		return accounts;
	}
}

4- persistence.xml
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
    http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0">
    
	<persistence-unit name="ForAccountsDB">
		<mapping-file>com/javatportal/Account.xml</mapping-file>
		<class>com.javatportal.Account</class>
	</persistence-unit>
</persistence>

5- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:tx="http://www.springframework.org/schema/tx" 
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
	
 	 <tx:annotation-driven transaction-manager="jpaTxnManagerBean" proxy-target-class="true"/>
	
	 <bean id="dataSourceBean" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"></property>
		<property name="url" value="jdbc:oracle:thin:@localhost:1521:xe"></property>
		<property name="username" value="system"></property>
		<property name="password" value="oracle"></property>
	</bean>
	 	 
 	  <bean id="hbAdapterBean" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
	 	<property name="showSql" value="true"></property>
	 	<property name="generateDdl" value="true"></property>
	 	<property name="databasePlatform" value="org.hibernate.dialect.OracleDialect"></property>
	 </bean>
	
	<bean id="emfBean" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
	 	<property name="dataSource" ref="dataSourceBean"></property>
	 	<property name="jpaVendorAdapter" ref="hbAdapterBean"></property>
	 </bean>
	 
	 <bean id="jpaTemplateBean" class="org.springframework.orm.jpa.JpaTemplate">
 	 	<property name="entityManagerFactory" ref="emfBean"></property>
 	 </bean>
 	 
 	 <bean id="accountsDaoBean" class="com.javatportal.AccountsDao">
 	 	<property name="template" ref="jpaTemplateBean"></property>
 	 </bean>
 	  <bean id="jpaTxnManagerBean" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="emfBean"></property>
	</bean>
 	 	
</beans>

The generateDdl property will create the table automatically.

The showSql property will show the sql query on console.


6- Accountsclient.java
package com.javatportal;

import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class AccountsClient{
public static void main(String[] args){
 ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
 AccountsDao accountsDao = context.getBean("accountsDaoBean",AccountsDao.class);
		
 accountsDao.createAccount(15, "Mithilesh", 41000);
 accountsDao.createAccount(20, "Rahul ", 35000);
 System.out.println("Accounts created");
		
 //accountsDao.updateBalance(20, 50000);
 //System.out.println("Account balance updated");
		
		
 /*List<Account> accounts = accountsDao.getAllAccounts();
 for (int i = 0; i < accounts.size(); i++) {
   Account acc = accounts.get(i);
   System.out.println(acc.getAccountNumber() + " : " + acc.getOwner() + " (" + acc.getBalance() + ")");
 }*/
		
  //accountsDao.deleteAccount(111);
  //System.out.println("Account deleted");
		
 }
}

Output

Hibernate: insert into account100 (balance, owner, accountnumber) values (?, ?, ?)
Hibernate: insert into account100 (balance, owner, accountnumber) values (?, ?, ?)
Accounts created