How to get json response only with an id of the related entity

Fetching entities with complex relationships can consume a lot of resources during calls to your API. To minimize the size of the requested json string, you can use the LAZY fetch type. This will result in accessing only the serialized object and its properties – without considering its relations. But often you need to obtain the identifiers of the associated objects as well. Check out how to fetch an entity with an id of a related object while preserving proper serialization and deserialization.

What we are going to build

The example Task class has id and name properties and requires Many-to-One relation with the Project entity. We want the json representation of a Task instance to look like this:

{
    "id": 1,
    "name": "task_name",
    "projectId": 1
}

You can achieve it by using @JsonIdentityInfo annotation alongside with @JsonIdentityReference. However, it may spawn the following error when the data is deserialized back to an object: "Unresolved forward references for related entity".

Let’s divide our venture into the following stages.

Requirements

The following fragment of the pom.xml file shows dependencies used in the project:

// pom.xml
…
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>
…

Define the relation between two entities

Let’s define the Many-to-One relation to the Project entity. When our API is requested for task data, we want to avoid fetching a related project with all other tasks associated with it. So we specify the fetch type to LAZY. You can see the relation between task and project entities defined in the following code snippet from the Task entity:

// Task.java
…
@ManyToOne(fetch = FetchType.LAZY, optional = false)
@JoinColumn(name = "project_id", nullable = false)
@OnDelete(action = OnDeleteAction.CASCADE)
private Project project;
…

The @OnDelete annotation allows removing all child records (tasks) whenever the parent record (project) is deleted.

Include the id property from the related entity when fetching the object

If you need a serialized instance of a task containing an identifier of a related project, add @JsonIdentityInfo annotation when defining the relation:

// Task.java
…
@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "id")
private Project project;
…

Enforce use of the related object id

To ensure that the project id  will be properly included as a task property during serialization, add the @JsonIdentityReference annotation:

// Task.java
…
@JsonIdentityReference(alwaysAsId = true)
private Project project;
…

Set alwaysAsId option to true in order to serialize all referenced values as ids. In the annotation documentation you can read that:

“(…) if value of ‘true’ is used, deserialization may require additional contextual information, (…) the default handling may not be sufficient.”

Fix the deserialization issue

To help deserialize the task object properly, add the @JsonProperty annotation and specify the json object field name – "projectId":

// Task.java
…
@JsonProperty("projectId")
private Project project;
…

Furthermore, we need the setter for the project property:

// Task.java
…
@JsonProperty("projectId")
public void setProjectById(Long projectId) {
    project = Project.fromId(projectId);
}
…

We are using a static factory method, as described in Effective Java (3^rd Edition) by Joshua Bloch. To obtain a new Project instance with only id specified, add the following method to the Project entity:

// Project.java
…
public static Project fromId(Long projectId) {
    Project project = new Project();
    project.id = projectId;
    return project;
}
…

After deserialization, the project property of the task object will hold a Project instance in which only the id property is set to an actual value.

Verify the results

The task instance was fully serialized and the related project was passed as a reference value and included in the json representation of the task as its property. To ascertain this, let’s add to the project the following test –  getsTaskById():

// awesomeproject/backend/src/test/java/in/keepgrowing/awesomeproject/tasks/TaskControllerTest.java
package in.keepgrowing.awesomeproject.tasks;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.data.web.config.EnableSpringDataWebSupport;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import java.util.Optional;
import static org.hamcrest.Matchers.is;
import static org.mockito.BDDMockito.given;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@RunWith(SpringRunner.class)
@WebMvcTest(TaskController.class)
@EnableSpringDataWebSupport
public class TaskControllerTest {

    @MockBean
    private TaskService taskService;
    @Autowired
    private MockMvc mvc;

    @Test
    public void getsTaskById() throws Exception {
        Task task = new Task("test_task");
        task.setProjectFromId(1L);
        given(taskService.getTaskById(1L)).willReturn(Optional.of(task));

        mvc.perform(get("/api/tasks/1")
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.name", is(task.getName())))
                .andExpect(jsonPath("$.projectId").value(is(task.getProject().getId()), Long.class));
    }
}

The source code for the Task entity

// Task.js
package in.keepgrowing.awesomeproject.tasks;

import com.fasterxml.jackson.annotation.*;
import in.keepgrowing.awesomeproject.projects.Project;
import org.hibernate.annotations.OnDelete;
import org.hibernate.annotations.OnDeleteAction;

import javax.persistence.*;
import javax.validation.constraints.NotBlank;
import java.util.Objects;

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

    @NotBlank(message = "Provide a task name")
    private String name;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "project_id", nullable = false)
    @OnDelete(action = OnDeleteAction.CASCADE)
    @JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "id")
    @JsonIdentityReference(alwaysAsId = true)
    @JsonProperty("projectId")
    private Project project;

    public Task() {
    }

    @JsonCreator
    public Task(@NotBlank(message = "Provide a task name") String name) {
        this.name = name;
    }

    @JsonProperty("projectId")
    public void setProjectById(Long projectId) {
        project = Project.fromId(projectId);
    }
… // the rest of getters and setters omitted for the sake of clarity
}

Photo by Toni Cuenca on StockSnap