Hibernate Relationships

  

Example 1: One-to-One Relationship

Scenario: Modeling a relationship where each employee has exactly one address.

Entities: Employee and Address

Employee.java

import javax.persistence.*;

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "address_id")
    private Address address;

    // Constructors, getters, setters
}

Address.java

import javax.persistence.*;

@Entity
public class Address {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String street;
    private String city;
    private String zipCode;

    // Constructors, getters, setters
}

Usage in Application:

// Creating and saving an employee with address
Employee employee = new Employee("John Doe");
Address address = new Address("123 Main St", "Anytown", "12345");
employee.setAddress(address);

entityManager.persist(employee);

Example 2: One-to-Many Relationship

Scenario: Modeling a relationship where one department can have multiple employees.

Entities: Department and Employee

Department.java

import javax.persistence.*;
import java.util.List;

@Entity
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    @OneToMany(mappedBy = "department", cascade = CascadeType.ALL)
    private List<Employee> employees;

    // Constructors, getters, setters
}

Employee.java

import javax.persistence.*;

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    @ManyToOne
    @JoinColumn(name = "department_id")
    private Department department;

    // Constructors, getters, setters
}

Usage in Application:

// Creating and saving a department with employees
Department department = new Department("Engineering");

Employee emp1 = new Employee("Alice");
emp1.setDepartment(department);

Employee emp2 = new Employee("Bob");
emp2.setDepartment(department);

department.getEmployees().add(emp1);
department.getEmployees().add(emp2);

entityManager.persist(department);

Example 3: Many-to-Many Relationship

Scenario: Modeling a relationship where students can enroll in multiple courses and each course can have multiple students.

Entities: Student and Course

Student.java

import javax.persistence.*;
import java.util.List;

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    @ManyToMany(mappedBy = "students")
    private List<Course> courses;

    // Constructors, getters, setters
}

Course.java

import javax.persistence.*;
import java.util.List;

@Entity
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    @ManyToMany
    @JoinTable(name = "course_student",
            joinColumns = @JoinColumn(name = "course_id"),
            inverseJoinColumns = @JoinColumn(name = "student_id"))
    private List<Student> students;

    // Constructors, getters, setters
}

Usage in Application:

// Creating and saving students and courses
Student student1 = new Student("John");
Student student2 = new Student("Jane");

Course course1 = new Course("Java Programming");
Course course2 = new Course("Database Management");

student1.getCourses().add(course1);
student1.getCourses().add(course2);

student2.getCourses().add(course1);

course1.getStudents().add(student1);
course1.getStudents().add(student2);

course2.getStudents().add(student1);

entityManager.persist(student1);
entityManager.persist(student2);

Example 4: Many-to-One Relationship

Scenario: Modeling a relationship where many orders belong to one customer.

Entities: Customer and Order

Customer.java

import javax.persistence.*;
import java.util.List;

@Entity
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL)
    private List<Order> orders;

    // Constructors, getters, setters
}

Order.java

import javax.persistence.*;

@Entity
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String orderNumber;
    
    @ManyToOne
    @JoinColumn(name = "customer_id")
    private Customer customer;

    // Constructors, getters, setters
}

Usage in Application:

// Creating and saving customer with orders
Customer customer = new Customer("John Doe");

Order order1 = new Order("ORD001");
Order order2 = new Order("ORD002");

order1.setCustomer(customer);
order2.setCustomer(customer);

customer.getOrders().add(order1);
customer.getOrders().add(order2);

entityManager.persist(customer);

    Hibernate is a powerful Object-Relational Mapping (ORM) framework 
for Java applications, widely used for simplifying database interactions
and enabling developers to work with objects rather than directly with 
SQL statements. In this blog post, we'll explore practical examples 
and best practices for using Hibernate, focusing on Hibernate Mapping, 
Query Language (HQL), Lazy Loading, Transactions, Integration, 
and Schema Generation.
1. Hibernate Mapping
Hibernate Mapping defines how Java objects (entities) are mapped to 
database tables and vice versa. Let's consider a real-world example:
Example:
Assume we have a User entity 
in our Java application:
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "username", nullable = false)
    private String username;
    
    // Getters and setters
}
In this example:
@Entity marks the class as a Hibernate entity.
@Table specifies the table name in the database.
@Id and @GeneratedValue define the primary key (id) 
and its generation strategy.
2. Hibernate Query Language (HQL)
Hibernate Query Language (HQL) allows developers to write 
database queries in terms of entity objects. It abstracts 
the underlying SQL syntax, making queries database-agnostic.
Example:
Querying users by username using HQL:
String hql = "FROM User WHERE username = :username";
Query query = session.createQuery(hql);
query.setParameter("username", "john_doe");
User user = (User) query.uniqueResult();
In this example:
session.createQuery(hql) creates a HQL query.
query.setParameter("username", "john_doe") sets 
the parameter value.
query.uniqueResult() executes the query and retrieves 
a single User object.
3. Lazy Loading
Lazy Loading in Hibernate delays loading associated entities until 
they are actually accessed. This improves performance by 
loading only what is necessary.
Example:
Consider a User entity with a OneToMany association with
Post entities:
@Entity
@Table(name = "users")
public class User {
    @OneToMany(mappedBy = "author", fetch = FetchType.LAZY)
    private List<Post> posts;
    
    // Other fields and methods
}
In this example:
fetch = FetchType.LAZY specifies lazy loading for the 
posts association.
Posts associated with a user are loaded from the database
 only when accessed 
     through user.getPosts().
4. Transactions
Transactions in Hibernate ensure atomicity, consistency,
 isolation, and durability
 (ACID properties) for database operations.
Example:
Performing database operations within a transaction:
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
    tx = session.beginTransaction();
    
    // Perform database operations (e.g., save, update, delete)
    User newUser = new User("jane_doe");
    session.save(newUser);
    
    tx.commit();
} catch (HibernateException e) {
    if (tx != null) tx.rollback();
    e.printStackTrace();
} finally {
    session.close();
}
In this example:
session.beginTransaction() starts a new transaction.
Operations are performed (e.g., session.save(newUser)) within
 the transaction tx.commit() commits the transaction, 
applying changes to the database.
5. Integration
Hibernate integrates seamlessly with various Java frameworks and 
technologies, enhancing its versatility and usability.
Example:
Integrating Hibernate with Spring Framework:
@Repository
public class UserRepository {
    
    @Autowired
    private SessionFactory sessionFactory;
    
    public User getUserById(Long id) {
        Session session = sessionFactory.getCurrentSession();
        return session.get(User.class, id);
    }
    
    // Other repository methods
}
In this example:
@Repository marks the class as a Spring-managed repository.
@Autowired injects the SessionFactory for Hibernate session 
    management.
session.get(User.class, id) retrieves a User object by its ID 
using Hibernate session.
6. Schema Generation
Hibernate can generate database schemas based on entity mappings,
 simplifying database setup and schema management.
Example:
Generating database schema from entity mappings in application.properties:
# Hibernate properties
spring.jpa.hibernate.ddl-auto=update
In this example:
spring.jpa.hibernate.ddl-auto=update automatically updates the
database schema based on entity mappings.