creating an Employee entity class using Hibernate annotations, along with sample

data insertion:
Step 1: Create a Maven Project

You can create a Maven project using your preferred IDE or by running the following
command in your terminal:

bash

mvn archetype:generate -DgroupId=com.example -DartifactId=hibernate-example -

DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Step 2: Add Dependencies in pom.xml

Add the necessary dependencies for Hibernate and your database driver in the
pom.xml file:

xml:

<dependencies>
<!-- Hibernate -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.5.7.Final</version>
</dependency>
<!-- Database Driver -->
<!-- Add the appropriate driver based on your database (e.g., MySQL,
PostgreSQL, etc.) -->
</dependencies>

Step 3: Create hibernate.cfg.xml

Create hibernate.cfg.xml in the src/main/resources directory. This file contains

Hibernate configuration properties and connection settings. Here's a sample
configuration for MySQL:

XML

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- Database connection settings -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property
name="connection.url">jdbc:mysql://localhost:3306/your_database</property>
<property name="connection.username">your_username</property>
<property name="connection.password">your_password</property>

<!-- Hibernate dialect -->

<property name="dialect">org.hibernate.dialect.MySQLDialect</property>

<!-- Echo all executed SQL to stdout -->

<property name="show_sql">true</property>

<!-- Mapping files -->

 <!-- Add mapping files here if using XML mapping -->

</session-factory>
</hibernate-configuration>

Step 4: Create Employee Entity Class

Create a Java class Employee in the package com.example.model with Hibernate

annotations:

java

package com.example.model;

import javax.persistence.*;

@Entity
@Table(name = "employee")
public class Employee {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@Column(name = "name")
private String name;

@Column(name = "salary")
private double salary;

// Constructors, getters, setters

}

Step 5: Insert Sample Data

To insert sample data, you can write a sample Java application or use Hibernate's
built-in functionality to insert data. Here's an example of inserting sample data
using Hibernate:

java

package com.example;

import com.example.model.Employee;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class App {

public static void main(String[] args) {
// Create session factory
SessionFactory factory = new
Configuration().configure("hibernate.cfg.xml").buildSessionFactory();

// Create session
Session session = factory.openSession();

// Begin transaction
 Transaction transaction = session.beginTransaction();

// Create and insert sample data

Employee employee1 = new Employee();
employee1.setName("John Doe");
employee1.setSalary(50000);

session.save(employee1);

Employee employee2 = new Employee();

employee2.setName("Jane Smith");
employee2.setSalary(60000);

session.save(employee2);

// Commit transaction
transaction.commit();

// Close session
session.close();

// Close session factory

factory.close();
}
}

Step 6: Run the Application

Compile and run the application. Make sure your database server is running and
accessible.

Step 4: Create Department Entity Class

Create a Java class Department in the package com.example.model with Hibernate

annotations:

java

package com.example.model;

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

@Entity
@Table(name = "department")
public class Department {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@Column(name = "name")
private String name;

@OneToMany(mappedBy = "department", cascade = CascadeType.ALL)

private List<Employee> employees = new ArrayList<>();
 // Constructors, getters, setters
}

Step 5: Update Employee Entity Class

Update the Employee class to include a ManyToOne relationship with Department:

java

package com.example.model;

import javax.persistence.*;

@Entity
@Table(name = "employee")
public class Employee {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@Column(name = "name")
private String name;

@Column(name = "salary")
private double salary;

@ManyToOne
@JoinColumn(name = "department_id")
private Department department;

// Constructors, getters, setters

}

Step 6: Insert Sample Data with Relationships

Update the sample data insertion code to include relationships between Department
and Employee:

java

public class App {

public static void main(String[] args) {
// Create session factory
SessionFactory factory = new
Configuration().configure("hibernate.cfg.xml").buildSessionFactory();

// Create session
Session session = factory.openSession();

// Begin transaction
Transaction transaction = session.beginTransaction();

// Create departments
Department department1 = new Department();
department1.setName("Engineering");

Department department2 = new Department();

 department2.setName("Marketing");

session.save(department1);
session.save(department2);

// Create employees and assign them to departments

Employee employee1 = new Employee();
employee1.setName("John Doe");
employee1.setSalary(50000);
employee1.setDepartment(department1);

Employee employee2 = new Employee();

employee2.setName("Jane Smith");
employee2.setSalary(60000);
employee2.setDepartment(department1);

Employee employee3 = new Employee();

employee3.setName("Mike Johnson");
employee3.setSalary(55000);
employee3.setDepartment(department2);

session.save(employee1);
session.save(employee2);
session.save(employee3);

// Commit transaction
transaction.commit();

// Close session
session.close();

// Close session factory

factory.close();
}
}

Step 7: CRUD Operations

You can now perform CRUD operations on Employee and Department entities. For
example, to retrieve all employees in a department:

java

// Assuming departmentId is the ID of the department

Department department = session.get(Department.class, departmentId);
List<Employee> employees = department.getEmployees();
for (Employee employee : employees) {
System.out.println("Employee Name: " + employee.getName());
}

Similarly, you can perform operations like updating and deleting entities as
needed.

With these additions, your application now includes multiple entities,

relationships between them, and basic CRUD operations.
SK
includes multiple entities, relationships between them, and basic CRUD operations.
ChatGPT
Certainly! Let's expand the example to include multiple entities, relationships
between them, and basic CRUD operations for Employee, Department, and User.
Step 4: Create User Entity Class

Create a Java class User in the package com.example.model with Hibernate

annotations:

java

package com.example.model;

import javax.persistence.*;

@Entity
@Table(name = "user")
public class User {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@Column(name = "username")
private String username;

@Column(name = "email")
private String email;

// Constructors, getters, setters

}

Step 5: Update Employee Entity Class

Update the Employee class to include a OneToOne relationship with User:

java

package com.example.model;

import javax.persistence.*;

@Entity
@Table(name = "employee")
public class Employee {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@Column(name = "name")
private String name;

@Column(name = "salary")
private double salary;

@OneToOne
@JoinColumn(name = "user_id")
private User user;

// Constructors, getters, setters

}

Step 6: Update Department Entity Class

Update the Department class to include a OneToMany relationship with Employee:

java

package com.example.model;

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

@Entity
@Table(name = "department")
public class Department {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@Column(name = "name")
private String name;

@OneToMany(mappedBy = "department", cascade = CascadeType.ALL)

private List<Employee> employees = new ArrayList<>();

// Constructors, getters, setters

}

Step 7: CRUD Operations

Now, let's perform CRUD operations on Employee, Department, and User entities.

java

public class App {

public static void main(String[] args) {
// Create session factory
SessionFactory factory = new
Configuration().configure("hibernate.cfg.xml").buildSessionFactory();

// Create session
Session session = factory.openSession();

// Begin transaction
Transaction transaction = session.beginTransaction();

// Create and save a user

User user = new User();
user.setUsername("john_doe");
user.setEmail("john@example.com");
session.save(user);

// Create and save a department

Department department = new Department();
department.setName("Engineering");
session.save(department);
 // Create and save an employee associated with the user and department
Employee employee = new Employee();
employee.setName("John Doe");
employee.setSalary(50000);
employee.setUser(user);
employee.setDepartment(department);
session.save(employee);

// Commit transaction
transaction.commit();

// Retrieve an employee by ID
transaction = session.beginTransaction();
Employee retrievedEmployee = session.get(Employee.class, employee.getId());
System.out.println("Retrieved Employee: " + retrievedEmployee.getName());

// Update employee details

retrievedEmployee.setSalary(55000);
session.update(retrievedEmployee);
transaction.commit();

// Delete an employee
transaction = session.beginTransaction();
session.delete(retrievedEmployee);
transaction.commit();

// Close session
session.close();

// Close session factory

factory.close();
}
}