Implementation Steps of JPA List Mapping

Project Implementation of the List Mapping in JPA

1. Define the Entity

Define the entities with the appropriate relationships of the JPA application. For example, consider the entities Student and Course, the student can be enrolled in multiple courses and it can form one-to-many relationships.

Student Entity:

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "student", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<Course> courses = new ArrayList<>();

    // Getters and setters
}

Course Entity:

@Entity
public class Course {
    @Id
    private Long id;
    private String name;
    
    // Getters and setters
}

In the above example, the Student class represents the table in the database and the @OneToMany annotation establishes the one-to-many relationship between the Student and Course entities of the application.

2. Configure the Persistence

In the JPA application, we need to the configure the persistence settings either through the persistence.xml of the project.

<persistence-unit name="PersistenceUnit" transaction-type="RESOURCE_LOCAL">
    <!-- Entity classes -->
    <class>com.example.model.Student</class>
    <class>com.example.model.Course</class>

    <!-- Database connection properties -->
    <properties>
        <!-- Database connection details -->
    </properties>
</persistence-unit>

The XML file can configure the persistence unit named as the PersistenceUnit and it lists the entities classes to manage by the JPA application.

3. Define the Database Schema Generation

In JPA application, we can automatically the generate the database schema based on the entity definitions and it can manually create the database schema using DDL scripts of the application.

4. Using the EntityManager

EntityManager is the primary interface for interacting with persistence context and it provides the methods for the persisting, retrieving, deleting and updating the entities of the JPA application.

EntityManager em = JPAUtil.getEntityManager();
EntityTransaction tx = em.getTransaction();

try {
    tx.begin();

    // Create and persist entities
    // Perform operations like persist, merge, remove, etc.

    tx.commit();
} catch (Exception e) {
    if (tx != null && tx.isActive()) {
        tx.rollback();
    }
    e.printStackTrace();
} finally {
    em.close();
    JPAUtil.close();
}

5. Retrieving the Data

We can retrieve the data using the JPQL queries or the EntityManager methods of the application.

Example:

List<Student> students = em.createQuery("SELECT s FROM Student s", Student.class).getResultList();
for (Student student : students) {
    System.out.println("Student: " + student.getName());
    System.out.println("Courses Enrolled:");
    for (Course course : student.getCourses()) {
        System.out.println("- " + course.getName());
    }
}

The above code can retrieves the all students from the database along with their enrolled courses and it can demonstrate the use of the JPQL queries of the application.

Bidirectional vs Unidirectional Mapping:

Bidirectional mapping can involves the mapping reference on the both sides of the relationship and it can enable the traversal from the both ends of the JPA application.
Unidirectional mapping can involves maintaining the references only on one side of the relationship into the application.

FetchType:

FetchType.LAZY: It can be used to the load the associated with the entities lazily when accessed of the JPA application.
FetchType.EAGER: It can load the associated with the entities eagerly along with the owning entity of the application.

Cascade operations:

CascadeType.ALL: It propagates all the operations like persist, merge, remove and refresh to the associated with the entities of the application.
CascadeType.PERSIST: It can be used to the propagate the persist operations of the application.
CascadeType.MERGE: It can be used to the propagate the merge operation of the application.
CascadeType.REMOVE: It can be used to the propagate the remove operation of the application.
CascadeType.REFRESH: It can be used to the propagate the refresh operation of the application.

JPA – List Mapping

JPA in Java is referred to as Java Persistence API(JPA). List mapping in JPA is a key feature for managing relationships between entities in an application. In this article, we will discuss the concept of List Mapping in JPA and its application. List mappings in JPA allow us to represent one-to-many relationships between entities using a Java collection, especially in the list of applications.

Tags:

#JPA #Advance Java