Cómo resolver la excepción de hibernación "no se pudo inicializar perezosamente una colección de roles"

Desde mi experiencia, tengo los siguientes métodos para resolver la famosa excepción LazyInitializationException:

(1) Usa Hibernar.inicializar

Hibernate.initialize(topics.getComments());

(2) Use JOIN FETCH

Puede usar la sintaxis JOIN FETCH en su JPQL para obtener explícitamente la colección hija. Esto es como ir a buscar ANSIOSOS.

(3) Usar OpenSessionInViewFilter

LazyInitializationException a menudo ocurren en la capa de vista. Si utiliza Spring framework, usted puede usar OpenSessionInViewFilter. Sin embargo, no le sugiero que lo haga. Puede conduce a problemas de rendimiento si no se utiliza correctamente.

El origen de su problema:

De forma predeterminada, hibernate carga perezosamente las colecciones (relaciones), lo que significa que cuando use el collection en su código (aquí comments campo en la clase Topic ) el hibernate obtiene eso de la base de datos, ahora el problema es que está obteniendo la colección en su controlador (donde JPA session is closed).Esta es la línea de código que causa la excepción (donde está cargando la colección comments):

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

Usted está recibiendo "comentarios" colección (tema.getComments()) en su controlador (donde JPA session ha terminado) y eso causa la excepción. También si usted había conseguido la colección comments en su archivo jsp como esta (en lugar de obtenerla en su controlador):

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

Seguirías teniendo la misma excepción por la misma razón.

Resolviendo el problema:

Porque solo puede tener dos colecciones con la FetchType.Eager(colección buscada ansiosamente) en una clase de Entidad y porque la carga lenta es más eficiente que cargar ansiosamente, creo que esta forma de resolver su problema es mejor que simplemente cambiar el FetchType a ansioso:

Si desea tener la colección lazy inicializada, y también hacer que esto funcione, es mejor agregar este fragmento de código a su 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>

Lo que hace este código es que aumentará la longitud de su JPA session o como dice la documentación, se usa "to allow for lazy loading in web views despite the original transactions already being completed." para de esta manera la sesión de JPA estará abierta un poco más y por eso puedes cargar perezosamente colecciones en sus archivos jsp y clases de controlador.

Sé que es una vieja pregunta, pero quiero ayudar. Puede poner la anotación transaccional en el método de servicio que necesita, en este caso findTopicByID(id) debe tener

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

Se puede encontrar más información sobre esta anotación aquí

Acerca de las otras soluciones:

fetch = FetchType.EAGER 

No es una buena práctica, solo debe utilizarse si es necesario.

Hibernate.initialize(topics.getComments());

El inicializador de hibernación vincula sus clases a la tecnología de hibernación. Si usted está apuntando a ser flexible no es una buena manera de ir.

Espero que ayude

La razón es que cuando se utiliza carga perezosa, la sesión se cierra.

Hay dos soluciones.

1. No utilice carga perezosa.

   Establece lazy=false en XML o Establece @OneToMany(fetch = FetchType.EAGER) en anotación.

2. Use carga perezosa.

   Establecer lazy=true en XML o Establecer @OneToMany(fetch = FetchType.LAZY) en anotación.

   Y añadir {[4] } en su web.xml

Detalle Ver mi POST.

Para cargar perezosamente una colección debe haber una sesión activa. En una aplicación web hay dos maneras de hacer esto. Puede usar el patrón Open Session In View, donde usa un interceptor para abrir la sesión al principio de la solicitud y cerrarla al final. El riesgo es que tenga un manejo sólido de excepciones o podría enlazar todas sus sesiones y su aplicación podría colgarse.

La otra forma de manejar esto es recopilar todos los datos que necesita en su controlador, cierre su sesión y luego rellene los datos en su modelo. Personalmente prefiero este enfoque, ya que parece un poco más cercano al espíritu del patrón MVC. Además, si obtiene un error de la base de datos de esta manera, puede manejarlo mucho mejor que si sucede en su renderizador de vista. Su amigo en este escenario es Hibernar.inicializar(mitópico.getComments ()). También tendrá que volver a unir el objeto a la sesión, ya que está creando una nueva transacción con cada petición. Usar sesión.lock (myTopic, LockMode.NINGUNO) por eso.

El problema es causado por acceder a un atributo con la sesión de hibernación cerrada. No tiene una transacción de hibernación en el controlador.

Posibles soluciones:

1. Haga toda esta lógica, en la capa de servicio, (con @Transactional), no en el controlador. Debe haber el lugar correcto para hacer esto, es parte de la lógica de la aplicación, no en el controlador (en este caso, una interfaz para cargar el modelo). Todas las operaciones en la capa de servicio deben ser transaccional. es decir: Mueve esta línea al TopicService.Método findTopicByID:

   Lista de comentarios de la colección = topicById.getComments ();

2. Usa 'eager'en lugar de 'lazy' . Ahora no estás usando 'perezoso'.. no es una solución real, si desea utilizar perezoso, funciona como una solución temporal (muy temporal).

3. utilice @Transactional en el Controlador. No se debe usar aquí, está mezclando la capa de servicio con la presentación, no es una buena diseño.
4. use OpenSessionInViewFilter, muchas desventajas reportadas, posible inestabilidad.

En general, la mejor solución es el 1.

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

Resuelvo este problema agregando @Transactional, creo que esto puede hacer que la sesión se abra

Si está tratando de tener una relación entre una entidad y una Colección o una Lista de objetos java (por ejemplo, Tipo largo), le gustaría algo como esto:

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

Descubrí que declarar @PersistenceContext como {[2] } también resuelve este problema:

@PersistenceContext(type = PersistenceContextType.EXTENDED)

Falta @ Anotación transaccional en el controlador

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

Fue el problema al que me enfrenté recientemente el que resolví usando

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

Descripción más detallada aquí y esto me salvó el día.

Su lista es de carga lenta, por lo que la lista no se cargó. llamar para entrar en la lista no es suficiente. uso en Hibernación.inicializar para iniciar la lista. Si el trabajo dosnt se ejecuta en el elemento list y llama a Hibernate.inicializar para cada uno . esto debe ser antes de regresar del alcance de la transacción. mira este post.
buscar -

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

Para resolver el problema en mi caso, solo faltaba esta línea

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

En el archivo application-context.

La anotación @Transactional sobre un método no se tuvo en cuenta.

Espero que la respuesta ayude a alguien

Para aquellos que trabajan con Criterios , encontré que

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

Hice todo lo que necesitaba había hecho.

El modo de recuperación inicial para colecciones se establece en FetchMode.PEREZOSO para proporcionar rendimiento, pero cuando necesito los datos, simplemente añado esa línea y disfruto de los objetos completamente poblados.

En mi caso el siguiente código fue un problema:

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

Debido a que se separó de la base de datos e Hibernar ya no se recuperaba la lista del campo cuando era necesario. Así que lo inicializo antes de separarlo:

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

Como expliqué en este artículo , la mejor manera de manejar el LazyInitializationException es recuperarlo en el momento de la consulta, así:

select t
from Topic t
left join fetch t.comments

Siempre debe evitar los siguientes anti-patrones:

• haciendo las asociaciones ANSIOSAS
• usando OSIV (Sesión abierta en vista)
• habilitar la propiedad hibernate.enable_lazy_load_no_trans Hibernate configuration

Por lo tanto, asegúrese de que sus FetchType.LAZY asociaciones se inicializan en el momento de la consulta o dentro el ámbito original @Transactional usando Hibernate.initialize para colecciones secundarias.

Usando la anotación hibernate @Transactional, si obtiene un objeto de la base de datos con atributos obtenidos perezosamente, simplemente puede obtenerlos obteniendo estos atributos de la siguiente manera:

@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();
        });
}

Aquí, en una transacción administrada por proxy de Hibernación, el hecho de llamar a ticket.getSales() hacer otra consulta para obtener ventas porque se lo pidió explícitamente.

La razón es que está tratando de obtener la lista de comentarios en su controlador después de cerrar la sesión dentro del servicio.

topicById.getComments();

Arriba cargará la lista de comentarios solo si su sesión de hibernación está activa, que supongo que cerró en su servicio.

Por lo tanto, tienes que obtener la lista de comentarios antes de cerrar la sesión.

En mi cae, tenía el mapeo b / w A y B como

A tiene

@OneToMany(mappedBy = "a", cascade = CascadeType.ALL)
Set<B> bs;

En la capa DAO, el método debe estar anotado con @Transactional si no ha anotado la asignación con Fetch Type-Eager

La colección comments en su clase de modelo Topic está cargada perezosamente, que es el comportamiento predeterminado si no la anota con fetch = FetchType.EAGER específicamente.

Es muy probable que su servicio findTopicByID esté usando una sesión de Hibernación sin estado. Una sesión sin estado no tiene la caché de primer nivel, es decir, sin contexto de persistencia. Más adelante, cuando intente iterar comments, Hibernar lanzará una excepción.

org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: mvc3.model.Topic.comments, no session or session was closed

La solución puede ser:

1. Anotar comments con fetch = FetchType.EAGER

   @OneToMany(fetch = FetchType.EAGER, mappedBy = "topic", cascade = CascadeType.ALL)   
   private Collection<Comment> comments = new LinkedHashSet<Comment>();
   

2. Si todavía desea que los comentarios se carguen perezosamente, use Las sesiones con estado de Hibernate, para que pueda obtener comentarios más adelante a pedido.

Hola A todos publicando bastante tarde espero que ayude a los demás, Agradeciendo de antemano a @ GMK por este post Hibernar.inicializar(objeto)

Cuando perezoso = "verdadero"

Set<myObject> set=null;
hibernateSession.open
set=hibernateSession.getMyObjects();
hibernateSession.close();

Ahora, si tengo acceso a 'set' después de cerrar la sesión, arroja una excepción.

Mi solución:

Set<myObject> set=new HashSet<myObject>();
hibernateSession.open
set.addAll(hibernateSession.getMyObjects());
hibernateSession.close();

Ahora puedo acceder a 'set' incluso después de cerrar la sesión de Hibernación.

Una de las mejores soluciones es agregar lo siguiente en su aplicación.archivo de propiedades: primavera.jpa.propiedad.hibernación.enable_lazy_load_no_trans = true

Otra forma de hacerlo, puede usar TransactionTemplate para envolver la búsqueda perezosa. Como

Collection<Comment> commentList = this.transactionTemplate.execute
(status -> topicById.getComments());

Añade esto a tu persistencia.xml

<property name="hibernate.enable_lazy_load_no_trans" value="true" />

Resolví usando List en lugar de Set:

private List<Categories> children = new ArrayList<Categories>();