Quick Contact

    Hibernate

    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

    Copyright 1999- Ducat Creative, All rights reserved.

    Anda bisa mendapatkan server slot online resmi dan terpercaya tentu saja di sini. Sebagai salah satu provider yang menyediakan banyak pilihan permainan.