Comment résoudre le" échoué à initialiser paresseusement une collection de rôle " Hibernate exception

L'origine de votre problème:

par défaut hibernate charge les collections (relations) ce qui signifie que lorsque vous utilisez le collection dans votre code (ici comments champ dans la classe Topic ) le problème est que vous obtenez la collection dans votre controller (où le JPA la fermeture de la session).C'est la ligne de code qui provoque l'exception (où vous chargez la collection comments ):

    Collection<Comment> commentList = topicById.getComments();

Vous "commentaires" de la collection (le sujet.getComments ()) dans votre controller (où JPA session s'est terminé) et qui cause l'exception. Aussi si vous aviez obtenu la collection comments dans votre fichier jsp comme ceci (au lieu de l'obtenir dans votre contrôleur):

<c:forEach items="topic.comments" var="item">
//some code
</c:forEach>

Vous aurait toujours la même exception pour la même raison.

Résoudre le problème:

Parce que vous ne pouvez avoir que deux collections avec la FetchType.Eager (collection avec impatience) dans une classe Entity et parce que le chargement paresseux est plus efficace que Chargement avide, je pense que cette façon de résoudre votre problème est mieux que de simplement changer le FetchType à impatient:

si vous voulez avoir la collecte initialisé paresseux, et aussi faire ce travail, il est préférable d'ajouter cet extrait de code à votre web.xml :

<filter>
    <filter-name>SpringOpenEntityManagerInViewFilter</filter-name>
    <filter-class>org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>SpringOpenEntityManagerInViewFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

quoi ce code fait est qu'il va augmenter la longueur de votre JPA session ou comme la documentation dit, il est utilisé "to allow for lazy loading in web views despite the original transactions already being completed." ainsi de cette façon, la session de L'App sera ouverte un peu plus longtemps et à cause de cela vous pouvez charger paresseusement des collections dans vos fichiers jsp et classes de contrôleur.

je sais que c'est une vieille question mais je veux aider. Vous pouvez mettre l'annotation transactionnelle sur la méthode de service dont vous avez besoin, dans ce cas findTopicByID (id) devrait avoir

@Transactional(propagation=Propagation.REQUIRED, readOnly=true, noRollbackFor=Exception.class)

plus d'informations sur cette annotation peut être trouvé ici

concernant les autres solutions:

fetch = FetchType.EAGER 

n'est pas une bonne pratique, elle ne doit être utilisée que si nécessaire.

Hibernate.initialize(topics.getComments());

le hibernate initializer lie vos classes à la technologie hibernate. Si vous cherchez à être flexible n'est pas une bonne façon d'aller.

j'Espère que ça aide

la raison est que lorsque vous utilisez la charge paresseuse, la session est fermée.

il y a deux solutions.

1. de Ne pas utiliser le lazy load.

   Set lazy=false en XML ou Définir des @OneToMany(fetch = FetchType.EAGER) Dans l'annotation.

2. Utiliser le lazy load.

   Set lazy=true en XML ou Définir des @OneToMany(fetch = FetchType.LAZY) Dans l'annotation.

   et ajouter OpenSessionInViewFilter filter dans votre web.xml

détail Voir mon POST .

pour charger paresseusement une collection il doit y avoir une session active. Dans une application web, il y a deux façons de le faire. Vous pouvez utiliser la session ouverte en vue pattern, où vous utilisez un interceptor pour ouvrir la session au début de la demande et la fermer à la fin. Le risque est que vous ayez besoin d'avoir une bonne gestion des exceptions ou vous pourriez lier toutes vos sessions et votre application pourrait pendre.

le une autre façon de gérer cela est de collecter toutes les données dont vous avez besoin dans votre controller, fermer votre session, et ensuite bourrer les données dans votre model. Personnellement, je préfère cette approche, car il semble un peu plus proche de l'esprit du modèle MVC. Aussi, si vous obtenez une erreur de la base de données de cette façon, vous pouvez gérer beaucoup mieux que si cela arrive à votre avis rendu. Votre ami dans ce scénario est hiberné.initialiser (myTopic.getComments()). Vous aurez également à rattachez l'objet à la session, puisque vous créez une nouvelle transaction avec chaque requête. Session d'utilisation.lock (myTopic, LockMode.AUCUN).

le problème est causé par l'accès à un attribut avec la session d'hibernation fermée. Vous n'avez pas de transaction d'hibernation dans le contrôleur.

solutions possibles:

1. faire toute cette logique, dans la couche de service , (avec le @Transactional), pas dans le contrôleur. Il devrait être le bon endroit pour ce faire, il fait partie de la logique de l'application, et non dans le contrôleur (dans ce cas, un interface pour charger le modèle). Toutes les opérations de la couche de service devraient être transactionnelles. i.e.: déplacez cette ligne vers le TopicService.findTopicByID method:

   Collection commentList = topicById.getComments ();

2. utilisez" eager "au lieu de "lazy " . Maintenant, vous n'utilisez pas "paresseux".. ce n'est pas une vraie solution, si vous souhaitez utiliser paresseux, fonctionne comme une temporaire (très temporaire) solution de contournement.

3. utiliser @Transactionnelle dans le Contrôleur . Il ne doit pas être utilisé ici, vous mélangez couche de service avec présentation, il n'est pas une bonne conception.
4. utiliser OpenSessionInViewFilter , nombreux inconvénients signalés, instabilité possible.

en général, la meilleure solution est le 1.

@Controller
@RequestMapping(value = "/topic")
@Transactional

Je résous ce problème en ajoutant @Transactional , je pense que cela peut rendre la session ouverte

si vous essayez d'avoir une relation entre une entité et une Collection ou une liste d'objets java (par exemple un type Long), elle aimerait quelque chose comme ceci:

@ElementCollection(fetch = FetchType.EAGER)
    public List<Long> ids;

j'ai découvert que déclarer @PersistenceContext comme EXTENDED résout aussi ce problème:

@PersistenceContext(type = PersistenceContextType.EXTENDED)

@l'annotation transactionnelle sur le contrôleur est manquante

@Controller
@RequestMapping("/")
@Transactional
public class UserController {
}

c'est le problème que j'ai récemment rencontré et que j'ai résolu en utilisant

<f:attribute name="collectionType" value="java.util.ArrayList" />

description plus détaillée ici et cela m'a sauvé la vie.

votre liste est chargée paresseusement, donc la liste n'a pas été chargée. appeler pour obtenir sur la liste n'est pas suffisant. utiliser en hibernation.initialiser afin d'initialisation de la liste. Si dosnt work fonctionne, exécutez l'élément list et appelez Hibernate.initialiser pour chaque . cela doit être fait avant que vous ne reveniez du champ d'application de la transaction. regardez ce" post 151930920".

chercher pour -

Node n = // .. get the node
Hibernate.initialize(n); // initializes 'parent' similar to getParent.
Hibernate.initialize(n.getChildren()); // pass the lazy collection into the session 

pour résoudre le problème dans mon cas, il manquait juste cette ligne

<tx:annotation-driven transaction-manager="myTxManager" />

dans le dossier de la demande-contexte.

l'annotation @Transactional sur une méthode n'a pas été prise en compte.

Espérons que la réponse sera aider quelqu'un

pour ceux qui travaillent avec critère , j'ai trouvé que

criteria.setFetchMode("lazily_fetched_member", FetchMode.EAGER);

a fait tout ce dont j'avais besoin.

le mode fetch initial pour les collections est défini à FetchMode.Paresseux de fournir des performances, mais quand j'ai besoin des données, je viens d'ajouter cette ligne et profiter des objets entièrement peuplés.

dans mon cas le code suivant était un problème:

entityManager.detach(topicById);
topicById.getComments() // exception thrown

parce qu'il s'est détaché de la base de données et Hibernate n'a plus récupéré la liste sur le terrain quand elle était nécessaire. Donc je l'initialise avant de le détacher:

Hibernate.initialize(topicById.getComments());
entityManager.detach(topicById);
topicById.getComments() // works like a charm

comme je l'ai expliqué dans cet article , la meilleure façon de gérer le LazyInitializationException est de le récupérer au moment de la requête, comme ceci:

select t
from Topic t
left join fetch t.comments

vous devez toujours éviter les anti-modèles suivants:

• rendre les associations avides
• utilisant OSIV (Open Session in View)
• permettant la hibernate.enable_lazy_load_no_trans Hibernate configuration de la propriété

par conséquent, assurez-vous que vos associations FetchType.LAZY sont initialisées au moment de la requête ou dans la portée @Transactional originale en utilisant Hibernate.initialize pour les collections secondaires.

en utilisant l'annotation @Transactional d'hibernation, si vous obtenez un objet dans la base de données avec des attributs paresseusement récupérés, vous pouvez simplement obtenir ces attributs en récupérant ces attributs comme ceci:

@Transactional
public void checkTicketSalePresence(UUID ticketUuid, UUID saleUuid) {
        Optional<Ticket> savedTicketOpt = ticketRepository.findById(ticketUuid);
        savedTicketOpt.ifPresent(ticket -> {
            Optional<Sale> saleOpt = ticket.getSales().stream().filter(sale -> sale.getUuid() == saleUuid).findFirst();
            assertThat(saleOpt).isPresent();
        });
}

ici, dans une transaction gérée par proxy Hibernate, le fait d'appeler ticket.getSales() fait une autre requête pour récupérer des ventes parce que vous l'avez explicitement demandé.

la raison est que vous essayez d'obtenir la liste de commentaires sur votre contrôleur après avoir fermé la session dans le service.

topicById.getComments();

ci-dessus chargera la liste des commentaires seulement si votre session d'hibernation est active, ce que je suppose que vous avez fermé dans votre service.

ainsi, vous devez obtenir la liste des commentaires avant de fermer la session.