If you are a web developer, you probably have developed some endpoint which has a slow response time. The issue for that might be that you are calling some 3rd party API, you have file processing or it might be how your entities are retrieved from the database.
In this article, we are going to take a look at how the Entity Graph might help us to improve our query performance when using JPA and Spring Boot.
Let’s discuss the following scenario:
We want to build an application where we can keep track of buildings, how many apartments every building has and how many tenants every apartment has. I have already created a simple application that can be downloaded from here.
In order to achieve the previously mentioned scenario, we will need to have the following entities:
package com.north47.entitygraphdemo.repository.model;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;
@Entity
@NoArgsConstructor
@AllArgsConstructor
@Getter
@Setter
public class Building {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String buildingName;
@OneToMany(mappedBy = "building", cascade = CascadeType.ALL)
private List<Apartment> apartments;
public void addApartment(Apartment apartment) {
if (apartments == null) {
apartments = new ArrayList<>();
}
apartments.add(apartment);
apartment.setBuilding(this);
}
}
package com.north47.entitygraphdemo.repository.model;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;
@Entity
@NoArgsConstructor
@AllArgsConstructor
@Getter
@Setter
public class Apartment {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String type;
@JoinColumn(name = "building_id")
@ManyToOne
private Building building;
@OneToMany(mappedBy = "apartment", cascade = CascadeType.ALL)
private List<Tenant> tenants;
public void addTenant(Tenant tenant) {
if (tenants == null) {
tenants = new ArrayList<>();
}
tenants.add(tenant);
tenant.setApartment(this);
}
}
package com.north47.entitygraphdemo.repository.model;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import javax.persistence.*;
@Entity
@NoArgsConstructor
@AllArgsConstructor
@Getter
@Setter
public class Tenant {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String name;
private String lastName;
@JoinColumn(name = "apartment_id")
@ManyToOne
private Apartment apartment;
}
We want to observe what will happen when we want to retrieve all the entities. For that purpose, a service method is created in BuildingService called iterate that will get all the buildings and loop through all remaining entities. For this method to be visible to the outer world a BuildingController is created that exposes GET endpoint from where we can access the iterate method in BuildingService. In order to have some data in our database, there is a SQL script data.sql that will insert some data and will be executed on startup. I would strongly suggest to start your application in debug mode and iterate through every step of the method iterate.
If you have already started your application insert the following URL: http://localhost:8080/building/iterate in your browser or some API application (Postman for example) and execute this GET request. This will execute the iterate method that was created previously.
Let’s see the content of the iterate service method we are calling with this endpoint and observe the console while executing it:
package com.north47.entitygraphdemo.service;
import com.north47.entitygraphdemo.repository.BuildingRepository;
import com.north47.entitygraphdemo.repository.model.Apartment;
import com.north47.entitygraphdemo.repository.model.Building;
import com.north47.entitygraphdemo.repository.model.Tenant;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.List;
@Slf4j
@Service
@RequiredArgsConstructor
public class BuildingService {
private final BuildingRepository buildingRepository;
public void iterate() {
log.debug("Iteration started");
log.debug("Get all buildings");
final List<Building> buildings = buildingRepository.findAll();
buildings.forEach(building -> {
log.debug("Get all apartments for building with id: {}", building.getId());
final List<Apartment> apartments = building.getApartments();
apartments.forEach(apartment -> {
log.debug("Get all tenants for apartment with id: {}", apartment.getId());
final List<Tenant> tenants = apartment.getTenants();
log.debug("Apartment with id : {} has {} tenants", apartment.getId(), tenants.size());
});
});
}
}
If you are in debug mode you may notice that after buildingRepository.findAll() is executed we can see the following log in the console:
Hibernate: select building0_.id as id1_1_, building0_.building_name as building2_1_ from building building0_
Let’s continue with executing the rest of the code. What will appear in the console is the following:
Hibernate: select apartments0_.building_id as building3_0_0_, apartments0_.id as id1_0_0_, apartments0_.id as id1_0_1_, apartments0_.building_id as building3_0_1_, apartments0_.type as type2_0_1_ from apartment apartments0_ where apartments0_.building_id=?
Hibernate: select tenants0_.apartment_id as apartmen4_2_0_, tenants0_.id as id1_2_0_, tenants0_.id as id1_2_1_, tenants0_.apartment_id as apartmen4_2_1_, tenants0_.last_name as last_nam2_2_1_, tenants0_.name as name3_2_1_ from tenant tenants0_ where tenants0_.apartment_id=?
Hibernate: select tenants0_.apartment_id as apartmen4_2_0_, tenants0_.id as id1_2_0_, tenants0_.id as id1_2_1_, tenants0_.apartment_id as apartmen4_2_1_, tenants0_.last_name as last_nam2_2_1_, tenants0_.name as name3_2_1_ from tenant tenants0_ where tenants0_.apartment_id=?
Even though we are not calling some repository methods, SQL queries are executed. This is happening because it is not specified the fetch type in the entities and the default one is the LAZY for OneToMany relationships. This means that when we will try to get the entities (in our case call methods getApartments in Building and getTenants in Aparment) that are annotated with @OneToMany, additional query will be executed. Imagine having a lot’s of data, and we want to execute a similar logic, then this will cause executing a lot more additional queries which will cause a huge latency. One solution is that we can always switch to changing the fetch type to EAGER, but that means that these collections will be always called and we won’t be able to change that in runtime.
One of the solutions can be the JPA Entity Graph. Let’s see how it can make our life easier. We will do the following changes in our domain class Building:
package com.north47.entitygraphdemo.repository.model;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Entity
@NoArgsConstructor
@AllArgsConstructor
@Getter
@Setter
@NamedEntityGraph(
name = "Building.List",
attributeNodes = {@NamedAttributeNode(value = "apartments", subgraph = "Building.Apartment")},
subgraphs = {
@NamedSubgraph(name = "Building.Apartment",
attributeNodes = @NamedAttributeNode(value = "tenants"))
}
)
public class Building {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String buildingName;
@OneToMany(mappedBy = "building", cascade = CascadeType.ALL)
private Set<Apartment> apartments;
public void addApartment(Apartment apartment) {
if (apartments == null) {
apartments = new HashSet<>();
}
apartments.add(apartment);
apartment.setBuilding(this);
}
}
So what happened here? We have defined an entity graph with named Building.List. With the attribute.nodes we are saying which collections to be loaded. Since we also want to get the tenants, we have defined a subgraph called Building.Apartment and in the subgraphs, we are saying to load all the tenants for every apartment. In order for this entity graph to be used we need to create a method in our BuildingRepository to whom we will specify to use this entity graph:
package com.north47.entitygraphdemo.repository;
import com.north47.entitygraphdemo.repository.model.Building;
import org.springframework.data.jpa.repository.EntityGraph;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import java.util.List;
public interface BuildingRepository extends JpaRepository<Building, Long> {
@Override
List<Building> findAll();
@EntityGraph(value = "Building.List")
@Query("select b from Building as b")
List<Building> findAllWithEntityGraph();
}
And of course, we will provide a service method that has the same logic but findAllWithEntityGraph() will be called:
public void iterateWithEntityGraph() {
log.debug("Iteration with entity started");
log.debug("Get all buildings");
final List<Building> buildings = buildingRepository.findAllWithEntityGraph();
buildings.forEach(building -> {
log.debug("Get all apartments for building with id: {}", building.getId());
final Set<Apartment> apartments = building.getApartments();
apartments.forEach(apartment -> {
log.debug("Get all tenants for apartment with id: {}", apartment.getId());
final Set<Tenant> tenants = apartment.getTenants();
log.debug("Apartment with id : {} has {} tenants", apartment.getId(), tenants.size());
});
});
}
And what is remaining is to expose this method using the BuildingController so we can test our new functionality:
@GetMapping(value = "/iterate/entityGraph")
public ResponseEntity<Void> iterateWithEntityGraph() {
buildingService.iterateWithEntityGraph();
return new ResponseEntity<>(HttpStatus.OK);
}
Now if we put the following URL http://localhost:8080/building/iterate/entityGraph in our browser and observe our console we can see that only one query is executed:
Hibernate: select building0_.id as id1_1_0_, apartments1_.id as id1_0_1_, tenants2_.id as id1_2_2_, building0_.building_name as building2_1_0_, apartments1_.building_id as building3_0_1_, apartments1_.type as type2_0_1_, apartments1_.building_id as building3_0_0__, apartments1_.id as id1_0_0__, tenants2_.apartment_id as apartmen4_2_2_, tenants2_.last_name as last_nam2_2_2_, tenants2_.name as name3_2_2_, tenants2_.apartment_id as apartmen4_2_1__, tenants2_.id as id1_2_1__ from building building0_ left outer join apartment apartments1_ on building0_.id=apartments1_.building_id left outer join tenant tenants2_ on apartments1_.id=tenants2_.apartment_id
So we managed to reduce the number of queries from 4 to 1 and we still have the possibility to call the findAll() method in the BuildingRepository where we won’t load all the apartments or the tenants. In a real case scenario, you can define as many entity graphs as you want and specify which collections to be loaded or not.
Hope you had fun, you can find the code in our repository.
