Skip to main content

A Deep Dive into JPA Fetch Types: Exploring the Default Loading Strategy

When working with Java Persistence API (JPA), it's essential to understand the different fetch types for entity associations. In JPA, you can define the fetch type for relationships between entities, which determines how related entities are loaded from the database.

In JPA, the default fetch types for different mappings are as follows:

One-to-One Relationship

For a one-to-one relationship, the default fetch type is FetchType.EAGER. This means that the associated entity will be loaded from the database eagerly, along with the main entity. 


@Entity
public class Author {
    // ...
    
    @OneToOne(fetch = FetchType.EAGER)
    private Address address;
    
    // ...
}

@Entity
public class Address {
    // ...
}

One-to-Many Relationship

For a one-to-many relationship, the default fetch type is FetchType.LAZY. This means that the associated entities will not be loaded from the database until explicitly accessed by your code. 


@Entity
public class Order {
    // ...
    
    @OneToMany(fetch = FetchType.LAZY)
    private List items;
    
    // ...
}

@Entity
public class OrderItem {
    // ...
}

Many-to-One Relationship

For a many-to-one relationship, the default fetch type is FetchType.EAGER. This means that the associated entity will be loaded from the database eagerly when the main entity is loaded. 


@Entity
public class OrderItem {
    // ...
    
    @ManyToOne(fetch = FetchType.EAGER)
    private Order order;
    
    // ...
}

@Entity
public class Order {
    // ...
}

Many-to-Many Relationship

For a many-to-many relationship, the default fetch type is FetchType.LAZY for both sides of the relationship. This means that the associated entities will not be loaded until you access the relationship in your code. 


@Entity
public class Book {
    // ...
    
    @ManyToMany(fetch = FetchType.LAZY)
    private List authors;
    
    // ...
}

@Entity
public class Author {
    // ...
    
    @ManyToMany(mappedBy = "authors", fetch = FetchType.LAZY)
    private List books;
    
    // ...
}

Summary

In JPA, the default fetch types for different mappings are:

  • One-to-One: FetchType.EAGER
  • One-to-Many: FetchType.LAZY
  • Many-to-One: FetchType.EAGER
  • Many-to-Many: FetchType.LAZY
Understanding the default fetch types is crucial for optimizing performance and minimizing unnecessary database queries.

Comments

Post a Comment

Popular posts from this blog

JSP page directives

A jsp page directive looks like this: <%@ directive attribute="value" %> I am not gonna explain each and every page directives here . I would like to discuss about two page directives  which is import and include. First of all consider the import directive . The following simple program illustrate the use of import page directive: The output would be something looks like this: <%@ page language="java" contentType="text/html; charset=UTF-8"     pageEncoding="UTF-8"%>  <%@ page import="java.util.Date" %>   //page directive <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Jsp Basics</title> </head> <body> <%=new Date() %> </body> </html> Tue Nov 12 17:42:34 I...
1 comment
Read more

Configuring Multiple Profiles in a Single YAML File for Spring Boot Application

Spring Boot provides a convenient way to configure application properties using YAML files. In a typical scenario, you might have different configurations for different environments such as development, testing, and production. Instead of maintaining multiple YAML files for each profile, you can configure multiple profiles within a single YAML file. This approach simplifies the configuration management process. Let's see how to achieve this. Step 1: Create a YAML Configuration File First, create a YAML file (e.g., application.yml ) in your Spring Boot project's resource directory. This file will contain the configuration properties for all the profiles you want to define. spring: profiles: active: dev logging: level: root: INFO com.example: DEBUG # Configuration for the 'dev' profile --- spring: profiles: dev database: url: jdbc:mysql://localhost:3306/devdb username: devuser password: devpassword # Co...
Post a Comment
Read more

How to Open a Project in IntelliJ IDEA from the Command Line: A Step-by-Step Guide

How to Open a Project in IntelliJ IDEA from the Command Line IntelliJ IDEA is a popular and powerful Integrated Development Environment (IDE) for Java development. You may have a project folder that you want to open in IntelliJ IDEA. In this tutorial, we will walk through the steps for opening a project in IntelliJ IDEA from the command line. Configure IntelliJ IDEA for Command Line Use Before we can open a project in IntelliJ IDEA from the command line, we need to make sure that it is properly configured. Here are the steps: Open IntelliJ IDEA and go to Tools > Create Command-line Launcher . Select the installation path and click OK . Make sure that the launcher is added to your system PATH variable. You can do this by opening a terminal or command prompt and typing: which idea If the output is the path to the IntelliJ IDEA launcher, then you're good to go! Open a Project in IntelliJ IDEA from the Command Line Open your terminal or command prompt. ...
Post a Comment
Read more