Orm hibernate java maven

Java Guides

In this tutorial, we will learn how to create Hibernate 6 Application and connect with the MySQL database. We use Maven as a dependency management tool.

In this tutorial, we use Java-based configuration and JPA annotations for mapping.

Technologies and tools used

• Hibernate 6.1.7.Final
• IDE — Eclipse
• Maven 3.5.3
• JavaSE 17
• MySQL — 8.0.32

Let’s start developing step by step Hibernate application using Maven as a project management and build tool.

Development Steps

1. Create a Simple Maven Project
2. Project Directory Structure
3. Add jar Dependencies to pom.xml
4. Creating the JPA Entity Class(Persistent class)
5. Create a Hibernate configuration file — Java Configuration
6. Create StudentDao Class
7. Create the Main class and Run an Application

1. Create a Simple Maven Project

Use the How to Create a Simple Maven Project in Eclipse article to create a simple Maven project in Eclipse IDE.

2. Project Directory Structure

3. 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.0modelVersion> parent> groupId>net.javaguides.hibernategroupId> artifactId>hibernate-tutorialartifactId> version>0.0.1-SNAPSHOTversion> parent> artifactId>hibernate-java-config-exampleartifactId> properties> project.build.sourceEncoding>UTF-8project.build.sourceEncoding> properties> dependencies>  https://mvnrepository.com/artifact/mysql/mysql-connector-java --> dependency> groupId>mysqlgroupId> artifactId>mysql-connector-javaartifactId> version>8.0.32version> dependency>  https://mvnrepository.com/artifact/org.hibernate/hibernate-core --> dependency> groupId>org.hibernategroupId> artifactId>hibernate-coreartifactId> version>6.1.7.Finalversion> dependency> dependencies> build> sourceDirectory>src/main/javasourceDirectory> plugins> plugin> artifactId>maven-compiler-pluginartifactId> version>3.5.1version> configuration> source>17source> target>17target> configuration> plugin> plugins> build> project>

Note that we are using the mysql-connector-java driver dependency to connect the Java Hibernate application to the MySQL database:

 https://mvnrepository.com/artifact/mysql/mysql-connector-java --> dependency> groupId>mysqlgroupId> artifactId>mysql-connector-javaartifactId> version>8.0.32version> dependency>

 https://mvnrepository.com/artifact/org.hibernate/hibernate-core --> dependency> groupId>org.hibernategroupId> artifactId>hibernate-coreartifactId> version>6.1.7.Finalversion> dependency>

We are using the maven-compiler-plugin to compile the Java Hibernate application with JRE 17 version:

plugin> artifactId>maven-compiler-pluginartifactId> version>3.5.1version> configuration> source>17source> target>17target> configuration> plugin>

4. Creating the JPA Entity Class(Persistent class)

• 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 the newInstance() method.
• Provide an identifier property: It is better to assign an attribute as an 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, which depends on the persistent class. The application programmer will not be able to use proxies for lazy association fetching.

Let’s create a Student entity class under net.javaguides.hibernate.entity package as follows.

package net.javaguides.hibernate.entity; import jakarta.persistence.*; @Entity @Table(name = "student") public class Student < @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "id") private int 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; > public int getId() < return id; > public void setId(int id) < this.id = id; > public String getFirstName() < return firstName; > public void setFirstName(String firstName) < this.firstName = firstName; > public String getLastName() < return lastName; > 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 + "]"; > >

@Column — The @Column annotation is used to specify the mapping between a basic entity attribute and the database table column.

@GeneratedValue — This annotation specifies the generation strategies for the values of primary keys.

5. Create a Hibernate configuration file — Java Configuration

The HibernateUtil Java configuration file contains information about the database and mapping file.

package net.javaguides.hibernate.util; import java.util.Properties; import org.hibernate.SessionFactory; import org.hibernate.boot.registry.StandardServiceRegistryBuilder; import org.hibernate.cfg.Configuration; import org.hibernate.cfg.Environment; import org.hibernate.service.ServiceRegistry; import net.javaguides.hibernate.entity.Student; public class HibernateUtil < private static SessionFactory sessionFactory; public static SessionFactory getSessionFactory() < if (sessionFactory == null) < try < Configuration configuration = new Configuration(); // Hibernate settings equivalent to hibernate.cfg.xml's properties Properties settings = new Properties(); settings.put(Environment.DRIVER, "com.mysql.cj.jdbc.Driver"); settings.put(Environment.URL, "jdbc:mysql://localhost:3306/hibernate_db?useSSL=false"); settings.put(Environment.USER, "root"); settings.put(Environment.PASS, "root"); settings.put(Environment.SHOW_SQL, "true"); settings.put(Environment.CURRENT_SESSION_CONTEXT_CLASS, "thread"); settings.put(Environment.HBM2DDL_AUTO, "create-drop"); configuration.setProperties(settings); configuration.addAnnotatedClass(Student.class); ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder() .applySettings(configuration.getProperties()).build(); sessionFactory = configuration.buildSessionFactory(serviceRegistry); > catch (Exception e) < e.printStackTrace(); > > return sessionFactory; > >

6. Create StudentDao Class

package net.javaguides.hibernate.dao; import java.util.List; import org.hibernate.Session; import org.hibernate.Transaction; import net.javaguides.hibernate.entity.Student; import net.javaguides.hibernate.util.HibernateUtil; public class StudentDao < public void saveStudent(Student student) < Transaction transaction = null; try (Session session = HibernateUtil.getSessionFactory().openSession()) < // start a transaction transaction = session.beginTransaction(); // save the student object session.save(student); // commit transaction transaction.commit(); > catch (Exception e) < if (transaction != null) < transaction.rollback(); > e.printStackTrace(); > > public List < Student > getStudents() < try (Session session = HibernateUtil.getSessionFactory().openSession()) < return session.createQuery("from Student", Student.class).list(); > > >

7. Create the main App class and Run an Application

package net.javaguides.hibernate; import java.util.List; import net.javaguides.hibernate.dao.StudentDao; import net.javaguides.hibernate.entity.Student; public class App < public static void main(String[] args) < StudentDao studentDao = new StudentDao(); Student student = new Student("Ramesh", "Fadatare", "rameshfadatare@javaguides.com"); studentDao.saveStudent(student); List  Student > students = studentDao.getStudents(); students.forEach(s - > System.out.println(s.getFirstName())); > >

Output

GitHub Repository

The complete source code of this article is available on my GitHub Repository — https://github.com/RameshMF/Hibernate-ORM-Tutorials

Conclusion

In this article, we have created a step-by-step hibernate application to demonstrate the use of Java-based configuration without using hibernate.cfg.xml to connect the MySQL database.

Related Hibernate Tutorials

• Hibernate One to Many CRUD Example
• Hibernate One-to-One CRUD Example
• Hibernate Example with MySQL Database
• Hibernate Framework Overview — Architecture and Basics
• Hibernate 5 — Save an Entity Example
• Hibernate 5 — Persist an Entity Example
• Hibernate 5 — saveOrUpdate() Method Example
• Hibernate 5 — get(), load(), and byId() Method Examples
• Hibernate 5 — merge() Example
• Hibernate 5 — Delete or Remove an Entity Example
• Hibernate 5 — load() Method Example
• Hibernate Session.evict() Method Example
• Hibernate Session.clear() Method Example
• Hibernate 5 c3p0 Connection Pool Example
• Hibernate Session Interface Methods with Examples

Источник