Hibernate: Save, Persist, Update, Merge, and SaveOrUpdate

In this tutorial, we will demonstrate how to use Hibernate's save, persist, update, merge, and saveOrUpdate methods. These methods are used to perform various operations on entity instances in Hibernate.

Prerequisites

  1. Java Development Kit (JDK) 21 or higher: Ensure JDK is installed and configured in your system.
  2. Integrated Development Environment (IDE): IntelliJ IDEA, Eclipse, or any other IDE.
  3. Maven: Ensure Maven is installed and configured in your system.

Step 1: Create a Maven Project

  1. Open your IDE and create a new Maven project.
  2. Update the pom.xml file to include Hibernate and other required dependencies.
<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>hibernate-methods-example</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.hibernate.orm</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>6.2.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.30</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.30</version>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>1.4.200</version>
        </dependency>
    </dependencies>
</project>

Explanation

  • Hibernate Core Dependency: Includes the main Hibernate framework.
  • SLF4J Dependencies: Used for logging.
  • H2 Database Dependency: An in-memory database for testing purposes.

Step 2: Create Hibernate Configuration File

Create a file named hibernate.cfg.xml in the src/main/resources directory.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>
        <property name="hibernate.connection.driver_class">org.h2.Driver</property>
        <property name="hibernate.connection.url">jdbc:h2:mem:testdb</property>
        <property name="hibernate.connection.username">sa</property>
        <property name="hibernate.connection.password"></property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
    </session-factory>
</hibernate-configuration>

Explanation

  • Dialect: Specifies the SQL dialect (H2 in this case).
  • Connection Properties: Configure the JDBC connection to the H2 database.
  • hbm2ddl.auto: Automatically manages the database schema (update existing schema).
  • show_sql: Prints SQL statements to the console.
  • format_sql: Formats SQL statements.

Step 3: Create the Employee Entity Class

Create a package named com.example.entity and a class named Employee.

package com.example.entity;

import jakarta.persistence.*;

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String department;

    public Employee() {}

    public Employee(String name, String department) {
        this.name = name;
        this.department = department;
    }

    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;
    }

    @Override
    public String toString() {
        return "Employee{id=" + id + ", name='" + name + '\'' + ", department='" + department + '\'' + '}';
    }
}

Explanation

  • @Entity: Marks the class as an entity.
  • @Id: Marks the field as the primary key.
  • @GeneratedValue: Specifies the strategy for generating values for the primary key.

Step 4: Create Hibernate Utility Class

Create a package named com.example.util and a class named HibernateUtil.

package com.example.util;

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;

public class HibernateUtil {
    private static SessionFactory sessionFactory;

    static {
        try {
            Configuration configuration = new Configuration().configure();
            ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
                    .applySettings(configuration.getProperties()).build();
            sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        } catch (Throwable ex) {
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

Explanation

  • Configuration: Loads Hibernate configuration from hibernate.cfg.xml.
  • ServiceRegistry: Builds the service registry from the configuration settings.
  • SessionFactory: Provides sessions to interact with the database.

Step 5: Create Main Class

Create a package named com.example and a class named Main.

package com.example;

import com.example.entity.Employee;
import com.example.util.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;

public class Main {
    public static void main(String[] args) {
        // Initialize session and transaction
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction transaction = session.beginTransaction();

        // Save a new employee
        Employee employee1 = new Employee("John Doe", "IT");
        session.save(employee1); // Using save
        transaction.commit();

        // Persist a new employee
        transaction = session.beginTransaction();
        Employee employee2 = new Employee("Jane Doe", "HR");
        session.persist(employee2); // Using persist
        transaction.commit();

        // Update the employee
        transaction = session.beginTransaction();
        employee1.setDepartment("Finance");
        session.update(employee1); // Using update
        transaction.commit();

        // Merge the employee
        transaction = session.beginTransaction();
        Employee detachedEmployee = new Employee("Detached Employee", "Sales");
        detachedEmployee.setId(employee1.getId());
        session.merge(detachedEmployee); // Using merge
        transaction.commit();

        // Save or update the employee
        transaction = session.beginTransaction();
        Employee employee3 = new Employee("Jack Doe", "Marketing");
        session.saveOrUpdate(employee3); // Using saveOrUpdate
        transaction.commit();

        // Retrieve and display employees
        session = HibernateUtil.getSessionFactory().openSession();
        Employee retrievedEmployee1 = session.get(Employee.class, employee1.getId());
        Employee retrievedEmployee2 = session.get(Employee.class, employee2.getId());
        Employee retrievedEmployee3 = session.get(Employee.class, employee3.getId());

        System.out.println("Retrieved Employee 1: " + retrievedEmployee1);
        System.out.println("Retrieved Employee 2: " + retrievedEmployee2);
        System.out.println("Retrieved Employee 3: " + retrievedEmployee3);

        // Close the session
        session.close();

        // Close the SessionFactory
        HibernateUtil.getSessionFactory().close();
    }
}

Explanation

  • session.save(): Generates an insert SQL statement. Returns the generated identifier.
  • session.persist(): Generates an insert SQL statement. Does not return the identifier.
  • session.update(): Updates the entity if it already exists in the database.
  • session.merge(): Copies the state of the given object onto the persistent object with the same identifier.
  • session.saveOrUpdate(): Either saves a transient entity or updates a detached entity.

Step 6: Run the Application

  1. Run the Main class.
  2. The output in the console should be:
Hibernate: create table Employee (id bigint generated by default as identity, department varchar(255), name varchar(255), primary key (id))
Hibernate: insert into Employee (department, name) values (?, ?)
Hibernate: insert into Employee (department, name) values (?, ?)
Hibernate: update Employee set department=? where id=?
Hibernate: insert into Employee (department, name) values (?, ?)
Hibernate: update Employee set department=?, name=? where id=?
Hibernate: insert into Employee (department, name) values (?, ?)
Hibernate: select employee0_.id

 as id1_0_0_, employee0_.department as departme2_0_0_, employee0_.name as name3_0_0_ from Employee employee0_ where employee0_.id=?
Hibernate: select employee0_.id as id1_0_0_, employee0_.department as departme2_0_0_, employee0_.name as name3_0_0_ from Employee employee0_ where employee0_.id=?
Hibernate: select employee0_.id as id1_0_0_, employee0_.department as departme2_0_0_, employee0_.name as name3_0_0_ from Employee employee0_ where employee0_.id=?
Retrieved Employee 1: Employee{id=1, name='Detached Employee', department='Sales'}
Retrieved Employee 2: Employee{id=2, name='Jane Doe', department='HR'}
Retrieved Employee 3: Employee{id=3, name='Jack Doe', department='Marketing'}

Conclusion

You have successfully created an example using Hibernate to demonstrate the use of save, persist, update, merge, and saveOrUpdate methods. This tutorial covered setting up a Maven project, configuring Hibernate, creating an entity class, and performing CRUD operations using various Hibernate methods.


Comments

Post a Comment