JPA CRUD — One Complete Project

Complete Layered Architecture

This is the same style of architecture as the reference image, but generated entirely from Mermaid code and rendered as an SVG diagram in the browser.

How a JPA Program Starts

EntityManagerFactory emf =
    Persistence.createEntityManagerFactory("employeePU");

EntityManager em =
    emf.createEntityManager();

Java Entity → Database Table

@Entity
@Table(name = "employee")
public class Employee {

    @Id
    @Column(name = "employee_id")
    private int employeeId;

    @Column(name = "employee_name")
    private String employeeName;

    @Column(name = "role")
    private String role;

    private double salary;

    @Temporal(TemporalType.DATE)
    private Date joiningDate;
}

Complete CRUD Flow

Persist Operation

em.getTransaction().begin();

em.persist(employee);

em.getTransaction().commit();

persist() does not mean "directly execute INSERT right now". It makes the entity managed; Hibernate synchronizes changes with the database when the persistence context is flushed, commonly at transaction commit.

Find Operation

Employee employee =
    em.find(Employee.class, 1);

JPQL Query

List<Employee> employees =
    em.createQuery(
        "SELECT e FROM Employee e",
        Employee.class
    ).getResultList();

JPQL talks about entities and their fields, not database tables directly.

Dirty Checking vs merge()

em.getTransaction().begin();

Employee e =
    em.find(Employee.class, 1);

e.setSalary(75000);

em.getTransaction().commit();

em.getTransaction().begin();

em.merge(employee);

em.getTransaction().commit();

Remove Operation

em.getTransaction().begin();

Employee employee =
    em.find(Employee.class, id);

if (employee != null) {
    em.remove(employee);
}

em.getTransaction().commit();

Entity Life Cycle

DTO and Entity Flow

Transaction Flow

try {

    em.getTransaction().begin();

    em.persist(employee);

    em.getTransaction().commit();

} catch (Exception e) {

    if (em.getTransaction().isActive()) {
        em.getTransaction().rollback();
    }

    throw e;

} finally {

    em.close();
}

Who Does What?

What Actually Happens During a Create?

How the Files Connect

Every File — persistence.xml → UI Tester

This is the complete runnable version of the same Employee CRUD project. The code is intentionally kept in the same order in which the application is understood: Maven → persistence.xml → Entity → DTO → Utility → DAO → Service → UI Tester.

1. Project Structure

EmployeeManagement/
│
├── pom.xml
│
└── src/
    └── main/
        ├── java/
        │   └── com/example/
        │       ├── entity/
        │       │   └── EmployeeEntity.java
        │       │
        │       ├── dto/
        │       │   └── EmployeeDTO.java
        │       │
        │       ├── dao/
        │       │   ├── EmployeeDAO.java
        │       │   └── EmployeeDAOImpl.java
        │       │
        │       ├── service/
        │       │   ├── EmployeeService.java
        │       │   └── EmployeeServiceImpl.java
        │       │
        │       └── utility/
        │           ├── JPAUtility.java
        │           └── Factory.java
        │
        │       └── UITester.java
        │
        └── resources/
            └── META-INF/
                └── persistence.xml

2. Database SQL

CREATE DATABASE employee_db;

USE employee_db;

CREATE TABLE employee (
    employee_id INT PRIMARY KEY,
    employee_name VARCHAR(100) NOT NULL,
    role VARCHAR(100),
    salary DOUBLE,
    joining_date DATE
);

3. pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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.example</groupId>
    <artifactId>EmployeeManagement</artifactId>
    <version>1.0</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>

        <!-- JPA API -->
        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>javax.persistence-api</artifactId>
            <version>2.2</version>
        </dependency>

        <!-- Hibernate JPA implementation -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.6.15.Final</version>
        </dependency>

        <!-- MySQL JDBC Driver -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>

    </dependencies>

</project>

4. persistence.xml

Location: src/main/resources/META-INF/persistence.xml

<?xml version="1.0" encoding="UTF-8"?>

<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_2.xsd"
    version="2.2">

    <persistence-unit name="employeePU">

        <provider>
            org.hibernate.jpa.HibernatePersistenceProvider
        </provider>

        <class>com.example.entity.EmployeeEntity</class>

        <properties>

            <property
                name="javax.persistence.jdbc.driver"
                value="com.mysql.cj.jdbc.Driver"/>

            <property
                name="javax.persistence.jdbc.url"
                value="jdbc:mysql://localhost:3306/employee_db"/>

            <property
                name="javax.persistence.jdbc.user"
                value="root"/>

            <property
                name="javax.persistence.jdbc.password"
                value="root"/>

            <property
                name="hibernate.dialect"
                value="org.hibernate.dialect.MySQL8Dialect"/>

            <property
                name="hibernate.show_sql"
                value="true"/>

            <property
                name="hibernate.format_sql"
                value="true"/>

        </properties>

    </persistence-unit>

</persistence>

5. EmployeeEntity.java

package com.example.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

import java.util.Date;

@Entity
@Table(name = "employee")
public class EmployeeEntity {

    @Id
    @Column(name = "employee_id")
    private int employeeId;

    @Column(name = "employee_name")
    private String employeeName;

    @Column(name = "role")
    private String role;

    @Column(name = "salary")
    private double salary;

    @Temporal(TemporalType.DATE)
    @Column(name = "joining_date")
    private Date joiningDate;

    public EmployeeEntity() {
    }

    public EmployeeEntity(
            int employeeId,
            String employeeName,
            String role,
            double salary,
            Date joiningDate) {

        this.employeeId = employeeId;
        this.employeeName = employeeName;
        this.role = role;
        this.salary = salary;
        this.joiningDate = joiningDate;
    }

    public int getEmployeeId() {
        return employeeId;
    }

    public void setEmployeeId(int employeeId) {
        this.employeeId = employeeId;
    }

    public String getEmployeeName() {
        return employeeName;
    }

    public void setEmployeeName(String employeeName) {
        this.employeeName = employeeName;
    }

    public String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }

    public double getSalary() {
        return salary;
    }

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

    public Date getJoiningDate() {
        return joiningDate;
    }

    public void setJoiningDate(Date joiningDate) {
        this.joiningDate = joiningDate;
    }

    @Override
    public String toString() {
        return "EmployeeEntity{" +
                "employeeId=" + employeeId +
                ", employeeName='" + employeeName + '\'' +
                ", role='" + role + '\'' +
                ", salary=" + salary +
                ", joiningDate=" + joiningDate +
                '}';
    }
}

6. EmployeeDTO.java

package com.example.dto;

import java.util.Date;

public class EmployeeDTO {

    private int employeeId;
    private String employeeName;
    private String role;
    private double salary;
    private Date joiningDate;

    public EmployeeDTO() {
    }

    public EmployeeDTO(
            int employeeId,
            String employeeName,
            String role,
            double salary,
            Date joiningDate) {

        this.employeeId = employeeId;
        this.employeeName = employeeName;
        this.role = role;
        this.salary = salary;
        this.joiningDate = joiningDate;
    }

    public int getEmployeeId() {
        return employeeId;
    }

    public void setEmployeeId(int employeeId) {
        this.employeeId = employeeId;
    }

    public String getEmployeeName() {
        return employeeName;
    }

    public void setEmployeeName(String employeeName) {
        this.employeeName = employeeName;
    }

    public String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }

    public double getSalary() {
        return salary;
    }

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

    public Date getJoiningDate() {
        return joiningDate;
    }

    public void setJoiningDate(Date joiningDate) {
        this.joiningDate = joiningDate;
    }

    @Override
    public String toString() {
        return "EmployeeDTO{" +
                "employeeId=" + employeeId +
                ", employeeName='" + employeeName + '\'' +
                ", role='" + role + '\'' +
                ", salary=" + salary +
                ", joiningDate=" + joiningDate +
                '}';
    }
}

7. JPAUtility.java

This class centralizes the EntityManagerFactory and EntityManager creation.

package com.example.utility;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public final class JPAUtility {

    private static final EntityManagerFactory EMF =
            Persistence.createEntityManagerFactory("employeePU");

    private JPAUtility() {
        // Utility class - do not create objects.
    }

    public static EntityManager getEntityManager() {
        return EMF.createEntityManager();
    }

    public static EntityManagerFactory getEntityManagerFactory() {
        return EMF;
    }

    public static void close() {
        if (EMF.isOpen()) {
            EMF.close();
        }
    }
}

8. Factory.java

The Factory hides DAO implementation creation from the Service layer.

package com.example.utility;

import com.example.dao.EmployeeDAO;
import com.example.dao.EmployeeDAOImpl;

public final class Factory {

    private Factory() {
        // Utility class - do not create objects.
    }

    public static EmployeeDAO getEmployeeDAO() {
        return new EmployeeDAOImpl();
    }
}

9. EmployeeDAO.java

package com.example.dao;

import com.example.entity.EmployeeEntity;

import java.util.List;

public interface EmployeeDAO {

    void save(EmployeeEntity employee);

    EmployeeEntity findById(int id);

    List<EmployeeEntity> findAll();

    void update(EmployeeEntity employee);

    void delete(int id);
}

10. EmployeeDAOImpl.java — Complete CRUD

package com.example.dao;

import com.example.entity.EmployeeEntity;
import com.example.utility.JPAUtility;

import javax.persistence.EntityManager;
import java.util.List;

public class EmployeeDAOImpl implements EmployeeDAO {

    @Override
    public void save(EmployeeEntity employee) {

        EntityManager em =
                JPAUtility.getEntityManager();

        try {
            em.getTransaction().begin();

            em.persist(employee);

            em.getTransaction().commit();

        } catch (RuntimeException e) {

            if (em.getTransaction().isActive()) {
                em.getTransaction().rollback();
            }

            throw e;

        } finally {
            em.close();
        }
    }

    @Override
    public EmployeeEntity findById(int id) {

        EntityManager em =
                JPAUtility.getEntityManager();

        try {
            return em.find(EmployeeEntity.class, id);

        } finally {
            em.close();
        }
    }

    @Override
    public List<EmployeeEntity> findAll() {

        EntityManager em =
                JPAUtility.getEntityManager();

        try {
            return em.createQuery(
                    "SELECT e FROM EmployeeEntity e",
                    EmployeeEntity.class
            ).getResultList();

        } finally {
            em.close();
        }
    }

    @Override
    public void update(EmployeeEntity employee) {

        EntityManager em =
                JPAUtility.getEntityManager();

        try {
            em.getTransaction().begin();

            em.merge(employee);

            em.getTransaction().commit();

        } catch (RuntimeException e) {

            if (em.getTransaction().isActive()) {
                em.getTransaction().rollback();
            }

            throw e;

        } finally {
            em.close();
        }
    }

    @Override
    public void delete(int id) {

        EntityManager em =
                JPAUtility.getEntityManager();

        try {
            em.getTransaction().begin();

            EmployeeEntity employee =
                    em.find(EmployeeEntity.class, id);

            if (employee != null) {
                em.remove(employee);
            }

            em.getTransaction().commit();

        } catch (RuntimeException e) {

            if (em.getTransaction().isActive()) {
                em.getTransaction().rollback();
            }

            throw e;

        } finally {
            em.close();
        }
    }
}

11. EmployeeService.java

package com.example.service;

import com.example.dto.EmployeeDTO;

import java.util.List;

public interface EmployeeService {

    void createEmployee(EmployeeDTO dto);

    EmployeeDTO getEmployee(int id);

    List<EmployeeDTO> getAllEmployees();

    void updateEmployee(EmployeeDTO dto);

    void deleteEmployee(int id);
}

12. EmployeeServiceImpl.java

package com.example.service;

import com.example.dao.EmployeeDAO;
import com.example.dto.EmployeeDTO;
import com.example.entity.EmployeeEntity;
import com.example.utility.Factory;

import java.util.ArrayList;
import java.util.List;

public class EmployeeServiceImpl
        implements EmployeeService {

    private final EmployeeDAO employeeDAO;

    public EmployeeServiceImpl() {

        employeeDAO =
                Factory.getEmployeeDAO();
    }

    @Override
    public void createEmployee(EmployeeDTO dto) {

        validate(dto);

        EmployeeEntity employee =
                toEntity(dto);

        employeeDAO.save(employee);
    }

    @Override
    public EmployeeDTO getEmployee(int id) {

        EmployeeEntity employee =
                employeeDAO.findById(id);

        if (employee == null) {
            return null;
        }

        return toDTO(employee);
    }

    @Override
    public List<EmployeeDTO> getAllEmployees() {

        List<EmployeeEntity> entities =
                employeeDAO.findAll();

        List<EmployeeDTO> result =
                new ArrayList<>();

        for (EmployeeEntity entity : entities) {
            result.add(toDTO(entity));
        }

        return result;
    }

    @Override
    public void updateEmployee(EmployeeDTO dto) {

        validate(dto);

        EmployeeEntity employee =
                toEntity(dto);

        employeeDAO.update(employee);
    }

    @Override
    public void deleteEmployee(int id) {

        EmployeeEntity employee =
                employeeDAO.findById(id);

        if (employee == null) {
            throw new IllegalArgumentException(
                    "Employee with ID " + id +
                    " does not exist."
            );
        }

        employeeDAO.delete(id);
    }

    private void validate(EmployeeDTO dto) {

        if (dto == null) {
            throw new IllegalArgumentException(
                    "Employee data cannot be null."
            );
        }

        if (dto.getEmployeeId() <= 0) {
            throw new IllegalArgumentException(
                    "Employee ID must be positive."
            );
        }

        if (dto.getEmployeeName() == null ||
                dto.getEmployeeName().trim().isEmpty()) {

            throw new IllegalArgumentException(
                    "Employee name is required."
            );
        }

        if (dto.getSalary() < 0) {
            throw new IllegalArgumentException(
                    "Salary cannot be negative."
            );
        }
    }

    private EmployeeEntity toEntity(
            EmployeeDTO dto) {

        return new EmployeeEntity(
                dto.getEmployeeId(),
                dto.getEmployeeName(),
                dto.getRole(),
                dto.getSalary(),
                dto.getJoiningDate()
        );
    }

    private EmployeeDTO toDTO(
            EmployeeEntity entity) {

        return new EmployeeDTO(
                entity.getEmployeeId(),
                entity.getEmployeeName(),
                entity.getRole(),
                entity.getSalary(),
                entity.getJoiningDate()
        );
    }
}

13. UITester.java — Complete CREATE / READ / UPDATE / DELETE

package com.example;

import com.example.dto.EmployeeDTO;
import com.example.service.EmployeeService;
import com.example.service.EmployeeServiceImpl;
import com.example.utility.JPAUtility;

import java.util.Date;
import java.util.List;

public class UITester {

    public static void main(String[] args) {

        EmployeeService service =
                new EmployeeServiceImpl();

        try {

            // =================================================
            // 1. CREATE
            // =================================================

            System.out.println(
                    "\\n========== CREATE =========="
            );

            EmployeeDTO employee =
                    new EmployeeDTO(
                            1001,
                            "Rahul",
                            "Java Developer",
                            50000.00,
                            new Date()
                    );

            service.createEmployee(employee);

            System.out.println(
                    "Employee created successfully!"
            );


            // =================================================
            // 2. READ ONE
            // =================================================

            System.out.println(
                    "\\n========== READ ONE =========="
            );

            EmployeeDTO found =
                    service.getEmployee(1001);

            if (found != null) {

                System.out.println(
                        "Employee found:"
                );

                System.out.println(found);

            } else {

                System.out.println(
                        "Employee not found."
                );
            }


            // =================================================
            // 3. READ ALL
            // =================================================

            System.out.println(
                    "\\n========== READ ALL =========="
            );

            List<EmployeeDTO> employees =
                    service.getAllEmployees();

            for (EmployeeDTO dto : employees) {
                System.out.println(dto);
            }


            // =================================================
            // 4. UPDATE
            // =================================================

            System.out.println(
                    "\\n========== UPDATE =========="
            );

            EmployeeDTO employeeToUpdate =
                    service.getEmployee(1001);

            if (employeeToUpdate != null) {

                employeeToUpdate.setSalary(
                        75000.00
                );

                employeeToUpdate.setRole(
                        "Senior Java Developer"
                );

                service.updateEmployee(
                        employeeToUpdate
                );

                System.out.println(
                        "Employee updated successfully!"
                );
            }


            // =================================================
            // 5. READ AFTER UPDATE
            // =================================================

            System.out.println(
                    "\\n========== READ AFTER UPDATE =========="
            );

            EmployeeDTO updated =
                    service.getEmployee(1001);

            System.out.println(updated);


            // =================================================
            // 6. DELETE
            // =================================================

            System.out.println(
                    "\\n========== DELETE =========="
            );

            service.deleteEmployee(1001);

            System.out.println(
                    "Employee deleted successfully!"
            );


            // =================================================
            // 7. VERIFY DELETE
            // =================================================

            System.out.println(
                    "\\n========== VERIFY DELETE =========="
            );

            EmployeeDTO deleted =
                    service.getEmployee(1001);

            if (deleted == null) {

                System.out.println(
                        "Employee does not exist anymore."
                );

            } else {

                System.out.println(
                        "Employee still exists: " +
                        deleted
                );
            }

        } catch (Exception e) {

            System.err.println(
                    "Operation failed: " +
                    e.getMessage()
            );

            e.printStackTrace();

        } finally {

            // Close the application-level
            // EntityManagerFactory.
            JPAUtility.close();
        }
    }
}

14. What the UI Tester actually triggers

15. Expected Console Output

========== CREATE ==========
Employee created successfully!

========== READ ONE ==========
Employee found:
EmployeeDTO{
    employeeId=1001,
    employeeName='Rahul',
    role='Java Developer',
    salary=50000.0,
    ...
}

========== READ ALL ==========
EmployeeDTO{
    employeeId=1001,
    employeeName='Rahul',
    role='Java Developer',
    salary=50000.0,
    ...
}

========== UPDATE ==========
Employee updated successfully!

========== READ AFTER UPDATE ==========
EmployeeDTO{
    employeeId=1001,
    employeeName='Rahul',
    role='Senior Java Developer',
    salary=75000.0,
    ...
}

========== DELETE ==========
Employee deleted successfully!

========== VERIFY DELETE ==========
Employee does not exist anymore.

One Place to See All CRUD Methods

public class EmployeeDAOImpl implements EmployeeDAO {

    private EntityManagerFactory emf;

    public EmployeeDAOImpl() {
        emf = Persistence
                .createEntityManagerFactory("employeePU");
    }

    // CREATE
    public void save(Employee employee) {

        EntityManager em = emf.createEntityManager();

        try {
            em.getTransaction().begin();

            em.persist(employee);

            em.getTransaction().commit();

        } catch (Exception e) {

            if (em.getTransaction().isActive()) {
                em.getTransaction().rollback();
            }

            throw e;

        } finally {
            em.close();
        }
    }

    // READ ONE
    public Employee findById(int id) {

        EntityManager em = emf.createEntityManager();

        try {
            return em.find(Employee.class, id);
        } finally {
            em.close();
        }
    }

    // READ ALL
    public List<Employee> findAll() {

        EntityManager em = emf.createEntityManager();

        try {
            return em.createQuery(
                    "SELECT e FROM Employee e",
                    Employee.class
            ).getResultList();

        } finally {
            em.close();
        }
    }

    // UPDATE
    public void update(Employee employee) {

        EntityManager em = emf.createEntityManager();

        try {
            em.getTransaction().begin();

            em.merge(employee);

            em.getTransaction().commit();

        } catch (Exception e) {

            if (em.getTransaction().isActive()) {
                em.getTransaction().rollback();
            }

            throw e;

        } finally {
            em.close();
        }
    }

    // DELETE
    public void delete(int id) {

        EntityManager em = emf.createEntityManager();

        try {
            em.getTransaction().begin();

            Employee employee =
                    em.find(Employee.class, id);

            if (employee != null) {
                em.remove(employee);
            }

            em.getTransaction().commit();

        } catch (Exception e) {

            if (em.getTransaction().isActive()) {
                em.getTransaction().rollback();
            }

            throw e;

        } finally {
            em.close();
        }
    }
}

Things You Must Not Mix Up

Learn This Sequence

50 Real JPA Interview Scenarios

Practice every question as Situation → Root cause → JPA concept → Fix → Interview answer. These are tied directly to the Employee CRUD project.

Rapid-Fire Coding Drill

// Find employee 1001.
// Increase salary if found.
// No update() call is required because the entity is managed.

em.getTransaction().begin();

EmployeeEntity employee =
        em.find(EmployeeEntity.class, 1001);

if (employee != null) {
    employee.setSalary(
        employee.getSalary() + 10000
    );
}

em.getTransaction().commit();