Understanding Entity Mapping Annotations in Hibernate

Course: Advanced Java Training

Topic: Understanding Entity Mapping Annotations

Course Link: Advanced Java Training Course

Demo Link: Register for a Course Demo

Website: JustAcademy Official Website

1. Introduction to Entity Mapping Annotations

Hibernate is an Object-Relational Mapping (ORM) framework that connects Java objects with relational database tables. Instead of manually writing SQL statements for every database operation, developers can define Java entity classes and use Hibernate to map their fields to database columns.

Entity mapping annotations are special Java annotations that describe how a class, its fields, and its relationships correspond to database structures. These annotations help Hibernate understand how to create, retrieve, update, and delete persistent data.

Modern Hibernate applications commonly use annotations from the jakarta.persistence package. Older applications may use the javax.persistence package, so the imports must match the versions of Hibernate and the persistence API used by the project.

Example of Object-Relational Mapping

Consider a Java class named Student. Its objects contain student information, while a relational database stores that information in a table named students.

Hibernate uses the mapping annotations to determine how the Java attributes correspond to database columns.

2. Learning Objectives

• Understand the purpose of entity mapping annotations.
• Learn how to map Java classes to database tables.
• Understand primary key and identifier generation annotations.
• Map Java fields to database columns.
• Configure nullability, uniqueness, length, and SQL column definitions.
• Understand field-based and property-based access.
• Map relationships between entities.
• Use embedded objects, enumerations, and transient fields.
• Identify common mapping errors and apply best practices.

3. What Is an Entity?

An entity is a Java class whose objects can be stored and managed by a persistence provider such as Hibernate. An entity usually represents a database table, and each persisted entity instance generally represents a row in that table.

An entity class must satisfy important requirements:

• It must be annotated with @Entity.
• It must have a primary key mapped using @Id or @EmbeddedId.
• It must have a public or protected no-argument constructor.
• The entity class must not be final, and persistent fields and methods must not be final.
• It must be included in the persistence configuration or discovered by the framework.

Basic Entity Example

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

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

    @Id
    private Long studentId;

    private String studentName;
    private String email;

    public Student() {
    }

    public Long getStudentId() {
        return studentId;
    }

    public void setStudentId(Long studentId) {
        this.studentId = studentId;
    }

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

In this example, @Entity declares the class as a persistent entity, @Table specifies the database table, and @Id identifies the primary key.

4. Important Entity Mapping Annotations

The Jakarta Persistence API provides annotations for mapping entity classes, identifiers, attributes, relationships, and embedded values. Hibernate implements these mapping rules and provides additional framework-specific features.

5. Understanding the @Entity Annotation

The @Entity annotation tells Hibernate that a class should be managed as a persistent entity. Without it, an ordinary Java class is not automatically treated as an entity.

Syntax

import jakarta.persistence.Entity;

@Entity
public class Employee {
    // Persistent attributes
}

Specifying an Entity Name

An optional entity name can be assigned using the name attribute. This name is used in JPQL queries and is not necessarily the database table name.

@Entity(name = "EmployeeRecord")
public class Employee {
    // Fields and methods
}

For example, a JPQL query may refer to the entity as EmployeeRecord. The entity name and the physical database table name serve different purposes.

6. Understanding the @Table Annotation

The @Table annotation specifies the database table associated with an entity. If it is omitted, the persistence provider applies its default table naming rules.

Example

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

@Entity
@Table(name = "employee_details")
public class Employee {
    // Entity attributes
}

Common @Table Attributes

Example with Schema and Unique Constraint

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;

@Entity
@Table(
    name = "employees",
    schema = "company",
    uniqueConstraints = {
        @UniqueConstraint(
            name = "uk_employee_email",
            columnNames = {"email"}
        )
    }
)
public class Employee {

    @Column(name = "email", nullable = false)
    private String email;

    public Employee() {
    }
}

Schema and constraint creation depend on database support and the application's schema-generation configuration. In production systems, database migrations are commonly used to manage schema changes.

7. Understanding @Id and Primary Keys

The @Id annotation identifies the primary key of an entity. A primary key uniquely identifies a row and allows Hibernate to track entity identity.

Example

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

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

    @Id
    private Long departmentId;

    private String departmentName;

    public Department() {
    }
}

In this example, departmentId is the primary key. Its value must be supplied by the application or generated using an appropriate identifier strategy.

Composite Primary Keys

When a record requires multiple fields to form its identity, a composite key can be mapped using @EmbeddedId with an @Embeddable key class or, in suitable cases, @IdClass. Composite key classes must follow the persistence provider's requirements, including implementing equality and hash-code behavior consistently.

8. Understanding @GeneratedValue

The @GeneratedValue annotation configures automatic generation of primary key values. It is normally used with @Id.

Example

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 productId;

    private String productName;

    public Product() {
    }
}

Identifier Generation Strategies

The best strategy depends on the database platform, performance needs, and application architecture. Avoid assuming that every database supports every strategy in the same way.

9. Understanding @Column

The @Column annotation customizes how a Java attribute maps to a database column. It is useful when Java field names and database column names differ or when the column requires specific constraints.

Example

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

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

    @Id
    private Long id;

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

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

    public Customer() {
    }
}

Important @Column Attributes

Important: mapping attributes such as nullable, unique, and length primarily describe mapping and schema-generation behavior. They do not automatically guarantee that an existing production database already has the matching constraint. Use database constraints and migrations where data integrity matters.

10. Understanding @Basic

The @Basic annotation describes the mapping of a basic attribute. Basic attributes include types such as strings, numeric wrappers, booleans, and many standard Java date/time types.

import jakarta.persistence.Basic;
import jakarta.persistence.Column;

@Basic(optional = false)
@Column(name = "first_name", nullable = false)
private String firstName;

@Basic is optional for many ordinary persistent fields because basic mapping is the default. The optional setting expresses whether the attribute is expected to be optional in the object model, while the column's nullable attribute concerns the database column mapping.

11. Understanding @Transient

The @Transient annotation marks a field or property that should not be persisted. It is useful for temporary data, calculated values, display-only fields, or values derived from other attributes.

Example

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

@Entity
public class OrderItem {

    @Id
    private Long id;

    private double unitPrice;
    private int quantity;

    @Transient
    private double displayedTotal;

    public OrderItem() {
    }

    public double getDisplayedTotal() {
        return unitPrice * quantity;
    }
}

The calculated total can be derived whenever needed and does not need to be stored as a separate database column. If the value must be searchable or historically preserved, consider whether it should instead be persisted.

12. Mapping Enumerations with @Enumerated

Java enums represent a fixed set of values. The @Enumerated annotation controls how an enum attribute is stored in the database.

Enum Definition

public enum EmployeeStatus {
    ACTIVE,
    ON_LEAVE,
    RESIGNED
}

Mapping as a String

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

@Entity
public class EmployeeRecord {

    @Id
    private Long id;

    @Enumerated(EnumType.STRING)
    @Column(name = "employee_status", length = 20)
    private EmployeeStatus status;

    public EmployeeRecord() {
    }
}

STRING versus ORDINAL

For many business applications, EnumType.STRING is the clearer choice. If enum names are changed later, coordinate the code changes with existing database values.

13. Mapping Date and Time Attributes

Java applications often need to store dates and times such as registration dates, order timestamps, and appointment times. Modern Java Time types are generally preferred because they represent date and time concepts clearly.

Example Using Java Time

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import java.time.LocalDate;
import java.time.LocalDateTime;

@Entity
public class Registration {

    @Id
    private Long id;

    private LocalDate registrationDate;
    private LocalDateTime createdAt;

    public Registration() {
    }
}

Types such as LocalDate, LocalDateTime, and Instant are commonly mapped without using @Temporal. The older @Temporal annotation is intended for legacy java.util.Date and java.util.Calendar mappings.

14. Understanding @Temporal for Legacy Date Types

When an application uses legacy date/time classes, @Temporal specifies whether the attribute should be mapped as a date, time, or timestamp.

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Temporal;
import jakarta.persistence.TemporalType;
import java.util.Date;

@Entity
public class LegacyEvent {

    @Id
    private Long id;

    @Temporal(TemporalType.DATE)
    private Date eventDate;

    @Temporal(TemporalType.TIMESTAMP)
    private Date createdAt;

    public LegacyEvent() {
    }
}

Use Java Time types in new code where practical. Choose timestamp and time-zone handling carefully, because database behavior and JDBC configuration can affect how values are stored and retrieved.

15. Understanding @Embeddable and @Embedded

Sometimes an entity contains a group of related values that should be represented by a reusable Java class but do not require a separate entity identity. Examples include addresses, monetary amounts, and contact details. Such objects can be mapped with @Embeddable and @Embedded.

Step 1: Create an Embeddable Class

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;
    }
}

Step 2: Embed the Class in an Entity

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

@Entity
@Table(name = "office_locations")
public class OfficeLocation {

    @Id
    private Long id;

    @Embedded
    private Address address;

    public OfficeLocation() {
    }
}

In a typical mapping, the embedded object's fields become columns in the owning entity's table. When multiple embedded objects use similar field names, @AttributeOverride and @AttributeOverrides can customize their column names.

16. Mapping Entity Relationships

Real-world database applications commonly contain relationships between entities. For example, a department may have several employees, and each employee may belong to one department.

Relationship Annotations

Example: Many Employees Belong to One Department

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
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
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String departmentName;

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

    public Department() {
    }
}

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

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

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

    private String employeeName;

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

    public Employee() {
    }
}

Here, the employees table contains the department_id foreign key. The Employee side owns the association because it declares the join column. The mappedBy attribute on Department points to the owning field named department in the Employee entity.

For bidirectional relationships, keep both sides synchronized in application code. Also review cascading, fetch behavior, and orphan-removal requirements before configuring them.

17. Understanding @JoinColumn

The @JoinColumn annotation specifies the foreign key column used to connect an entity to another entity.

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

The name attribute identifies the foreign key column in the table that owns the association. Other options can customize the referenced column and schema-generation constraints. Ensure the database contains the corresponding foreign key and that its nullability matches the application's business rules.

18. Understanding @JoinTable

A join table stores associations between entities. It is commonly used for many-to-many relationships and can also be used for certain one-to-one or one-to-many mappings.

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

@Entity
public class StudentProfile {

    @Id
    private Long id;

    @ManyToMany
    @JoinTable(
        name = "student_subjects",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "subject_id")
    )
    private Set subjects = new HashSet<>();

    public StudentProfile() {
    }
}

The join table student_subjects connects students and subjects. The joinColumns attribute describes the foreign key referring to the owning entity, while inverseJoinColumns describes the foreign key referring to the other entity.

19. Understanding @Version for Optimistic Locking

The @Version annotation enables optimistic locking. Hibernate uses the version attribute to detect whether another transaction has changed a record since it was read.

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Version;

@Entity
public class InventoryItem {

    @Id
    private Long id;

    private int availableQuantity;

    @Version
    private Long version;

    public InventoryItem() {
    }
}

When Hibernate updates a versioned entity, it checks the version value and updates it as part of the operation. If a conflicting update is detected, the transaction may fail with an optimistic locking exception. The application should handle the conflict appropriately instead of silently overwriting newer data.

20. Field Access and Property Access

Hibernate can access persistent state through fields or JavaBean properties. The placement of mapping annotations generally determines the access strategy unless it is explicitly configured.

Field Access

@Entity
public class Course {

    @Id
    private Long id;

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

    public Course() {
    }
}

In this example, the annotations are placed on fields. Hibernate accesses the mapped state through the fields according to the field-access mapping.

Property Access

@Entity
public class Course {

    private Long id;
    private String title;

    public Course() {
    }

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

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

    @Column(name = "course_title")
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }
}

Here, mapping annotations are placed on getter methods, so property access is used. Avoid casually mixing field and property annotations in the same entity hierarchy. If mixed access is necessary, use @Access explicitly and follow its rules.

21. Complete Example: Mapping a Course Entity

The following example combines several common mapping annotations into one entity. It uses Jakarta Persistence imports and assumes that the project has a compatible Hibernate and persistence API configuration.

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import jakarta.persistence.Transient;
import jakarta.persistence.Version;
import java.math.BigDecimal;
import java.time.LocalDate;

enum CourseStatus {
    ACTIVE,
    UPCOMING,
    COMPLETED
}

@Entity
@Table(name = "training_courses")
public class TrainingCourse {

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

    @Column(name = "course_name", nullable = false, length = 120)
    private String courseName;

    @Column(name = "course_fee", precision = 10, scale = 2)
    private BigDecimal fee;

    @Column(name = "start_date")
    private LocalDate startDate;

    @Enumerated(EnumType.STRING)
    @Column(name = "course_status", nullable = false, length = 20)
    private CourseStatus status;

    @Version
    private Long version;

    @Transient
    private String displayLabel;

    public TrainingCourse() {
    }

    public Long getId() {
        return id;
    }

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    public BigDecimal getFee() {
        return fee;
    }

    public void setFee(BigDecimal fee) {
        this.fee = fee;
    }

    public LocalDate getStartDate() {
        return startDate;
    }

    public void setStartDate(LocalDate startDate) {
        this.startDate = startDate;
    }

    public CourseStatus getStatus() {
        return status;
    }

    public void setStatus(CourseStatus status) {
        this.status = status;
    }
}

Explanation of the Example

• @Entity makes TrainingCourse a persistent entity.
• @Table maps the entity to training_courses.
• @Id defines the primary key.
• @GeneratedValue configures automatic identifier generation.
• @Column customizes column names and mapping constraints.
• @Enumerated(EnumType.STRING) stores the course status as a string.
• @Version supports optimistic locking.
• @Transient prevents the display-only attribute from being persisted.

For production use, validate the database schema, enum values, column constraints, and identifier strategy against the actual database platform.

22. How Hibernate Uses Mapping Annotations

When a Hibernate application starts, it discovers or registers its mapped entity classes and builds metadata from their annotations and configuration. Hibernate uses this metadata to understand entity identity, column mappings, associations, and persistence behavior.

1. Entity discovery: Hibernate identifies entity classes included in the persistence unit or session factory configuration.
2. Metadata processing: It reads annotations such as @Entity, @Id, @Column, and relationship annotations.
3. Mapping validation: It validates many mapping requirements and may report invalid or inconsistent mappings during startup.
4. SQL generation: Hibernate prepares SQL statements for supported operations based on the mapping metadata.
5. Persistence operations: Entities can be saved, retrieved, updated, and deleted through the Hibernate or Jakarta Persistence APIs.
6. Relationship handling: Hibernate manages configured associations, foreign keys, cascading operations, and fetching behavior.

Annotations define mapping metadata; they do not automatically guarantee that a database schema has been created or migrated correctly. That depends on configuration and database management practices.

23. Common Entity Mapping Errors and Solutions

24. Best Practices for Entity Mapping

• Use explicit @Table and @Column names when consistent naming across environments is important.
• Define a stable primary key for every entity.
• Choose identifier generation strategies that fit the target database.
• Prefer EnumType.STRING when readable and stable enum persistence is required.
• Use @Transient for values that should not be stored.
• Use Java Time classes for new date and time mappings where appropriate.
• Keep the owning side of bidirectional associations clear and synchronize both sides in helper methods.
• Configure cascade operations only when the lifecycle of related entities truly depends on the parent.
• Use lazy fetching thoughtfully and monitor for N+1 query problems.
• Use database constraints and migration tools to maintain production schema integrity.
• Use @Version for entities that need optimistic concurrency control.
• Avoid placing mapping annotations on both fields and getters without a deliberate access strategy.
• Keep entity methods such as equals(), hashCode(), and toString() safe around generated identifiers and lazy associations.
• Test mappings against the actual database dialect or a sufficiently representative test environment.

25. Practical Exercise

Exercise: Create a Training Management Entity Model

Build a small Advanced Java application that manages training courses and instructors. Use the mapping annotations covered in this lesson.

Requirements

1. Create an Instructor entity with an automatically generated identifier.
2. Map the instructor table using @Table.
3. Map the instructor's name and email using @Column.
4. Configure the email column to be unique and non-null in the intended schema.
5. Create a TrainingCourse entity with a course title, fee, start date, and status.
6. Use @Enumerated(EnumType.STRING) for the course status.
7. Add a version attribute using @Version.
8. Create an association between courses and instructors using an appropriate relationship annotation.
9. Persist sample entities and verify the resulting records and foreign keys.
10. Test what happens when a required value is missing or a duplicate email is submitted.

Expected Learning Outcome

After completing this exercise, you should be able to create entity classes, define identifiers, configure column mappings, represent relationships, and diagnose common mapping problems.

26. Interview Questions and Answers

Q1. What is entity mapping in Hibernate?

Answer: Entity mapping defines how Java classes and their attributes correspond to relational database tables and columns. Hibernate uses the mapping metadata to manage persistence operations.

Q2. What is the purpose of @Entity?

Answer: It declares that a Java class is a persistent entity managed by a persistence provider.

Q3. What is the difference between @Entity and @Table?

Answer: @Entity identifies a persistent Java class, while @Table specifies the physical database table mapped to that class.

Q4. Why is @Id required?

Answer: It identifies the primary key attribute that distinguishes one entity instance from another.

Q5. What does @GeneratedValue do?

Answer: It configures how identifier values are generated, often using a database identity column or sequence.

Q6. What is the purpose of @Column?

Answer: It customizes the mapping of a Java attribute to a database column, including the column name and certain mapping constraints.

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

Answer: @Transient tells the persistence provider not to persist an attribute. The Java transient keyword is a language feature associated with Java serialization and also excludes a field from ordinary JPA field persistence.

Q8. What is the difference between @Embedded and @Embeddable?

Answer: @Embeddable declares a reusable value class, while @Embedded marks the attribute in an entity that uses that value class.

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

Answer: @ManyToOne maps many records to one associated entity, while @OneToMany maps one entity to a collection of associated entities.

Q10. What does mappedBy mean?

Answer: In a bidirectional association, mappedBy identifies the attribute on the owning side that defines the relationship mapping.

Q11. What is the difference between EnumType.STRING and EnumType.ORDINAL?

Answer: STRING stores the enum constant's name, whereas ORDINAL stores its position. STRING avoids changes in enum ordering from changing the meaning of stored numeric positions.

Q12. What is @Version used for?

Answer: It supports optimistic locking by detecting conflicting updates to a versioned entity.

Q13. What is the difference between field access and property access?

Answer: Field access places mapping annotations on instance variables; property access places them on getter methods. The access strategy determines how the persistence provider reads and writes persistent state.

Q14. Does @Column(nullable = false) automatically update an existing database?

Answer: No. It describes the mapping and can influence schema generation, but an existing database must be changed through schema management or migration when necessary.

Q15. Why should entity mapping be tested?

Answer: Testing helps detect invalid mappings, schema mismatches, incorrect relationship ownership, constraint violations, and persistence issues before deployment.

27. Quick Revision Checklist

• @Entity declares a persistent entity class.
• @Table specifies the database table.
• @Id identifies the primary key.
• @GeneratedValue configures identifier generation.
• @Column customizes column mapping.
• @Transient excludes an attribute from persistence.
• @Enumerated configures enum persistence.
• @Embedded and @Embeddable map reusable value objects.
• @OneToOne, @OneToMany, @ManyToOne, and @ManyToMany define entity relationships.
• @JoinColumn and @JoinTable configure relationship storage.
• @Version enables optimistic locking.
• Field access and property access determine where mapping annotations belong.
• Database migrations and constraints remain important even when annotations describe the intended schema.

28. Conclusion

Entity mapping annotations are essential for connecting Java domain models with relational databases in Hibernate. By understanding annotations such as @Entity, @Table, @Id, @GeneratedValue, and @Column, developers can define clear and maintainable mappings. Relationship annotations, embedded objects, enum mappings, and version fields provide further control over how application data is represented and managed.

Good mapping practices include selecting appropriate identifiers, validating database constraints, choosing a consistent access strategy, and testing entity relationships. These skills form an important foundation for building reliable Advanced Java applications using Hibernate.

Additional Learning Resources

Explore the Advanced Java Training Course for further learning.

Interested in course details or a guided introduction? Register for a course demo.

Visit the JustAcademy website to explore additional training resources.