Creating Hibernate Entities and Mapping Configurations

Course: Advance Java Training

Topic: Creating Hibernate Entities and Mapping Configurations

Course Link: Advance Java Training – JustAcademy

Demo Link: Register for a Course Demo

Website: JustAcademy Official Website

1. Introduction to Hibernate Entities and Mapping Configurations

Hibernate is a Java Object-Relational Mapping (ORM) framework that simplifies communication between Java applications and relational databases. It allows developers to represent database records as Java objects and define how these objects correspond to database tables and columns.

A Hibernate entity is a Java class whose objects can be stored, retrieved, updated, and deleted in a database. Mapping configuration defines the relationship between the Java entity and the database schema, including table names, column names, primary keys, relationships, and constraints.

For example, an Employee entity can represent an employee record in a MySQL employees table. Hibernate uses mapping metadata to determine how an Employee object should be converted into database operations.

Learning Objectives

• Understand Hibernate entities and their role in persistence.
• Create entity classes using Jakarta Persistence annotations.
• Configure primary keys and identifier generation strategies.
• Map Java fields to database columns.
• Understand annotation-based and XML-based mapping configurations.
• Map relationships between entities.
• Configure Hibernate to recognize entity classes.
• Perform CRUD operations using mapped entities.
• Identify common mapping errors and apply best practices.

2. What Is a Hibernate Entity?

An entity is a Java class that represents a persistent domain object. Each entity instance usually corresponds to a row in a relational database table, while its persistent attributes correspond to columns.

Hibernate implements the Jakarta Persistence (JPA) specification and also provides its own native APIs. In modern projects, entity annotations generally come from the jakarta.persistence package.

Characteristics of an Entity

• It is normally declared using the @Entity annotation or an XML mapping.
• It must have an identifier defined using @Id or an equivalent supported mapping.
• It typically has a public or protected no-argument constructor.
• It contains persistent attributes representing database information.
• It can define relationships with other entities.
• Its instances can be managed by a Hibernate persistence context.

Example of an Entity Class

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

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

    @Id
    private Long id;

    private String name;
    private String department;

    public Employee() {
    }

    public Employee(Long id, String name, String department) {
        this.id = id;
        this.name = name;
        this.department = department;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }
}

Explanation: The @Entity annotation marks Employee as a persistent entity. The @Table annotation maps it to the employees table, and @Id identifies the primary key. The remaining persistent fields are mapped to columns by default.

3. Understanding Object-Relational Mapping

Object-Relational Mapping (ORM) connects the object-oriented programming model with the relational database model. Java uses classes, objects, and attributes, whereas relational databases store information in tables, rows, and columns.

Benefits of ORM

• Reduces repetitive JDBC and result-set mapping code.
• Provides an object-oriented approach to database operations.
• Helps manage entity relationships.
• Supports change tracking for managed entities.
• Can improve database portability when mappings and queries are designed appropriately.

4. Important Hibernate Mapping Annotations

Annotations provide mapping metadata directly within Java classes. They are commonly used because they keep entity definitions and their database mappings close together.

5. Creating an Entity Step by Step

Step 1: Create a Java Project

Create a Java project using Maven or Gradle. Add a Hibernate ORM dependency, the appropriate Jakarta Persistence API version through the dependency setup, and the JDBC driver for your database. Use compatible versions of Hibernate, Java, and the database driver.

Step 2: Create the Entity Package

Organize entity classes in a dedicated package, such as com.example.entity. Keeping entities organized helps maintain a clear application structure.

Step 3: Define the Entity Class

Create a Java class with fields representing the data that must be stored in the database.

package com.example.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

@Entity
@Table(name = "products")
public class Product {

    @Id
    private Long id;

    private String name;
    private double price;

    public Product() {
    }

    public Product(Long id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

Step 4: Configure the Primary Key

Every entity needs an identifier that uniquely identifies each persistent instance. In this example, the id field is the primary key. Its value must be supplied by the application because no generated-value strategy is configured.

Step 5: Define the Table and Columns

Use @Table to select the database table and @Column to customize column names, nullability, uniqueness, length, and other supported properties.

Step 6: Register the Entity

Ensure that the entity is discovered by the persistence unit or explicitly registered with Hibernate. The exact process depends on whether the application uses native Hibernate bootstrap, Jakarta Persistence configuration, or a framework such as Spring.

6. Mapping Entities to Database Tables

The @Table annotation specifies the primary table associated with an entity. If it is omitted, the persistence provider derives the table name using its naming rules.

Example: Custom Table Name

@Entity
@Table(name = "customer_records")
public class Customer {

    @Id
    private Long id;

    private String name;

    public Customer() {
    }
}

Here, the Customer entity maps to the customer_records table rather than relying on the default table-name mapping.

Useful @Table Options

• name: Specifies the table name.
• schema: Specifies the database schema when applicable.
• catalog: Specifies the database catalog when applicable.
• uniqueConstraints: Declares table-level uniqueness constraints.
• indexes: Declares index metadata for supported schema-generation workflows.

Schema and catalog names should be configured deliberately. Avoid hardcoding environment-specific names if the application must run across multiple database environments.

7. Mapping Java Fields to Database Columns

The @Column annotation customizes the mapping between a Java attribute and a database column. Without it, the persistence provider generally derives the column name from the persistent attribute and its naming rules.

Example

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

    @Id
    private Long id;

    @Column(name = "employee_name", nullable = false, length = 100)
    private String name;

    @Column(name = "email_address", unique = true, length = 150)
    private String email;

    @Column(name = "monthly_salary", precision = 12, scale = 2)
    private java.math.BigDecimal salary;

    public Employee() {
    }
}

Common @Column Properties

Important: Annotation settings do not necessarily change an existing production database schema automatically. Database constraints must exist in the actual schema for the database to enforce them.

8. Primary Keys and Identifier Generation

A primary key uniquely identifies a row in a table. Hibernate requires every entity to have an identifier mapping so it can distinguish persistent entity instances.

Using @Id

@Id
private Long id;

Use this approach when the application assigns the identifier or when the mapping is designed for a pre-existing identifier strategy.

Using @GeneratedValue

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

@Entity
@Table(name = "products")
public class Product {

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

    private String name;
    private double price;

    public Product() {
    }
}

Identifier Generation Strategies

The best identifier strategy depends on the database, Hibernate version, schema design, and performance requirements. Test identifier generation against the database used by the application.

9. Field Access and Property Access

Hibernate can access persistent state through fields or through JavaBean-style properties. The placement of mapping annotations commonly determines the access strategy.

Field Access Example

@Entity
public class Student {

    @Id
    private Long id;

    private String name;

    public Student() {
    }
}

In this example, the identifier annotation is placed on the field, so field access is normally used.

Property Access Example

@Entity
public class Student {

    private Long id;
    private String name;

    public Student() {
    }

    @Id
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Here, the identifier annotation is placed on a getter, so property access is normally used.

Best Practices

• Choose an access strategy consistently for each entity hierarchy.
• Avoid placing mapping annotations on both fields and getters without an explicit and appropriate access configuration.
• Use getters and setters where required by the chosen access strategy and application design.
• Keep entity invariants and business rules in mind when exposing setters.

10. Mapping Enumerated Types

Java enums represent a fixed set of named values, such as employee status, order status, or user roles. The @Enumerated annotation specifies how an enum attribute is stored.

Example

import jakarta.persistence.Entity;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import jakarta.persistence.Id;

public enum EmployeeStatus {
    ACTIVE,
    INACTIVE,
    ON_LEAVE
}

@Entity
public class StaffMember {

    @Id
    private Long id;

    @Enumerated(EnumType.STRING)
    private EmployeeStatus status;

    public StaffMember() {
    }
}

Using EnumType.STRING stores the enum's name, such as ACTIVE. This is generally safer than ordinal storage when enum ordering might change, although renaming enum constants requires a corresponding data migration or compatibility plan.

11. Excluding Fields with @Transient

Sometimes a Java class contains a value that is calculated at runtime and should not be stored in the database. The @Transient annotation marks an attribute as non-persistent.

Example

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Transient;

@Entity
public class Product {

    @Id
    private Long id;

    private double price;

    @Transient
    private double discountAmount;

    public Product() {
    }

    public double getFinalPrice() {
        return price - discountAmount;
    }
}

The discountAmount field is excluded from ORM persistence mapping. It can be used by application logic without requiring a corresponding database column.

12. Mapping Relationships Between Entities

Relational databases connect tables through primary keys and foreign keys. Hibernate maps these relationships to Java references and collections, making it possible to navigate related data using objects.

Common Relationship Types

13. Mapping a Many-to-One Relationship

A many-to-one relationship occurs when multiple records reference one parent record. For example, many employees may belong to the same department. The foreign key is commonly stored in the employees table.

Department Entity

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

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

    @Id
    private Long id;

    private String departmentName;

    public Department() {
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getDepartmentName() {
        return departmentName;
    }

    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }
}

Employee Entity with Foreign Key

import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;

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

    @Id
    private Long id;

    private String name;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "department_id")
    private Department department;

    public Employee() {
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }
}

The @ManyToOne annotation defines the association, and @JoinColumn specifies the foreign key column in the employees table.

14. Mapping a One-to-Many Relationship

A one-to-many relationship represents one parent record associated with multiple child records. A department can contain many employees.

Example

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
import java.util.ArrayList;
import java.util.List;

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

    @Id
    private Long id;

    private String departmentName;

    @OneToMany(mappedBy = "department")
    private List<Employee> employees = new ArrayList<>();

    public Department() {
    }

    public List<Employee> getEmployees() {
        return employees;
    }
}

The mappedBy attribute indicates that the Employee entity's department property owns the relationship. The foreign key is therefore mapped on the many-to-one side.

Maintaining Both Sides of a Bidirectional Relationship

public void addEmployee(Employee employee) {
    employees.add(employee);
    employee.setDepartment(this);
}

public void removeEmployee(Employee employee) {
    employees.remove(employee);
    employee.setDepartment(null);
}

These helper methods keep the Java object relationship consistent. Whether removing an employee should also delete the database record depends on the configured cascade and orphan-removal rules.

15. Mapping One-to-One Relationships

A one-to-one relationship connects one entity instance to another. For example, one user may have one profile.

Example

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.OneToOne;
import jakarta.persistence.Table;

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

    @Id
    private Long id;

    @OneToOne
    @JoinColumn(name = "profile_id", unique = true)
    private UserProfile profile;

    public User() {
    }
}

The profile_id column references a user profile. The uniqueness requirement prevents multiple users from referencing the same profile when the database constraint is created and enforced. The exact ownership design should reflect the intended schema.

16. Mapping Many-to-Many Relationships

A many-to-many relationship connects multiple records in one table with multiple records in another table. For example, students can enroll in multiple courses, and each course can contain multiple students.

Example

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.JoinTable;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToMany;
import jakarta.persistence.Table;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "students")
public class Student {

    @Id
    private Long id;

    private String name;

    @ManyToMany
    @JoinTable(
        name = "student_courses",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private Set<Course> courses = new HashSet<>();

    public Student() {
    }
}

The @JoinTable annotation defines the association table and its two foreign key columns. If the relationship requires extra attributes, such as enrollment date or grade, model the association table as its own entity instead of using a simple many-to-many mapping.

17. Embedded Objects and Reusable Value Types

An embeddable class groups related attributes that do not need their own entity identity. Its fields can be stored as columns in the table of the entity that embeds it.

Address Embeddable

import jakarta.persistence.Embeddable;

@Embeddable
public class Address {

    private String street;
    private String city;
    private String postalCode;

    public Address() {
    }

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getPostalCode() {
        return postalCode;
    }

    public void setPostalCode(String postalCode) {
        this.postalCode = postalCode;
    }
}

Embedding Address in Customer

import jakarta.persistence.Embedded;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;

@Entity
public class Customer {

    @Id
    private Long id;

    private String name;

    @Embedded
    private Address address;

    public Customer() {
    }
}

In this example, the Address fields are mapped into the Customer entity's table by default. Attribute overrides can be used when different embedded attributes need custom column names.

18. Annotation-Based Mapping vs XML Mapping

Hibernate supports more than one way to define entity mappings. Annotations are widely used for new projects, while XML mappings can be useful when mapping metadata needs to remain separate from Java source code.

19. Configuring Hibernate with XML

Hibernate configuration XML and entity mapping XML serve different purposes. A configuration file such as hibernate.cfg.xml commonly contains connection settings and mapping registrations. An entity mapping file defines how a Java class maps to tables and columns.

Example hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "https://hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">
            com.mysql.cj.jdbc.Driver
        </property>
        <property name="hibernate.connection.url">
            jdbc:mysql://localhost:3306/companydb
        </property>
        <property name="hibernate.connection.username">
            app_user
        </property>
        <property name="hibernate.connection.password">
            ${DB_PASSWORD}
        </property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <mapping class="com.example.entity.Employee"/>
    </session-factory>
</hibernate-configuration>

Important: The password placeholder is illustrative. Hibernate does not automatically replace ${DB_PASSWORD} in every configuration setup. Use an appropriate external configuration mechanism or secure secret provider. Do not commit real database credentials to source control.

Native Hibernate Bootstrap Example

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

    private static final SessionFactory SESSION_FACTORY =
        new Configuration()
            .configure("hibernate.cfg.xml")
            .buildSessionFactory();

    public static SessionFactory getSessionFactory() {
        return SESSION_FACTORY;
    }

    public static void shutdown() {
        SESSION_FACTORY.close();
    }
}

This example illustrates a simple native Hibernate bootstrap. Production applications should handle startup failures and application shutdown correctly. Framework-managed applications should generally use the framework's recommended configuration and lifecycle management instead of creating a competing SessionFactory.

20. XML Entity Mapping Example

Hibernate's native XML mapping format can describe an entity mapping separately from the Java class. The following is an illustrative legacy-style .hbm.xml mapping.

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "https://hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.example.entity.Employee"
           table="employees">
        <id name="id" column="id" type="long">
            <generator class="assigned"/>
        </id>
        <property name="name" column="employee_name"
                  type="string" not-null="true"/>
        <property name="department" column="department"
                  type="string"/>
    </class>
</hibernate-mapping>

This mapping assumes that the Employee class exposes compatible persistent properties and an identifier named id. The assigned generator means the application must assign the identifier. The XML mapping must also be registered or discovered using the configuration mechanism supported by the Hibernate version in use.

For new projects, Jakarta Persistence annotations or standard persistence XML are often the simplest choice. Native Hibernate mapping XML is more commonly encountered in existing applications and specialized mapping scenarios.

21. Registering Entities and Mapping Metadata

Creating an entity class is not enough; the persistence unit or Hibernate bootstrap process must recognize its mapping metadata. If an entity is not discovered or registered, queries and persistence operations may fail.

Common Registration Methods

• Declare the entity in the standard Jakarta Persistence configuration.
• Use package scanning in a framework that supports it.
• Register the annotated class through native Hibernate bootstrap APIs.
• Register an appropriate XML mapping resource.

Example: Registering an Annotated Entity

Configuration configuration = new Configuration();

configuration.configure("hibernate.cfg.xml");
configuration.addAnnotatedClass(Employee.class);

SessionFactory sessionFactory =
    configuration.buildSessionFactory();

This example uses Hibernate's native Configuration API. Depending on the Hibernate version and project setup, the entity may already be registered through XML or automatic discovery, so avoid unnecessary duplicate configuration.

22. Schema Generation and Database Configuration

Hibernate can use entity mappings to generate or validate database schema structures. This is useful during development and testing, but automatic schema changes must be handled cautiously in production environments.

Common Schema Settings

For production systems, use versioned database migration tools and reviewed schema changes. The precise configuration properties and behavior can vary with Hibernate version and bootstrap method.

23. Performing CRUD Operations with Mapped Entities

Once the entity is mapped and Hibernate is configured, the application can use Hibernate APIs to create, read, update, and delete persistent objects.

Create an Entity

try (var session = sessionFactory.openSession()) {
    var transaction = session.beginTransaction();

    Product product = new Product();
    product.setId(201L);
    product.setName("Keyboard");
    product.setPrice(1499.00);

    session.persist(product);
    transaction.commit();
}

This example assumes that Product uses an application-assigned identifier. If its identifier is generated by the database, do not manually assign the identifier unless the mapping and database design specifically allow it.

Read an Entity

try (var session = sessionFactory.openSession()) {
    Product product = session.find(Product.class, 201L);

    if (product != null) {
        System.out.println(product.getName());
        System.out.println(product.getPrice());
    }
}

Update a Managed Entity

try (var session = sessionFactory.openSession()) {
    var transaction = session.beginTransaction();

    Product product = session.find(Product.class, 201L);

    if (product != null) {
        product.setPrice(1299.00);
    }

    transaction.commit();
}

Hibernate can detect changes to a managed entity and synchronize them during flushing. The transaction is committed to complete the database update.

Delete an Entity

try (var session = sessionFactory.openSession()) {
    var transaction = session.beginTransaction();

    Product product = session.find(Product.class, 201L);

    if (product != null) {
        session.remove(product);
    }

    transaction.commit();
}

These examples omit repetitive rollback handling for readability. Real applications should handle failures and roll back active transactions appropriately. Framework-managed transaction boundaries are often preferable in larger applications.

24. Common Entity Mapping Errors and Solutions

25. Best Practices for Entity Design and Mapping

• Give every entity a clear domain purpose and a valid identifier.
• Use consistent naming conventions for entity classes, tables, and columns.
• Choose field access or property access deliberately.
• Use appropriate Java types, such as BigDecimal for monetary amounts requiring decimal precision.
• Use explicit column mappings when database names differ from Java attributes.
• Define relationships according to the real database design.
• Understand the owning side of bidirectional associations.
• Avoid unnecessary cascade operations, particularly cascade remove.
• Use lazy fetching thoughtfully and avoid uncontrolled queries.
• Keep database schema changes under version control using migration scripts.
• Do not expose database credentials in source code or public repositories.
• Test entity mappings against the target database engine.
• Use SQL logging and query inspection to troubleshoot persistence issues.
• Keep entities free from unnecessary infrastructure dependencies where practical.

26. Practical Exercises

Exercise 1: Create a Student Entity

• Create a Student class with id, name, email, and course fields.
• Map the class to a students table.
• Configure the primary key and appropriate column constraints.
• Register the entity with Hibernate.

Exercise 2: Configure Identifier Generation

• Use a generated identifier for a Product entity.
• Persist multiple products.
• Verify that identifiers are assigned correctly.
• Test the configuration against your chosen database.

Exercise 3: Map Entity Relationships

• Create Department and Employee entities.
• Map a many-to-one association using @JoinColumn.
• Add a one-to-many collection using mappedBy.
• Test persistence, retrieval, and relationship consistency.

Exercise 4: Compare Annotation and XML Mapping

• Create an entity using annotations.
• Explore a separate XML mapping configuration.
• Register the mapping metadata with Hibernate.
• Compare readability and maintainability for each approach.

Mini Project: Product Management System

Create a Product Management System with the following requirements:

• Define a Product entity with id, name, price, and category.
• Map the entity to a products table.
• Configure primary key generation and column constraints.
• Implement create, read, update, and delete operations.
• Use transactions for database modifications.
• Validate mappings and verify the generated SQL.

27. Interview Questions and Answers

Q1. What is a Hibernate entity?

Answer: A Hibernate entity is a Java class mapped to persistent database data. Its instances can be managed by Hibernate and synchronized with a relational database.

Q2. What is the purpose of the @Entity annotation?

Answer: It marks a Java class as an entity that can participate in ORM persistence.

Q3. What is the purpose of @Table?

Answer: It specifies the database table associated with an entity and can define additional table-level mapping metadata.

Q4. Why does an entity need an identifier?

Answer: An identifier uniquely distinguishes each persistent entity instance and maps to its primary key.

Q5. What is the difference between @Id and @GeneratedValue?

Answer: @Id identifies the primary key attribute. @GeneratedValue configures how its value is generated when a generated identifier strategy is used.

Q6. What is the purpose of @Column?

Answer: It customizes how an entity attribute maps to a database column, including its name and relevant schema constraints.

Q7. What is the difference between @Transient and Java's transient keyword?

Answer: @Transient from Jakarta Persistence excludes an attribute from ORM persistence. Java's transient keyword controls Java object serialization and can also affect default ORM field mapping, depending on the access strategy.

Q8. What is the difference between annotation-based and XML-based mapping?

Answer: Annotation-based mappings are defined in Java source code, whereas XML-based mappings store mapping metadata in external configuration files. The appropriate option depends on project requirements and compatibility.

Q9. What is the difference between @OneToMany and @ManyToOne?

Answer: @OneToMany represents one entity associated with multiple entities. @ManyToOne represents multiple entities associated with one entity.

Q10. What does mappedBy mean?

Answer: It identifies the attribute on the owning entity that manages a bidirectional association. The inverse side does not independently define the same foreign key mapping.

Q11. What is an embeddable class?

Answer: It is a reusable value type whose attributes are mapped as part of an owning entity rather than having an independent entity identity.

Q12. Can Hibernate automatically create database tables?

Answer: Yes. Hibernate supports schema-generation options based on entity mappings. Automatic schema generation is useful in development and testing, but reviewed migration scripts are generally safer for production.

Q13. What happens if an entity is not registered?

Answer: Hibernate may be unable to resolve its mapping metadata, leading to errors when the entity is queried or persisted.

Q14. What is the owning side of a relationship?

Answer: It is the side responsible for defining the database relationship mapping, often including the foreign key or join table. In a bidirectional association, the inverse side usually refers to it through mappedBy.

28. Quick Revision Checklist

• Understand ORM and the role of Hibernate entities.
• Know the requirements for creating entity classes.
• Understand @Entity, @Table, @Id, and @Column.
• Know common identifier generation strategies.
• Understand field access and property access.
• Know how to map enum attributes and transient fields.
• Understand one-to-one, one-to-many, many-to-one, and many-to-many relationships.
• Know the purpose of @JoinColumn, @JoinTable, and mappedBy.
• Understand annotation-based and XML-based mappings.
• Know how entities are registered with Hibernate.
• Understand schema generation and production migration practices.
• Practice CRUD operations and troubleshoot mapping errors.

29. Conclusion

Creating Hibernate entities and mapping configurations is a fundamental skill in Java persistence development. Entities represent persistent domain objects, while mapping metadata defines how those objects relate to database tables, columns, identifiers, and relationships.

By mastering entity annotations, identifier generation, relationship mapping, XML configuration, schema validation, and CRUD operations, developers can create maintainable applications that interact with relational databases effectively. Regular practice with real database schemas and SQL logs helps build confidence in troubleshooting and performance optimization.

Learn More with JustAcademy

Explore the Advance Java Training course to learn more about Java application development, Hibernate ORM, database integration, and enterprise application concepts.

To learn more about the course, register for a course demo.

Visit the JustAcademy website for additional training information and learning resources.