Hibernate 5 – Save an Entity Example

Hibernate 5 – Save an Entity Example

save(Object object) Method

save() method persist the given transient instance, first assigning a generated identifier. (Or using the current value of the identifier property if the assigned generator is used.) This operation cascades to associated instances if the association is mapped with cascade=”save-update”.

Add jar Dependencies to pom.xml

< 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>
< parent>
< groupId>net.ducatindia.hibernate< /groupId>
< artifactId>hibernate-tutorial< /artifactId>
< version>0.0.1-SNAPSHOT< /version>
< /parent>
< artifactId>hibernate-xml-config-example< /artifactId>
< properties>
< project.build.sourceEncoding>UTF-8< /project.build.sourceEncoding>
< /properties>
< dependencies>
< !-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
< dependency>
< groupId>mysql< /groupId>
< artifactId>mysql-connector-java< /artifactId>
< version>8.0.13< /version>
< /dependency>
< !-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
< dependency>
< groupId>org.hibernate< /groupId>
< artifactId>hibernate-core< /artifactId>
< version>5.3.7.Final< /version>
< /dependency>
< /dependencies>
< build>
< sourceDirectory>src/main/java< /sourceDirectory>
< plugins>
< plugin>
< artifactId>maven-compiler-plugin< /artifactId>
< version>3.5.1< /version>
< configuration>
< source>1.8< /source>
< target>1.8< /target>
< /configuration>
< /plugin>
< /plugins>
< /build>
< /project>

Creating the JPA Entity Class(Persistent class)

Let’s create a Student persistent class that is mapped to a database table.

A simple Persistent class should follow some rules:

• A no-arg constructor:

  It is recommended that you have a default constructor at least package visibility so that hibernate can create the instance of the Persistent class by newInstance() method.

• Provide an identifier property:

  It is better to assign an attribute as id. This attribute behaves as a primary key in a database.

• Declare getter and setter methods:

  The Hibernate recognizes the method by getter and setter method names by default.

• Prefer non-final class:

  Hibernate uses the concept of proxies, that depends on the persistent class. The application programmer will not be able to use proxies for lazy association fetching.

Create a Student entity class under net.javaguides.hibernate.entity package as follows.

packagenet.ducatindia.hibernate.entity;

importjavax.persistence.Column;
importjavax.persistence.Entity;
importjavax.persistence.GeneratedValue;
importjavax.persistence.GenerationType;
importjavax.persistence.Id;
importjavax.persistence.Table;

@Entity
@Table(name = "student")
public class Student {

    @Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
privateint id;

@Column(name = "first_name")
private String firstName;

@Column(name = "last_name")
private String lastName;

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

public Student() {

    }

public Student(String firstName, String lastName, String email) {
this.firstName = firstName;
this.lastName = lastName;
this.email = email;
    }

publicintgetId() {
return id;
    }

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

public String getFirstName() {
returnfirstName;
    }

public void setFirstName(String firstName) {
this.firstName = firstName;
    }

public String getLastName() {
returnlastName;
    }

public void setLastName(String lastName) {
this.lastName = lastName;
    }

public String getEmail() {
return email;
    }

public void setEmail(String email) {
this.email = email;
    }

    @Override
public String toString() {
        return "Student [id=" + id + ", firstName=" + firstName + ", lastName=" + lastName + ", email=" + email + "]";
    }
}

Create a Hibernate configuration file – hibernate.cfg.xml

The configuration file contains information about the database and mapping file. Conventionally, its name should be hibernate.cfg.xml.

You can use Hibernate 5 Java Configuration Example instead of a hibernate.cfg.xml file.

Let’s create an XML file named as hibernate.cfg.xml under resources folder and write the following code in it.

< !DOCTYPEhibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
< hibernate-configuration>
< session-factory>
< !-- JDBC Database connection settings -->
< propertyname="connection.driver_class">com.mysql.cj.jdbc.Driver< /property>
< propertyname="connection.url">jdbc:mysql://localhost:3306/hibernate_db?useSSL=false< /property>
< propertyname="connection.username">root< /property>
< propertyname="connection.password">root< /property>
< !-- JDBC connection pool settings ... using built-in test pool -->
< propertyname="connection.pool_size">1< /property>
< !-- Select our SQL dialect -->
< propertyname="dialect">org.hibernate.dialect.MySQL5Dialect< /property>
< !-- Echo the SQL to stdout -->
< propertyname="show_sql">true< /property>
< !-- Set the current session context -->
< propertyname="current_session_context_class">thread< /property>
< !-- Drop and re-create the database schema on startup -->
< propertyname="hbm2ddl.auto">create-drop< /property>
< !--dbcp connection pool configuration -->
< propertyname="hibernate.dbcp.initialSize">5< /property>
< propertyname="hibernate.dbcp.maxTotal">20< /property>
< propertyname="hibernate.dbcp.maxIdle">10< /property>
< propertyname="hibernate.dbcp.minIdle">5< /property>
< propertyname="hibernate.dbcp.maxWaitMillis">-1< /property>
< mappingclass="net.javaguides.hibernate.entity.Student" />
< /session-factory>
< /hibernate-configuration>

Create a Hibernate utility Class

Create a helper class to bootstrap hibernate SessionFactory. In most Hibernate applications, the SessionFactory should be instantiated once during application initialization. The single instance should then be used by all code in a particular process, and any Session should be created using this single SessionFactory. The SessionFactory is thread-safe and can be shared; a Session is a single-threaded object. Let’s create HibernateUtil.java class to configure SessionFactory as a singleton and use throughout the application.

The bootstrapping API is quite flexible, but in most cases, it makes the most sense to think of it as a 3 step process:

1. Build the StandardServiceRegistry
2. Build the Metadata
3. Use those 2 to build the SessionFactory

packagenet.ducatindia.hibernate.util;

importorg.hibernate.SessionFactory;
importorg.hibernate.boot.Metadata;
importorg.hibernate.boot.MetadataSources;
importorg.hibernate.boot.registry.StandardServiceRegistry;
importorg.hibernate.boot.registry.StandardServiceRegistryBuilder;

publicclassHibernateUtil {
privatestaticStandardServiceRegistry registry;
privatestaticSessionFactorysessionFactory;

publicstaticSessionFactorygetSessionFactory() {
if (sessionFactory==null) {
try {
// Create registry
registry=newStandardServiceRegistryBuilder().configure().build();

// Create MetadataSources
MetadataSources sources =newMetadataSources(registry);

// Create Metadata
Metadatametadata=sources.getMetadataBuilder().build();

// Create SessionFactory
sessionFactory=metadata.getSessionFactoryBuilder().build();

            } catch (Exception e) {
e.printStackTrace();
if (registry !=null) {
StandardServiceRegistryBuilder.destroy(registry);
                }
            }
        }
returnsessionFactory;
    }

publicstaticvoidshutdown() {
if (registry !=null) {
StandardServiceRegistryBuilder.destroy(registry);
        }
    }
}

Create the main App class and Run an Application

Here is main App class which is used to connect MySQL database and persist Student object in a database table. Let’s test Hibernate application to connect MySQL database.

packagenet.ducatindia.hibernate;

importjava.util.List;

importorg.hibernate.Session;
importorg.hibernate.Transaction;

importnet.ducatindia.hibernate.entity.Student;
importnet.ducatindia.hibernate.util.HibernateUtil;

publicclassApp {
publicstaticvoidmain(String[] args) {

Studentstudent=newStudent("Rajan", "Sharma", "ducatindia@ducatindia.com");
Student student1 =newStudent("Dines", "singh", "dinesh@ducatdia.com");
Transactiontransaction=null;
try (Sessionsession=HibernateUtil.getSessionFactory().openSession()) {
// start a transaction
transaction=session.beginTransaction();
// save the student objects
session.save(student);
session.save(student1);
// commit transaction
transaction.commit();
        } catch (Exception e) {
if (transaction !=null) {
transaction.rollback();
            }
e.printStackTrace();
        }

try (Sessionsession=HibernateUtil.getSessionFactory().openSession()) {
List< Student> students =session.createQuery("from Student", Student.class).list();
students.forEach(s ->System.out.println(s.getFirstName()));
        } catch (Exception e) {
if (transaction !=null) {
transaction.rollback();
            }
e.printStackTrace();
        }
    }
}

Apply now for Advanced Java Training Course