JPA Interfaces explained with code samples

In my earlier article, we had learnt how to create a basic JPA application.  In this article, I will be explaining the important JPA interfaces.

Persistence Unit

As seen earlier, we need to create a configuration file called persistence.xml that contains the database configuration details as follows:

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence             http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"             version="2.1">    <persistence-unit name="PERSISTENCE">        <description>JPA Demo</description>        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>        <properties>            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLInnoDBDialect"/>            <property name="javax.persistence.jdbc.driver"                      value="com.mysql.jdbc.Driver"/>            <property name="javax.persistence.jdbc.url"                      value="jdbc:mysql://localhost/jpademo"/>            <property name="javax.persistence.jdbc.user" value="user"/>            <property name="javax.persistence.jdbc.password" value="password"/>        </properties>    </persistence-unit></persistence>

 

The persistence.xml file specifies a persistence unit. A persistence unit encapsulates database details. So, it includes the JPA Provider, mapping information & database configuration details. The persistence.xml file above specifies a persistence unit PERSISTENCE. It specifies Hibernate as the persistence provider and includes various other database connection details.  JPA uses the information in the persistence unit to configure the database connection. If your application uses multiple databases, you need to create a separate persistence unit corresponding to each database.

Entity

An Entity is a simple POJO class that corresponds to a database table. It needs to have fields corresponding to the database table columns. Earlier, we had created a Fruit entity class as follows:

@Entitypublic class Fruit { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private int id; private String name; private String colour; private int calories; //getters and setters}

The Fruit class has the @Entity annotation. This designates the Fruit class as a JPA entity. So, this class corresponds to a Fruit table having columns corresponding to name, colour and calories.  Each object of the Fruit class corresponds to a record in the Fruit table.

JPA Interfaces

Just to recap, we had written the following JPA Code:

 @Test public void testSave() {  EntityManagerFactory emf = Persistence.createEntityManagerFactory("PERSISTENCE");  EntityManager em = emf.createEntityManager();  EntityTransaction et = em.getTransaction();  et.begin();  Fruit apple = new Fruit();  apple.setName("apple");  apple.setColour("red");  apple.setCalories(5);  em.persist(apple);  et.commit();  System.out.println("Fruit record saved successfully");  em.close();  emf.close();}    @Test  public void testQuery() {    EntityManagerFactory emf = Persistence.createEntityManagerFactory("PERSISTENCE");    EntityManager em = emf.createEntityManager();    TypedQuery<Fruit> query = em.createQuery("from Fruit",Fruit.class);    List<Fruit> fruits = query.getResultList();    System.out.println("Fruit table has "+fruits.size()+" records");  }}

Let us now break down this code.

EntityManagerFactory

EntityManagerFactory is an in-built JPA interface. It can be created via the Persistence class by specifying the name of the persistence unit from the persistence.xml file. The code above creates an EntityManagerFactory emf by referring to the PERSISTENCE persistence unit. An EntityManagerFactory is specific to a database. So, if you’d like to connect to a different database, you need to create a different EntityManagerFactory instance. An EntityManagerFactory can be used to created EntityManager instances.

EntityManager

EntityManager is also an in-built JPA interface. It can be created via an EntityManagerFactory instance. The code above creates an EntityManager instance em via the EntityManagerFactory instance emf.  An EntityManager represents a database connection.  You can use it to perform database operations like insert/update/delete or to query a table. The code above invokes the persist method to save a Fruit record into the Fruit table.

EntityTransaction

EntityTransaction is also an in-built JPA interface. It can be created via an EntityManager.  The code above creates an EntityTransaction instance et via the EntityManager instance em.  An EntityTransaction encapsulates a database transaction. A call to the begin method starts the transaction and a call to commit saves the changes in the database.

Query

Query is also an in-built JPA interface. It can be created via an EntityManager.  The code above creates a TypedQuery (which is a sub-interface of Query) instance query via the EntityManager instance em.  You can use Query to execute a database query. The code above uses query to obtain all the Fruit records. The Query interface has methods that to retrieve the query execution results. The code above uses the query.getResultList. This returns a List of Fruit objects.

Further Learning

Master JPA and Hibernate with Spring Boot
Spring Data JPA with Hibernate
Hibernate and JPA Fundamentals

Conclusion

So, in this class, we learnt about about persistence unit and entities. We also took a look at the important JPA interfaces like EntityManagerFactory, EntityManager, EntityTransaction and Query.

Comments

Post a Comment

Popular posts from this blog

How to use logging in SpringBoot with code samples

Image
In this article, we will learn how to use logging in SpringBoot. Introduction There are several Java logging frameworks like logback, log4j, and so on. Spring Boot supports out-of-the-box support for logback. Let us learn how to use logging in SpringBoot with logback. Step 1 – Create a New Maven Project Create a new Maven project. (Refer to  this  blog post). This will create a project in Eclipse as follows:   Step 2 – Add the Spring Boot Dependencies Add the spring-boot-starter-web dependency to the pom.xml . So, the pom.xml should look as follows: <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.learnjava</groupId> <artifactId>learnjava-springboot-logging-example</artifactId> <version>0.0.1-SNAPSHOT&
Read more

Python While Loop with code samples

Much like a Java while loop, you can use a Python while loop to repeatedly execute a block of code as long as a condition is true. In this article, we will learn more about the Python while loop. Python While loop Syntax A while loop in Python has the following syntax: while <condition>: loop body The while keyword is followed by a condition. If the condition evaluates to true, the body of the loop is executed. Once the body of the loop is completed, the condition is checked again and this is repeated until the condition evaluates to false at which point the loop is exited. While loop Sample Code The following code demonstrates how you can use the while loop: num=10counter=1total=0while counter<=num: total += counter counter+=1print("sum of first 10 numbers is",total) This code adds the numbers from 1 to 10 and prints the sum. It uses a while loop to iterate from 1 to 10. The while loop checks the condition counter <= num and if so adds the current value of count
Read more

How to convert a List to a Set

In this blog post ,I will be showing you how you can convert a List to a Set. Consider the following code snippet: public class ListToSetDemo {public static void main(String[] args) {List<Integer> list = Arrays.asList(5,3,11,15,9);//Method 1Set<Integer> set = new HashSet<Integer>(list);System.out.println("Set is "+set);//method 2Set<Integer> set2 = new HashSet<Integer>();set2.addAll(list);System.out.println("Set is "+set2);}} This code demonstrates two ways to convert a List to a Set. Method 1 Here, we are creating a new HashSet . We are invoking the constructor that accepts a Collection object. Here, we are passing in the input list to this constructor.   Method 2 Here again, we are creating a new HashSet . However, we are using the default constructor. We are then invoking the addAll method and passing in the input list.   When you run this code, it will print the following output: Set is [3, 5, 9, 11, 15]Set is [3, 5, 9, 11, 15] No
Read more