failed to lazily initialize a collection of role could not initialize proxy - no Session

Hello, everyone. I got an error: failed to lazily initialize a collection of role: com.kata.cinema.base.models.entitys.Question.medias: could not initialize proxy - no Session.
I see that question is not added to media correctly because of relation between them is may-to-many. What is wrong?



@Entity @Table(name = "media") @NoArgsConstructor @AllArgsConstructor @Getter @Setter public class Media {    @Id    @GeneratedValue(strategy = GenerationType.SEQUENCE)    private Long id;    private String title;    private String previewUrl;    private boolean isEnabled = false;    private MediaStatus status = MediaStatus.EDITED;    @Lob    @JdbcTypeCode(SqlTypes.LONGVARCHAR)    private String htmlBody;    private LocalDateTime date = LocalDateTime.now();    @OneToMany(mappedBy = "media", cascade = CascadeType.ALL)    private Set<Comment> comments;    @ManyToOne(fetch = FetchType.LAZY)    @JoinColumn(name = "author_id")    private User nameAuthor;    @ManyToMany    @JoinTable(name = "media_category",            joinColumns = @JoinColumn(name = "media_id"),            inverseJoinColumns = @JoinColumn(name = "category_id"))    private Set<Category> categories  = new HashSet<>();    @ManyToMany    @JoinTable(name = "media_movie",            joinColumns = @JoinColumn(name = "media_id"),            inverseJoinColumns = @JoinColumn(name = "movie_id"))    private Set<Movie> movies = new HashSet<>();    @ManyToMany(fetch = FetchType.LAZY, cascade = { CascadeType.PERSIST, CascadeType.ALL })    @JoinTable(name = "media_question", joinColumns = { @JoinColumn(name = "media_id") }, inverseJoinColumns = {            @JoinColumn(name = "question_id") })    private Set<Question> questions = new HashSet<>();    public Set<Question> getQuestions() {        return questions;    }    public void addQuestion(Question question) {        this.questions.add(question);        question.getMedias().add(this);    }    public void removeQuestion(long questionId) {        Question question = this.questions.stream().filter(t -> t.getId() == questionId).findFirst().orElse(null);        if (question != null) {            this.questions.remove(question);            question.getMedias().remove(this);        }    }    @Override    public boolean equals(Object o) {        if (this == o) return true;        if (o == null || Hibernate.getClass(this) != Hibernate.getClass(o)) return false;        Media media = (Media) o;        return id != null && Objects.equals(id, media.id);    }    @Override    public int hashCode() {        return getClass().hashCode();    } }


@Entity @Table(name = "questions") @Getter @Setter public class Question {    @Id    @GeneratedValue(strategy = GenerationType.SEQUENCE)    private Long id;    @Column(name = "question")    private String question;    @Column(name = "position")    private Integer position;    @ManyToMany(fetch = FetchType.LAZY,            cascade = {                    CascadeType.PERSIST,                    CascadeType.MERGE            },            mappedBy = "questions")    @JsonIgnore    private Set<Media> medias = new HashSet<>();    public long getId() {        return id;    }    public Set<Media> getMedias() {        return medias;    }    public void setMedias(Set<Media> medias) {        this.medias = medias;    } }

@Service @RequiredArgsConstructor public class MediaServicesImpl implements MediaServices {    private final MediaBodyRepository mediaBodyRepository;    @Transactional    @Override    public void save(Media media) {        mediaBodyRepository.save(media);    }    @Override    public void update(Media media) {        mediaBodyRepository.save(media);    }    @Override    public void delete(Long id) {        mediaBodyRepository.deleteById(id);    }    @Transactional    @Override    public Optional<Media> findById(Long mediaId) {                return  mediaBodyRepository.findById(mediaId);    }    @Override    public List<Media> getAllMedia() {        return mediaBodyRepository.findAll();    }    @Override    public Media getMediaById(Long mediaId) {        return mediaBodyRepository.findById(mediaId).orElseThrow();    }   }

@RequiredArgsConstructor @RestController @RequestMapping("/api") public class QuestionServiceController {    private final MediaServices mediaServices;    private final QuestionService questionService;    @PostMapping("/media/{mediaId}/question")    public void addJsonQuestionAnswer(@PathVariable(value = "mediaId") Long mediaId, @RequestBody QuestionRequestDto body) throws IOException {        if (body != null) {            QuestionRequestDto json = body;            System.out.println(json.getAnswers());            questionService.save(json);            Question newQuestion = questionService.findByQuestion(body.getQuestion());            mediaServices.findById(mediaId).map(media -> {                media.addQuestion(newQuestion);                mediaServices.save(media);                return newQuestion;            }).orElseThrow(() -> new RuntimeException("Not found Media with id = " + mediaId));        }    } }

Unless I'm mistaken, your Entity has been detached from its EntityManager (session). When you do that and you have lazy-fetched properties, the properties will return a proxy object rather than the property collection so that you will know that the property values in the collection had not been fetched.

The cure for that is to re-attach (merge) the parent Entity and fetch them. Note that the Entity returned from merge() is NOT the same ("==") Entity as the argument to merge(), although it is "equals()" to that Entity object. Use the returned Entity and discard the original instance.

You can also avoid this problem by force-fetching the lazy properties before detaching.

Do you mean using query in Service?
@Modifying @Transactional @Query(value = "insert into media_question (media_id, question_id) VALUES (:media_id, :question_id)", nativeQuery = true) Long saveBuilding(Long media_id, Long question_id);

Would you show an example "by force-fetching the lazy properties before detaching"?

Hmm. I just realized you have a many-to-many relationship here. In a case like that, you're probably going to have to force-fetch join table and terminal objects.

Many/Many relationships are messy at the best of times and sometime the best solution is to use an alternative to SQL databases. For example, the Neo4J database is very good when the relationships between objects is as important or even more important than the entity object properties. It's quite a bit different from SQL, but complex object relationships are easy, especially many-to-many relationships. There is Spring framework support for Neo4J as part of the Spring Data module that also supplues JDBC and JPA SQL database support.

In answer to the latest quesion, though:

To force-fetch a lazy property. just access that property BEFORE detaching from the database. You should be able to simply use the collection's "size()" method, but uf not, try to fetch the first element of the collection and be prepared to see that the collection might be empty depending on what data has been stored so far.

As I said, it's messier in a many-to-many setup, but the force-fetching mechanisms are similar.

I used a tutorial (https://www.bezkoder.com/jpa-many-to-many/) with success (https://github.com/svil1502/spring-boot-many-to-many3.git) and this code is working

   @PostMapping("/medias/{mediaId}/questions/answers")    public void addJsonQuestionAnwer(@PathVariable(value = "mediaId") Long mediaId, @RequestBody QuestionRequestDto body) throws IOException {        if (body != null) {            QuestionRequestDto json = body;            questionRepository.save(mapstructMapper.questionRequestDtoToQuestion(json));                     Question newQuestion = questionRepository.findByName(body.getName());            mediaRepository.findById(mediaId).map(media -> {                media.addQuestion(newQuestion);                return mediaRepository.save(media);            }).orElseThrow(() -> new ResourceNotFoundException("Not found Media with id = " + mediaId));            for (AnswerRequestDto answer : json.getAnswers()) {                              Answer newanswer = mapstructMapper.answerRequestDtoToAnswer(answer);                newanswer.setQuestion(newQuestion);                          answerRepository.save(newanswer);            }        }    }
And my problem started when I had added Repository to Service, code has crashed. What is wrong? service was supposed to be a layer and not a hindrance...

it's done with FetchType.EAGER
I found https://stackoverflow.com/questions/61675882/lazy-initialization-manytomany-what-is-the-error, but i have no idea haw to use it in my case

Hi, Svetlana,
I ran your code from your Github you provided, I had an issue:
Caused by: org.springframework.data.mapping.PropertyReferenceException: No property 'findMediaWithAnswers' found for type 'Media'

You may want to remove findMediaWithAnswer() method declaration from MediaRepository first.

Yes. I saw and fixed https://github.com/svil1502/spring-boot-many-to-many-work. I try to do with Eager. But I was told  fix my code with  join featch. I am looking for tutorials about it.

I don't know haw to use join fetch, if I need to add Question to Media with table media_question, not select.

I am not too familiar with FetchMode. But you may find a clue :  https://www.baeldung.com/hibernate-fetchmode

Himai Minh wrote:I am not too familiar with FetchMode. But you may find a clue :  https://www.baeldung.com/hibernate-fetchmode

The 5-second intro to FetchMode (NOTE Hibernate and JPA are NOT always the same thing!!!)

FetchMode controls how related objects are fetched from the database when you fetch an Entity object.

EAGER fetch means then if I have an Invoice Entity and a bunch of InvoiceItems (collection) and I fetch the Invoice, the InvoiceItems get fetched at the same time.

LAZY fetch means that if I fetch the Invoice, the InvoiceItems do NOT get fetched. Only if I explicitly access the InvoiceItems collection will cause them to be fetched. That means I can save time and resources if I want only the Invoice and not its line items. It also means that I avoid the dread "vacuum" effect that I'll explain in a moment.

The biggest "gotcha" to LAZY fetch comes when you fetch the Invoice and then DETACH it from its EntityManager. This is a useful thing to do, since it converts the Entity instance into a POJO that isn't secretly dragging around a lot of data management stuff with it, but the downside of not having that secret management stuff is that any attempt to access InvoiceItems will throw an Exception because the database cannot be accessed. The Proxy Object ensures that so that we can tell non-fetched data from non-existent data (that is, if there ARE no InvoiceItems).

To avoid that Exception, the Entity must first be re-attached (merged) and then you can access InvoiceItems in the normal way.

OK, to wrap it up, aside from the memory/CPU overhead, there's another disadvantage to EAGER fetching. If the dependent objects refer in turn to other objects and those references are also EAGER, then they get piggybacked in automatically (the "vaduum effect"). In some cases, a simple one-record fetch can end up pulling the entirety of a very large database into RAM.

Which is why it's useful to have a choice of fetch options, even though it does make things slightly more complicated.

Problem was fixed with @Transactional, and LAZY fetch  was on its place. Thank you very much.

@Transactional @PostMapping("/media/{mediaId}/question")    public void addJsonQuestionAnswer(@PathVariable(value = "mediaId") Long mediaId, @RequestBody QuestionRequestDto body) throws IOException {        if (body != null) {            QuestionRequestDto json = body;            System.out.println(json.getAnswers());            questionService.save(json);            Question newQuestion = questionService.findByQuestion(body.getQuestion());            mediaServices.findById(mediaId).map(media -> {                media.addQuestion(newQuestion);                mediaServices.save(media);                return newQuestion;            }).orElseThrow(() -> new RuntimeException("Not found Media with id = " + mediaId));        }    }

Svetlana,
Congratulations. Do you specify any entity with Lazy fetch type ?

Of course, two entities Media and Question  are related  with many-to-many

package com.kata.cinema.base.models.entitys; import com.kata.cinema.base.models.enums.MediaStatus; import jakarta.persistence.CascadeType; import jakarta.persistence.Entity; import jakarta.persistence.FetchType; import jakarta.persistence.GeneratedValue; import jakarta.persistence.GenerationType; import jakarta.persistence.Id; import jakarta.persistence.JoinColumn; import jakarta.persistence.JoinTable; import jakarta.persistence.Lob; import jakarta.persistence.ManyToMany; import jakarta.persistence.ManyToOne; import jakarta.persistence.OneToMany; import jakarta.persistence.Table; import lombok.AllArgsConstructor; import lombok.Getter; import lombok.NoArgsConstructor; import lombok.Setter; import org.hibernate.Hibernate; import org.hibernate.annotations.JdbcTypeCode; import org.hibernate.type.SqlTypes; import java.time.LocalDateTime; import java.util.HashSet; import java.util.Objects; import java.util.Set; @Entity @Table(name = "media") @NoArgsConstructor @AllArgsConstructor @Getter @Setter public class Media {    @Id    @GeneratedValue(strategy = GenerationType.SEQUENCE)    private Long id;    private String title;    private String previewUrl;    private boolean isEnabled = false;    private MediaStatus status = MediaStatus.EDITED;    @Lob    @JdbcTypeCode(SqlTypes.LONGVARCHAR)    private String htmlBody;    private LocalDateTime date = LocalDateTime.now();    @OneToMany(mappedBy = "media", cascade = CascadeType.ALL)    private Set<Comment> comments;    @ManyToOne(fetch = FetchType.LAZY)    @JoinColumn(name = "author_id")    private User nameAuthor;    @ManyToMany    @JoinTable(name = "media_category",            joinColumns = @JoinColumn(name = "media_id"),            inverseJoinColumns = @JoinColumn(name = "category_id"))    private Set<Category> categories  = new HashSet<>();    @ManyToMany    @JoinTable(name = "media_movie",            joinColumns = @JoinColumn(name = "media_id"),            inverseJoinColumns = @JoinColumn(name = "movie_id"))    private Set<Movie> movies = new HashSet<>();    @ManyToMany(fetch = FetchType.LAZY, cascade = { CascadeType.PERSIST, CascadeType.MERGE })    @JoinTable(name = "media_question", joinColumns = { @JoinColumn(name = "media_id") }, inverseJoinColumns = {            @JoinColumn(name = "question_id") })    private Set<Question> questions = new HashSet<>();    public Set<Question> getQuestions() {        return questions;    }    public void setQuestions(Set<Question> questions) {        this.questions = questions;    }    public void addQuestion(Question question) {        this.questions.add(question);        question.getMedias().add(this);    }    public void removeQuestion(long questionId) {        Question question = this.questions.stream().filter(t -> t.getId() == questionId).findFirst().orElse(null);        if (question != null) {            this.questions.remove(question);            question.getMedias().remove(this);        }    }    @Override    public boolean equals(Object o) {        if (this == o) return true;        if (o == null || Hibernate.getClass(this) != Hibernate.getClass(o)) return false;        Media media = (Media) o;        return id != null && Objects.equals(id, media.id);    }    @Override    public int hashCode() {        return getClass().hashCode();    } }

package com.kata.cinema.base.models.entitys; import com.fasterxml.jackson.annotation.JsonIgnore; import jakarta.persistence.*; import lombok.Getter; import lombok.Setter; import java.util.HashSet; import java.util.Set; @Entity @Table(name = "questions") @Getter @Setter public class Question {    @Id    @GeneratedValue(strategy = GenerationType.SEQUENCE)    private Long id;    @Column(name = "question")    private String question;    @Column(name = "position")    private Integer position;    @ManyToMany(fetch = FetchType.LAZY,            cascade = {                    CascadeType.PERSIST,                    CascadeType.MERGE            },            mappedBy = "questions")    @JsonIgnore    private Set<Media> medias = new HashSet<>();    public Question() {    }    public long getId() {        return id;    }    public Set<Media> getMedias() {        return medias;    }    public void setMedias(Set<Media> medias) {        this.medias = medias;    } }