Spring Data JPA - Different joins for different queries

Using Java 11, Spring Boot, and Spring Data JPA

Overview

I have 3 joined tables in a mysql database that I want to access using Spring Data JPA. For the sake of simplicity, let's call them student, course, and performance_report.

Here are my data classes:

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

    @Id
    @Column(name = "student_id")
    private Long studentId;

    @Column(name = "student_name")
    private String studentName;

    @OneToMany(mappedBy = "student", fetch = FetchType.EAGER,
            cascade = CascadeType.ALL)
    private List<PerformanceReport> performanceReports;
}

@Entity
@Table(name = "course")
@Data
public class Course {

    @Id
    @Column(name = "course_id")
    private Long courseId;

    @Column(name = "course_name")
    private String courseName;

}

@Entity
@Table(name = "performance_report")
@Data
public class PerformanceReport {

    @Id
    @Column(name = "performance_report_id")
    private Long performanceReportId;

    @ManyToOne(fetch = FetchType.EAGER, optional = false)
    @JoinColumn(name = "student_id", nullable = false)
    // JsonBackReference needed to prevent infinite recursion.
    @JsonBackReference
    private Student student;

    @ManyToOne(fetch = FetchType.EAGER, optional = false)
    @JoinColumn(name = "course_id", nullable = false)
    private Course course;

    @Column(name = "grade")
    private String grade;

    @Column(name = "attendance")
    private String attendance;
}

Here is my StudentRepository:

public interface StudentRepository extends JpaRepository<Student, Long> {

    Optional<Student> findById(Long studentId);
}

Calling StudentRepository.findById produces an object like this:

{
  "studentId": 1,
  "studentName": "Spongebob Squarepants",
  "performanceReports": [
    {
      "performanceReportId": 5473,
      "course": {
        "courseId": 643,
        "courseName": "Boating 101"
      },
      "grade": "F",
      "attendance": "100%"
    },
    {
      "performanceReportId": 4723,
      "course": {
        "courseId": 346,
        "courseName": "Grilling 101"
      },
      "grade": "A+",
      "attendance": "100%"
    }
  ]
}

Problem

I also want to perform the inverse of this operation so I can query Course and get an object like this:

{
  "courseId": 346,
  "courseName": "Grilling 101",
  "performanceReports": [
    {
      "performanceReportId": 4723,
      "student": {
        "studentId": 1,
        "studentName": "Spongebob Squarepants"
      },
      "grade": "A+",
      "attendance": "100%"
    },
    {
      "performanceReportId": 4774,
      "student": {
        "studentId": 4,
        "studentName": "Squidward Tentacles"
      },
      "grade": "C-",
      "attendance": "72%"
    }
  ]
}

I cannot do this with my current entity structure.

If I set up the joins for Course in the same way as I do for Student - by adding a @OneToMany in Course and adding a @JsonBackReference to the second @ManyToOne in PerformanceReport - I won't get any Student data in my result. It will also prevent the Course data from flowing through to the Student query. If I remove the @JsonBackReference annotations, I get infinite recursion and a StackOverflow error.

I tried creating separate entities to account for these scenarios. I removed the join from the Student and put it in a class that extends Student. I then do the same for Course and PerformanceReport. Not only does this cause new errors, but it is very messy. It also requires me to create separate repositories for dealing with these extended classes.

There must be a better way.

Am I approaching this correctly? Is Spring Data JPA the best way to accomplish such a task? What if I want to query Student or Course without using any joins at all?

Surely I don't need new entities for every possible scenario. How can I customize the way I join tables for different queries?

Your problem is not so much related to JPA and can be expressed in a more compact way. I present and explain a solution that uses - instead of @JsonBackrefence - a @JsonView annotation.

Assume we have two classes:

Parent:

@Getter @Setter
public class Parent {
	public static class ManagedReferenceView {};
	// Just to have something to show	
	private String name = "" + hashCode();
	@JsonView(ManagedReferenceView.class)
	private List<Child> children;
}

Child:

@Getter @Setter
@RequiredArgsConstructor
public class Child {
	public static class BackReferenceView {
	};
	// Just to have something to show	
	private String name = "" + hashCode();
	@JsonView(BackReferenceView.class)
	private final Parent parent;
}

As you see the view classes need no code, those are just "names" to be used. The point is to tell what we want to serialize when. And this is how those are used (for example):

Construct some parent:

Parent p = new Parent();
p.setChildren(Arrays.asList(new Child(p), new Child(p)));

Serialize Parent:

objectMapper.writerWithView(Parent.ManagedReferenceView.class).writeValueAsString(p);

Serialize Child:

objectMapper.writerWithView(Child.BackReferenceView.class).writeValueAsString(p);

And for the JPA optimizing part of your question you can add fetch = FetchType.LAZY to your joins which lets Hibernate to decide whether it is wise to fetch references from db. In best case references are not fetched until objectMapper needs to call getter for reference when serializing. And maybe you need a view also that does not trigger getter.

Also you can implement JPA projections and such but that is an another story.