Hibernate Framework Architecture and Basics
Hibernate Hello World Tutorial
Hibernate XML Configuration Example
Hibernate Java Configuration Example
Hibernate Transaction Management
Hibernate/JPA - Primary Key Generation Strategies
JPA and Hibernate Cascade Types
Hibernate - Save an Entity Example
Hibernate - Persist an Entity Example
Hibernate - saveOrUpdate() Method Example
Hibernate - get(), load() and byId() Method
Hibernate - merge() Example
Hibernate - Delete or Remove an Entity Example
Hibernate - load() Method Example
Hibernate Session.clear() Method Example
Hibernate One to One Mapping
Hibernate One to Many Mapping
Hibernate Many to Many Annotation
Hibernate One to Many CRUD Example
Hibernate One to One CRUD Example
Hibernate Inheritance Mapping
Hibernate Query Language
Hibernate CRUD Operations Example
Hibernate Session Interface Methods
JSP Servlet Hibernate CRUD Example
Hibernate Registration Form Example
Login Form using JSP + Servlet + Hibernate + MySQL
More .........
In this tutorial, we implement one-to-one bidirectional entity mapping using JPA and Hibernate, and MySQL databases. We will perform CRUD ( Create, Read, Update and Delete) operations with the MySQL database.
In this example, we create Instructor and InstructorDetail entities and we make a one-to-one mapping between them.
We will implement CRUD (create/save, read, update, delete) operations for Instructor and InstructorDetailentities.
For Instructor DAO CRUD operations:
void saveInstructor(Instructor instructor);
void updateInstructor(Instructor instructor);
void deleteInstructor(int id);
Instructor getInstructor(int id);
For InstructorDetailDao DAO CRUD operations:
void saveInstructorDetail(InstructorDetail instructorDetail);
void updateInstructorDetail(InstructorDetail instructorDetail);
InstructorDetail getInstructorDetail(int id);
Development Steps
- Create a Simple Maven Project
- Project Directory Structure
- Add jar Dependencies to pom.xml
- Creating the JPA Entities(Persistent classes)
- Create Hibernate DAO Classes
- Create a Hibernate configuration file - HibernateUtil.java (Java Configuration)
- 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
Refer to the below screenshot to create a project or packaging structure for our Hibernate application:
3. Add dependencies to pom.xml
We are using MySQL database so add MySQL dependency 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-one-to-one-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>
Note that we are using mysql-connector-java driver dependency to connect Java Hibernate application to MySQL database:
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.13</version> </dependency>
We are using Hibernate core 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>
We are using the maven-compiler-plugin to compile the Java Hibernate application with JRE 1.8 version:
<plugin> <artifactId>maven-compiler-plugin</artifactId> <version>3.5.1</version> <configuration> <source>1.8</source> <target>1.8</target> </configuration> </plugin>
4. Creating the JPA Entities(Persistent classes)
We are creating a bidirectional mapping, we have placed @OneToOne annotation on both entity classes.
Instructor JPA Entity
package net.javaguides.hibernate.entity;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;
@Entity
@Table(name = "instructor")
public class Instructor {
@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;
@OneToOne(cascade = CascadeType.ALL, mappedBy = "instructor", fetch = FetchType.LAZY)
private InstructorDetail instructorDetail;
public Instructor() {
}
public Instructor(String firstName, String lastName, String email) {
this.firstName = firstName;
this.lastName = lastName;
this.email = email;
}
// getters and setters
}
InstructorDetail JPA Entity
package net.javaguides.hibernate.entity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;
@Entity
@Table(name = "instructor_detail")
public class InstructorDetail {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private int id;
@Column(name = "youtube_channel")
private String youtubeChannel;
@Column(name = "hobby")
private String hobby;
@OneToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "instructor_id")
private Instructor instructor;
public InstructorDetail() {
}
public InstructorDetail(String youtubeChannel, String hobby) {
this.youtubeChannel = youtubeChannel;
this.hobby = hobby;
}
// getters and setters
}
Note that we are using the below JPA annotations:
- @Table maps the entity with the table. If no @Table is defined, the default value is used: the class name of the entity.
- @Entity - This annotation specifies that the class is an entity.
- @Id declares the identifier property of the entity.
- @Column maps the entity's field with the table's column. If @Column is omitted, the default value is used: the field name of the entity.
- @GeneratedValue - This annotation specifies the generation strategies for the values of primary keys.
5. Create Hibernate DAO Classes
InstructorDao.java
package net.javaguides.hibernate.dao;
import org.hibernate.Session;
import org.hibernate.Transaction;
import net.javaguides.hibernate.entity.Instructor;
import net.javaguides.hibernate.util.HibernateUtil;
public class InstructorDao {
public void saveInstructor(Instructor instructor) {
Transaction transaction = null;
try (Session session = HibernateUtil.getSessionFactory().openSession()) {
// start a transaction
transaction = session.beginTransaction();
// save the student object
session.save(instructor);
// commit transaction
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
}
}
public void updateInstructor(Instructor instructor) {
Transaction transaction = null;
try (Session session = HibernateUtil.getSessionFactory().openSession()) {
// start a transaction
transaction = session.beginTransaction();
// save the student object
session.update(instructor);
// commit transaction
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
}
}
public void deleteInstructor(int id) {
Transaction transaction = null;
try (Session session = HibernateUtil.getSessionFactory().openSession()) {
// start a transaction
transaction = session.beginTransaction();
// Delete a instructor object
Instructor instructor = session.get(Instructor.class, id);
if (instructor != null) {
session.delete(instructor);
System.out.println("instructor is deleted");
}
// commit transaction
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
}
}
public Instructor getInstructor(int id) {
Transaction transaction = null;
Instructor instructor = null;
try (Session session = HibernateUtil.getSessionFactory().openSession()) {
// start a transaction
transaction = session.beginTransaction();
// get an instructor object
instructor = session.get(Instructor.class, id);
// commit transaction
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
}
return instructor;
}
}
InstructorDetailDao.java
package net.javaguides.hibernate.dao;
import org.hibernate.Session;
import org.hibernate.Transaction;
import net.javaguides.hibernate.entity.InstructorDetail;
import net.javaguides.hibernate.util.HibernateUtil;
public class InstructorDetailDao {
public void saveInstructorDetail(InstructorDetail instructorDetail) {
Transaction transaction = null;
try (Session session = HibernateUtil.getSessionFactory().openSession()) {
// start a transaction
transaction = session.beginTransaction();
// save the student object
session.save(instructorDetail);
// commit transaction
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
}
}
public void updateInstructorDetail(InstructorDetail instructorDetail) {
Transaction transaction = null;
try (Session session = HibernateUtil.getSessionFactory().openSession()) {
// start a transaction
transaction = session.beginTransaction();
// save the student object
session.update(instructorDetail);
// commit transaction
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
}
}
public InstructorDetail getInstructorDetail(int id) {
Transaction transaction = null;
InstructorDetail instructor = null;
try (Session session = HibernateUtil.getSessionFactory().openSession()) {
// start a transaction
transaction = session.beginTransaction();
// get an instructor object
instructor = session.get(InstructorDetail.class, id);
// commit transaction
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
}
return instructor;
}
}
6. HibernateUtil.java (Java Configuration)
The HibernateUtil Java configuration file contains information about the database and mapping file. Let's create a HibernateUtil file and write the following code in it.
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.Instructor;
import net.javaguides.hibernate.entity.InstructorDetail;
/**
* Java based configuration
* @author ramesh Fadatare
*
*/
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");
settings.put(Environment.USER, "root");
settings.put(Environment.PASS, "root");
settings.put(Environment.DIALECT, "org.hibernate.dialect.MySQL5InnoDBDialect");
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(InstructorDetail.class);
configuration.addAnnotatedClass(Instructor.class);
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
.applySettings(configuration.getProperties()).build();
System.out.println("Hibernate Java Config serviceRegistry created");
sessionFactory = configuration.buildSessionFactory(serviceRegistry);
return sessionFactory;
} catch (Exception e) {
e.printStackTrace();
}
}
return sessionFactory;
}
}
7. Create the Main class and Run an Application
package net.javaguides.hibernate;
import net.javaguides.hibernate.dao.InstructorDao;
import net.javaguides.hibernate.entity.Instructor;
import net.javaguides.hibernate.entity.InstructorDetail;
public class ManApp {
public static void main(String[] args) {
Instructor instructor = new Instructor("Ramesh", "Fadatare", "ramesh@javaguides.com");
InstructorDetail instructorDetail = new InstructorDetail("http://www.youtube.com", "Guitar");
// associate the objects
instructorDetail.setInstructor(instructor);
// associate the objects
instructor.setInstructorDetail(instructorDetail);
// when you get instructorDetail then hibernate also saves instructor info
InstructorDao instructorDao = new InstructorDao();
instructorDao.saveInstructor(instructor);
}
}
Note that when you save instructorDetail then hibernate also saves instructor info because of cascade and bidirectional.
Output
Conclusion
In this tutorial, we successfully built a project from scratch and learned how to map a one-to-one database relationship using Hibernate 5.
We have performed CRUD ( Create, Read, Update and Delete) operations with the MySQL database.
You might also be interested in checking out the following articles on JPA and Hibernate -
Free Spring Boot Tutorial | Full In-depth Course | Learn Spring Boot in 10 Hours
Watch this course on YouTube at Spring Boot Tutorial | Fee 10 Hours Full Course
Comments
Post a Comment