Why is hibernate creating null foreign keys?

Question

I am trying to create a spring boot application with two entities: Question and QuestionChoices. I'm using a bidirectional onetomany relationship. When I try to create a Question entity along with a list of QuestionChoices, the foreign key in the QuestionChoice is coming out null.

Here is my QuestionChoice entity:

@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
public class QuestionChoice {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    private String choice;

    @ManyToOne
    @JoinColumn(name = "question_id")
    private Question question;

    public QuestionChoice(String choice, Question question) {
        this.choice = choice;
        this.question = question;
    }

    public QuestionChoice(String choice) {
        this.choice = choice;
    }

}

Here is my Question entity:

@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Question {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int question_id;
    private String questionName;
    private String questionText;

    @OneToMany(mappedBy = "question", cascade = CascadeType.ALL)
    private List<QuestionChoice> questionChoices;

    public Question(String questionName, String questionText, List<QuestionChoice> questionChoices) {
        this.questionName = questionName;
        this.questionText = questionText;
        this.questionChoices = questionChoices;
        this.questionChoices.forEach(x -> x.setQuestion(this));
    }
}

I have a QuestionRepository and QuestionChoiceRepository:

@Repository
public interface QuestionRepository extends JpaRepository<Question, Integer> {
}

@Repository
public interface QuestionChoiceRepository extends JpaRepository<QuestionChoice, Integer> {
}

Here is my controller:

@RestController
public class Controller {

    QuestionRepository questionRepository;
    QuestionChoiceRepository questionChoiceRepository;

    public Controller(QuestionRepository questionRepository,
                      QuestionChoiceRepository questionChoiceRepository) {
        this.questionRepository = questionRepository;
        this.questionChoiceRepository = questionChoiceRepository;
    }

    @PostMapping("/question")
    public Question createQuestion(@RequestBody Question question) {
        return questionRepository.save(question);
    }

    @GetMapping("/question")
    public List<Question> getQuestions() {
        return questionRepository.findAll();
    }

}

Here is my POST request:

POST http://localhost:8080/question
Content-Type: application/json

{
  "questionName": "gender",
  "questionText": "What is your gender?",
  "questionChoices": ["male", "female"]
}

Here is the response from the POST:

{
  "id": 1,
  "questionName": "gender",
  "questionText": "What is your gender?",
  "questionChoices": [
    {
      "id": 1,
      "choice": "male",
      "question": null
    },
    {
      "id": 2,
      "choice": "female",
      "question": null
    }
  ]
}

And here is the response from the GET request:

GET http://localhost:8080/question

HTTP/1.1 200 
Content-Type: application/json;charset=UTF-8
Transfer-Encoding: chunked
Date: Wed, 16 Oct 2019 11:10:51 GMT

[
  {
    "id": 1,
    "questionName": "gender",
    "questionText": "What is your gender?",
    "questionChoices": []
  }
]

So not only are the foreign keys of the QuestionChoices null, but the list of question choices in the question entity is also null.

Any idea what I am doing wrong?

Update

I've found a good solution to this problem here: Infinite Recursion with Jackson JSON and Hibernate JPA issue. The problem is with Jackson, not Hibernate. Just add an additional annotation to the reference objects within the entities and everything works great!

score 1 · Answer 1 · answered Oct 16 '19 at 11:21

1

You're sending an array of strings for your questionChoices in the JSON body. Your JSON mapper needs to populate a List<Question> from this array of strings. So it needs to transform each String into a QuestionChoice object. Presumably, it does that by calling the QuestionChoice constructor that takes a String as argument.

So you're saving a Question which has QuestionChoices which all have a null question property. So you're telling JPA that all QuestionChoices don't have any question (since it's null). So JPA saves what you tell it to save: QuestionChoices without any parent question.

You need to properly initialize the question property of the QuestionChoice.

answered Oct 16 '19 at 11:21

JB Nizet

678,734
91
1,224
1,255

I thought the ```question``` property of ```QuestionChoice``` is initialized in the ```Question``` constructor with ```this.questionChoices.forEach(x -> x.setQuestion(this));```. Is there another way I need to initialize it? – dwvldg Oct 16 '19 at 11:26
I have no idea of which JSON mapper you're using, but I doubt it uses the constructor to populate your objects. It uses the no-arg cnstructor, and then initializes the fields directly, or calls the setters. If you want it to use the constructor, you need to read its documentation and configure it to do that (if possible). Whatever the way you choose to do it, it needs to be done. – JB Nizet Oct 16 '19 at 11:32
I'm using the default JSON mapper for spring boot, Jackson. It appears my ```Question``` constructor is not being used. When I attempt to set the ```question``` field of the ```QuestionChoice``` object, I get an infinite recursion and stackoverflow. Do you know how to prevent this from happening? – dwvldg Oct 16 '19 at 12:15

score 0 · Answer 2 · answered Oct 16 '19 at 11:34

0

You don't use your constructor public Question(...) after request. You should make a method to link choices with question

answered Oct 16 '19 at 11:34

Nick

805
5
14

Matheus · Accepted Answer · 2019-10-16T13:15:54.773

The deserializer will always use the default constructor to construct the object. Your custom constructor has no effect over the deserialization.

What you can do is:

1 - Guarantee the association in your service / controller layer

@PostMapping("/question")
public Question createQuestion(@RequestBody Question question) {
    question.getQuestionChoices().forEach(choice -> choice.setQuestion(question));
    return questionRepository.save(question);
}

or 2 - Guarantee the association in your setter method:

public class Question {

    // omitted for brevity

    @OneToMany(mappedBy = "question", cascade = CascadeType.ALL)
    private List<QuestionChoice> questionChoices;

    public void setQuestionChoices(List<QuestionChoice> questionChoices) {
        if (questionChoices != null) {
            questionChoices.forEach(choice -> choice.setQuestion(this));
        }
        this.questionChoices = questionChoices;
    }
}

Update

To prevent the infinite recursion, simply remove the 'question' attribute from the 'questionChoice' for presentation purposes.

I can think of two options:

1 - Set the question to null inside of questionChoice

@PostMapping("/question")
public Question createQuestion(@RequestBody Question question) {
    Question savedQuestion = questionRepository.save(question);
    savedQuestion.getQuestionChoices().forEach(choice -> choice.setQuestion(null));

    return savedQuestion;
}

@GetMapping("/question")
public List<Question> getQuestions() {
    List<Question> questions questionRepository.findAll();
    questions.forEach(question -> {
        question.getQuestionChoices.forEach(choice -> choice.setQuestion(null));
    });

    return questions;
}

This will save your question choices and foreign keys into the database, but will serialize questionChoices.question as null when sending the response to prevent infinite recursion.

2 - Use of DTOs.

You create a DTOs to serialize them as response objects to return exactly what you want to.

QuestionDTO.java

public class QuestionDTO {

    private int question_id;
    private String questionName;
    private String questionText;

    // notice that here you're using composition of DTOs (QuestionChoiceDTO instead of QuestionChoice)
    private List<QuestionChoiceDTO> questionChoices;

    // constructors..

    // getters and setters..
}

QuestionChoiceDTO.java

public class QuestionChoiceDTO {

    private int id;
    private String choice;

    // notice that you don't need to create the Question object here

    // constructors..

    // getters and setters..

}

Then in your controller:

@PostMapping("/question")
public QuestionDTO createQuestion(@RequestBody Question question) {
    Question savedQuestion = questionRepository.save(question);

    List<QuestionChoiceDTO> questionChoices = new ArrayList<>();
    savedQuestion.getQuestionChoices().forEach(choice -> {
        questionChoices.add(new QuestionChoiceDTO(choice.getId(), choice.getChoice()));
    });

    QuestionDTO response = new QuestionDTO(savedQuestion.getQuestion_id(), savedQuestion.getQuestionName(), savedQuestion.getQuestionText(), questionChoices);

    return response;
}

@GetMapping("/question")
public List<QuestionDTO> getQuestions() {
    List<Question> questions = questionRepository.findAll();
    List<QuestionDTO> response = new ArrayList<>();

    questions.forEach(question -> {
        List<QuestionChoicesDTO> questionChoices = new ArrayList<>();
        question.getQuestionChoices().forEach(choice -> questionChoices.add(new QuestionChoiceDTO(choice.getId(), choice.getChoice()));

        responses.add(new QuestionDTO(savedQuestion.getQuestion_id(), savedQuestion.getQuestionName(), savedQuestion.getQuestionText(), questionChoices));
    });
}

I always prefer the latter, because for big projects, IMHO, the use of DTO's can be a strong tool for organizing code and making concise use of request / response objects without using your domain objects.

I think this is on the right track. However, when I try both methods, I get an infinite recursive loop and stackoverflow. Here is the error message from the POST request: ```"error": "OK", "message": "Could not write JSON: Infinite recursion (StackOverflowError); nested exception is com.fasterxml.jackson.databind.JsonMappingException``` Then it just goes on like that forever. — dwvldg, Oct 16 '19 at 12:02
Where do you get the infinite loop? On the `POST` or on your `GET` method? — Matheus, Oct 16 '19 at 12:04
That's expected. You enter in a infinite recursion because when you send the response you need to prevent this by removing the 'question' attribute from questionChoices. If you don't do that, the serializer keeps serializing one inside another. Maybe this is a topic for another question — Matheus, Oct 16 '19 at 12:13

Why is hibernate creating null foreign keys?

3 Answers3