Programming Tutorials

Tutorial Using the Java Persistence API (JPA) in Hibernate

By: Felix in Hibernate Tutorials on 2022-12-28  

The Java Persistence API (JPA) is a standard API for accessing relational databases from Java applications. Hibernate is one of the most popular implementations of JPA. Here are the basic steps to use JPA in Hibernate:

1. Define your entity classes: Entity classes represent your database tables. Annotate the class with @Entity and annotate the fields with the corresponding JPA annotations (@Id, @Column, etc.) to map them to the table columns.

2. Create a persistence.xml file: This file defines the persistence unit, which is a group of related entity classes and their configuration settings. It also specifies the database connection details and the JPA provider (in this case, Hibernate).

3. Create an EntityManagerFactory: The EntityManagerFactory is responsible for creating EntityManager instances, which are used to interact with the database.

4. Begin a transaction: Transactions are used to group a set of database operations together. Begin a transaction using the EntityManager.

5. Perform database operations: Use the EntityManager to perform CRUD (Create, Read, Update, Delete) operations on your entity objects.

6. Commit the transaction: If all database operations succeed, commit the transaction. If any operation fails, roll back the transaction.

7. Close the EntityManager and EntityManagerFactory: When you are done with the database operations, close the EntityManager and EntityManagerFactory.

Here's a sample code snippet that demonstrates the basic usage of JPA in Hibernate:

EntityManagerFactory emf = Persistence.createEntityManagerFactory("my-persistence-unit");
EntityManager em = emf.createEntityManager();

try {
    // Begin transaction
    em.getTransaction().begin();

    // Perform database operations
    MyEntity entity = new MyEntity();
    entity.setName("John Doe");
    em.persist(entity);

    // Commit transaction
    em.getTransaction().commit();
} catch (Exception e) {
    // Roll back transaction on error
    em.getTransaction().rollback();
} finally {
    // Close EntityManager and EntityManagerFactory
    em.close();
    emf.close();
}

In this example, MyEntity is an entity class that is mapped to a database table. The EntityManagerFactory is created with the name of the persistence unit ("my-persistence-unit"), which is defined in the persistence.xml file. The EntityManager is then created from the EntityManagerFactory.

The em.getTransaction().begin() method starts a transaction. The em.persist(entity) method adds a new entity object to the database. The em.getTransaction().commit() method commits the transaction. If any exception occurs during the transaction, the catch block rolls back the transaction.

Finally, the em.close() method closes the EntityManager, and the emf.close() method closes the EntityManagerFactory.