The Java Persistence API (a.k.a. JPA) is a Java specification for managing, persisting, and accessing data between objects and relational databases. Hibernate is an ORM (Object Relational Mapping) tool that implements JPA specification.
Below article describes Hibernate native Bootstrapping -
>> Hibernate 5 XML Configuration Example
>> Hibernate 5 Java Configuration Example
In this post, we will show you how to create or configure a simple JPA application with Hibernate.
Technologies and tools used
- Hibernate 5.3.7.Final
- JPA 2.1
- IDE - Eclipse Noen
- Maven 3.5.3
- JavaSE 1.8
- MySQL - 8.0.13
Let's start developing step by step Hibernate application using Maven as project management and build tool.
Development Steps
- Create a Simple Maven Project
- Project Directory Structure
- Add jar Dependencies to pom.xml
- Creating the JPA Entity Class(Persistent class)
- Create a JPA configuration file
- Create a JPA helper class
- Create the Main class and Run an Application
1. Create a Simple Maven Project
Use How to Create a Simple Maven Project in Eclipse article to create a simple Maven project in Eclipse IDE.
2. Project Directory Structure
The project directory structure for your reference -
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.0</modelVersion>
<parent>
<groupId>net.javaguides.hibernate</groupId>
<artifactId>hibernate-tutorial</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<artifactId>hibernate-jpa-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>
4. 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.
package net.javaguides.hibernate.entity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@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 + "]";
}
}
5. Create a JPA configuration file
Let's create an XML file named as persistence.xml under src/main/java/META-INF folder and write the following code in it.
<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_1.xsd"
version="2.1">
<persistence-unit name="PERSISTENCE">
<description> Hibernate JPA Configuration Example</description>
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<class>net.javaguides.hibernate.entity.Student</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/hibernate_db" />
<property name="javax.persistence.jdbc.user" value="root" />
<property name="javax.persistence.jdbc.password"
value="root" />
<property name="hibernate.show_sql" value="true" />
<property name="hibernate.hbm2ddl.auto" value="create-drop" />
</properties>
</persistence-unit>
</persistence>
6. Create a JPA helper class
Let's create a helper class to bootstrap a JPA EntityManagerFactory.
package net.javaguides.hibernate.util;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
public class JPAUtil {
private static final String PERSISTENCE_UNIT_NAME = "PERSISTENCE";
private static EntityManagerFactory factory;
public static EntityManagerFactory getEntityManagerFactory() {
if (factory == null) {
factory = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT_NAME);
}
return factory;
}
public static void shutdown() {
if (factory != null) {
factory.close();
}
}
}
7. Create a main class and run an application
Here is the main class to persist student object using the EntityManager#persist method.
MainApp.java
package net.javaguides.hibernate;
import javax.persistence.EntityManager;
import net.javaguides.hibernate.entity.Student;
import net.javaguides.hibernate.util.JPAUtil;
public class App {
public static void main(String[] args) {
EntityManager entityManager = JPAUtil.getEntityManagerFactory().createEntityManager();
entityManager.getTransaction().begin();
Student student = new Student("Ramesh", "Fadatare", "rameshfadatare@javaguides.com");
entityManager.persist(student);
entityManager.getTransaction().commit();
entityManager.close();
JPAUtil.shutdown();
}
}
Output
Hibernate Native Bootstrapping
Hibernate 5 XML Configuration Example - In this article, we will show you how to create a Hibernate Application using hibernate.cfg.xml configuration to connect the MySQL database.Hibernate 5 Java Configuration Example - In this article, we will show you how to create a Hibernate Application using Java configuration without using hibernate.cfg.xml to connect the MySQL database.
GitHub Repository
The complete source code of this article available on my GitHub Repository - https://github.com/RameshMF/Hibernate-ORM-Tutorials
Conclusion
In this post, we have shown you how to create or configure a simple JPA application with Hibernate.
Learn more about JPA at JPA Tutorial
How to Create a Simple Maven Project in Eclipse....this link giving 404 error. Please check sir!
ReplyDeleteFixed. Thanks for reporting.
Delete