JPA CRUD Operations Example with EntityManager - Create, Read, Update and Delete Operations Example

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

✅ Some premium posts are free to read — no account needed. Follow me on Medium to stay updated and support my writing.

🎓 Top 10 Udemy Courses (Huge Discount): Explore My Udemy Courses — Learn through real-time, project-based development.

▶️ Subscribe to My YouTube Channel (172K+ subscribers): Java Guides on YouTube

Introduction

Java Persistence API (JPA) is a specification for managing relational data in Java applications. It provides a standard way to manage persistence and object-relational mapping (ORM) in Java. In this tutorial, we will demonstrate how to perform basic CRUD (Create, Read, Update, and Delete) operations using JPA with Hibernate implementation and EntityManager.

Prerequisites

Before we start, ensure you have the following:

• Java Development Kit (JDK) installed
• Apache Maven installed
• MySQL database installed and running (or any other relational database)
• An IDE (such as IntelliJ IDEA, Eclipse, or VS Code) installed

Step 1: Setting Up the JPA Project

1.1 Create a Maven Project

1. Open your IDE and create a new Maven project.

2. Configure the pom.xml file with the following content:

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>jpa-hibernate-crud</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- JPA and Hibernate -->
        <dependency>
            <groupId>org.hibernate.orm</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>6.4.0.Final</version>
        </dependency>
        <dependency>
            <groupId>jakarta.persistence</groupId>
            <artifactId>jakarta.persistence-api</artifactId>
            <version>3.1.0</version>
        </dependency>

        <!-- MySQL Connector -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>

        <!-- SLF4J for logging -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.32</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.32</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>17</source>
                    <target>17</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

1.2 Configure Hibernate

Create a persistence.xml file in the src/main/resources/META-INF directory with the following content:

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="https://jakarta.ee/xml/ns/persistence" version="3.0">
    <persistence-unit name="PERSISTENCE">
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <class>com.example.jpa.hibernate.crud.model.Employee</class>
        <properties>
            <property name="jakarta.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/your_database_name"/>
            <property name="jakarta.persistence.jdbc.user" value="your_username"/>
            <property name="jakarta.persistence.jdbc.password" value="your_password"/>
            <property name="jakarta.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.format_sql" value="true"/>
        </properties>
    </persistence-unit>
</persistence>

Replace your_database_name, your_username, and your_password with your MySQL database credentials.

Step 2: Creating the Entity Class

Create an Employee class in the com.example.jpa.hibernate.crud.model package:

package com.example.jpa.hibernate.crud.model;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String department;
    private double salary;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

Step 3: Creating the DAO Class

Create a DAO class to manage CRUD operations in the com.example.jpa.hibernate.crud.dao package:

package com.example.jpa.hibernate.crud.dao;

import com.example.jpa.hibernate.crud.model.Employee;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.TypedQuery;
import java.util.List;

public class EmployeeDao {

    private EntityManagerFactory emf = Persistence.createEntityManagerFactory("PERSISTENCE");

    public void saveEmployee(Employee employee) {
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();
        em.persist(employee);
        em.getTransaction().commit();
        em.close();
    }

    public void updateEmployee(Employee employee) {
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();
        em.merge(employee);
        em.getTransaction().commit();
        em.close();
    }

    public Employee getEmployeeById(Long id) {
        EntityManager em = emf.createEntityManager();
        Employee employee = em.find(Employee.class, id);
        em.close();
        return employee;
    }

    public List<Employee> getAllEmployees() {
        EntityManager em = emf.createEntityManager();
        TypedQuery<Employee> query = em.createQuery("SELECT e FROM Employee e", Employee.class);
        List<Employee> employees = query.getResultList();
        em.close();
        return employees;
    }

    public void deleteEmployee(Long id) {
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();
        Employee employee = em.find(Employee.class, id);
        if (employee != null) {
            em.remove(employee);
        }
        em.getTransaction().commit();
        em.close();
    }
}

Step 4: Creating the Main Class

Create a Main class in the com.example.jpa.hibernate.crud package to test the CRUD operations:

package com.example.jpa.hibernate.crud;

import com.example.jpa.hibernate.crud.dao.EmployeeDao;
import com.example.jpa.hibernate.crud.model.Employee;

import java.util.List;

public class Main {
    public static void main(String[] args) {
        EmployeeDao employeeDao = new EmployeeDao();

        // Create and save a new employee
        Employee employee = new Employee();
        employee.setName("John Doe");
        employee.setDepartment("IT");
        employee.setSalary(60000);
        employeeDao.saveEmployee(employee);
        System.out.println("Employee saved.");

        // Fetch and print all employees
        List<Employee> employees = employeeDao.getAllEmployees();
        employees.forEach(emp -> System.out.println(emp.getName() + " - " + emp.getDepartment() + " - " + emp.getSalary()));

        // Update an employee
        employee.setSalary(70000);
        employeeDao.updateEmployee(employee);
        System.out.println("Employee updated.");

        // Fetch and print the updated employee
        Employee updatedEmployee = employeeDao.getEmployeeById(employee.getId());
        System.out.println("Updated Employee: " + updatedEmployee.getName() + " - " + updatedEmployee.getDepartment() + " - " + updatedEmployee.getSalary());

        // Delete an employee
        employeeDao.deleteEmployee(updatedEmployee.getId());
        System.out.println("Employee deleted.");
    }
}

Conclusion

In this tutorial, we demonstrated how to perform basic CRUD operations using JPA with Hibernate as the JPA provider and EntityManager for transaction management. We configured the project with Maven, set up Hibernate and JPA, created an entity class, a DAO class, and a main class to test the CRUD operations. By following these steps, you can effectively manage data persistence in your Java applications using JPA and Hibernate.