Comment réparer Hibernate LazyInitializationException: échec paresseusement initialiser une collection de rôles, n'a pas pu initialiser proxy - pas de Session

Dans la coutume AuthenticationProvider de mon projet pour le printemps, je suis en train de lire la liste des autorités de l'utilisateur, mais je suis confronté à l'erreur suivante:

org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.horariolivre.entity.Usuario.autorizacoes, could not initialize proxy - no Session
at org.hibernate.collection.internal.AbstractPersistentCollection.throwLazyInitializationException(AbstractPersistentCollection.java:566)
at org.hibernate.collection.internal.AbstractPersistentCollection.withTemporarySessionIfNeeded(AbstractPersistentCollection.java:186)
at org.hibernate.collection.internal.AbstractPersistentCollection.initialize(AbstractPersistentCollection.java:545)
at org.hibernate.collection.internal.AbstractPersistentCollection.read(AbstractPersistentCollection.java:124)
at org.hibernate.collection.internal.PersistentBag.iterator(PersistentBag.java:266)
at com.horariolivre.security.CustomAuthenticationProvider.authenticate(CustomAuthenticationProvider.java:45)
at org.springframework.security.authentication.ProviderManager.authenticate(ProviderManager.java:156)
at org.springframework.security.authentication.ProviderManager.authenticate(ProviderManager.java:177)
at org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter.attemptAuthentication(UsernamePasswordAuthenticationFilter.java:94)
at org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter.doFilter(AbstractAuthenticationProcessingFilter.java:211)
at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:342)
at org.springframework.security.web.authentication.logout.LogoutFilter.doFilter(LogoutFilter.java:110)
at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:342)
at org.springframework.security.web.header.HeaderWriterFilter.doFilterInternal(HeaderWriterFilter.java:57)
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107)
at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:342)
at org.springframework.security.web.context.SecurityContextPersistenceFilter.doFilter(SecurityContextPersistenceFilter.java:87)
at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:342)
at org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilter.doFilterInternal(WebAsyncManagerIntegrationFilter.java:50)
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107)
at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:342)
at org.springframework.security.web.FilterChainProxy.doFilterInternal(FilterChainProxy.java:192)
at org.springframework.security.web.FilterChainProxy.doFilter(FilterChainProxy.java:160)
at org.springframework.web.filter.DelegatingFilterProxy.invokeDelegate(DelegatingFilterProxy.java:343)
at org.springframework.web.filter.DelegatingFilterProxy.doFilter(DelegatingFilterProxy.java:260)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:243)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:210)
at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:222)
at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:123)
at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:502)
at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:171)
at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:99)
at org.apache.catalina.valves.AccessLogValve.invoke(AccessLogValve.java:953)
at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:118)
at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:408)
at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1023)
at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:589)
at org.apache.tomcat.util.net.JIoEndpoint$SocketProcessor.run(JIoEndpoint.java:312)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
at java.lang.Thread.run(Thread.java:744)

En lisant d'autres sujets à partir d'ici dans StackOberflow, je comprends ce qui se passe en raison de la façon dont ce type d'attribut est gérée par le framework, mais je ne peux pas trouver une solution pour mon cas. Quelqu'un peut point ce que je fais de mal et ce que je peux faire pour le réparer?

Le code de ma Coutume AuthenticationProvider est:

@Component
public class CustomAuthenticationProvider implements AuthenticationProvider {
@Autowired
private UsuarioHome usuario;
public CustomAuthenticationProvider() {
super();
}
@Override
public Authentication authenticate(Authentication authentication) throws AuthenticationException {
System.out.println("CustomAuthenticationProvider.authenticate");
String username = authentication.getName();
String password = authentication.getCredentials().toString();
Usuario user = usuario.findByUsername(username);
if (user != null) {
if(user.getSenha().equals(password)) {
List<AutorizacoesUsuario> list = user.getAutorizacoes();
List <String> rolesAsList = new ArrayList<String>();
for(AutorizacoesUsuario role : list){
rolesAsList.add(role.getAutorizacoes().getNome());
}
List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();
for (String role_name : rolesAsList) {
authorities.add(new SimpleGrantedAuthority(role_name));
}
Authentication auth = new UsernamePasswordAuthenticationToken(username, password, authorities);
return auth;
}
else {
return null;
}
} else {
return null;
}
}
@Override
public boolean supports(Class<?> authentication) {
return authentication.equals(UsernamePasswordAuthenticationToken.class);
}
}

Mes classes d'Entité sont:

UsuarioHome.java

@Entity
@Table(name = "usuario")
public class Usuario implements java.io.Serializable {
private int id;
private String login;
private String senha;
private String primeiroNome;
private String ultimoNome;
private List<TipoUsuario> tipoUsuarios = new ArrayList<TipoUsuario>();
private List<AutorizacoesUsuario> autorizacoes = new ArrayList<AutorizacoesUsuario>();
private List<DadosUsuario> dadosUsuarios = new ArrayList<DadosUsuario>();
private ConfigHorarioLivre config;
public Usuario() {
}
public Usuario(String login, String senha) {
this.login = login;
this.senha = senha;
}
public Usuario(String login, String senha, String primeiroNome, String ultimoNome, List<TipoUsuario> tipoUsuarios, List<AutorizacoesUsuario> autorizacoesUsuarios, List<DadosUsuario> dadosUsuarios, ConfigHorarioLivre config) {
this.login = login;
this.senha = senha;
this.primeiroNome = primeiroNome;
this.ultimoNome = ultimoNome;
this.tipoUsuarios = tipoUsuarios;
this.autorizacoes = autorizacoesUsuarios;
this.dadosUsuarios = dadosUsuarios;
this.config = config;
}
public Usuario(String login, String senha, String primeiroNome, String ultimoNome, String tipoUsuario, String[] campos) {
this.login = login;
this.senha = senha;
this.primeiroNome = primeiroNome;
this.ultimoNome = ultimoNome;
this.tipoUsuarios.add(new TipoUsuario(this, new Tipo(tipoUsuario)));
for(int i=0; i<campos.length; i++)
this.dadosUsuarios.add(new DadosUsuario(this, null, campos[i]));
}
@Id
@Column(name = "id", unique = true, nullable = false)
@GeneratedValue(strategy=GenerationType.AUTO)
public int getId() {
return this.id;
}
public void setId(int id) {
this.id = id;
}
@Column(name = "login", nullable = false, length = 16)
public String getLogin() {
return this.login;
}
public void setLogin(String login) {
this.login = login;
}
@Column(name = "senha", nullable = false)
public String getSenha() {
return this.senha;
}
public void setSenha(String senha) {
this.senha = senha;
}
@Column(name = "primeiro_nome", length = 32)
public String getPrimeiroNome() {
return this.primeiroNome;
}
public void setPrimeiroNome(String primeiroNome) {
this.primeiroNome = primeiroNome;
}
@Column(name = "ultimo_nome", length = 32)
public String getUltimoNome() {
return this.ultimoNome;
}
public void setUltimoNome(String ultimoNome) {
this.ultimoNome = ultimoNome;
}
@ManyToMany(cascade=CascadeType.ALL)
@JoinTable(name = "tipo_usuario", joinColumns = { @JoinColumn(name = "fk_usuario") }, inverseJoinColumns = { @JoinColumn(name = "fk_tipo") })
@LazyCollection(LazyCollectionOption.TRUE)
public List<TipoUsuario> getTipoUsuarios() {
return this.tipoUsuarios;
}
public void setTipoUsuarios(List<TipoUsuario> tipoUsuarios) {
this.tipoUsuarios = tipoUsuarios;
}
@ManyToMany(cascade=CascadeType.ALL)
@JoinTable(name = "autorizacoes_usuario", joinColumns = { @JoinColumn(name = "fk_usuario") }, inverseJoinColumns = { @JoinColumn(name = "fk_autorizacoes") })
@LazyCollection(LazyCollectionOption.TRUE)
public List<AutorizacoesUsuario> getAutorizacoes() {
return this.autorizacoes;
}
public void setAutorizacoes(List<AutorizacoesUsuario> autorizacoes) {
this.autorizacoes = autorizacoes;
}
@ManyToMany(cascade=CascadeType.ALL)
@JoinTable(name = "dados_usuario", joinColumns = { @JoinColumn(name = "fk_usuario") }, inverseJoinColumns = { @JoinColumn(name = "fk_dados") })
@LazyCollection(LazyCollectionOption.TRUE)
public List<DadosUsuario> getDadosUsuarios() {
return this.dadosUsuarios;
}
public void setDadosUsuarios(List<DadosUsuario> dadosUsuarios) {
this.dadosUsuarios = dadosUsuarios;
}
@OneToOne
@JoinColumn(name="fk_config")
public ConfigHorarioLivre getConfig() {
return config;
}
public void setConfig(ConfigHorarioLivre config) {
this.config = config;
}
}

AutorizacoesUsuario.java

@Entity
@Table(name = "autorizacoes_usuario", uniqueConstraints = @UniqueConstraint(columnNames = "id"))
public class AutorizacoesUsuario implements java.io.Serializable {
private int id;
private Usuario usuario;
private Autorizacoes autorizacoes;
public AutorizacoesUsuario() {
}
public AutorizacoesUsuario(Usuario usuario, Autorizacoes autorizacoes) {
this.usuario = usuario;
this.autorizacoes = autorizacoes;
}
@Id
@Column(name = "id", unique = true, nullable = false)
@GeneratedValue(strategy=GenerationType.AUTO)
public int getId() {
return this.id;
}
public void setId(int id) {
this.id = id;
}
@OneToOne
@JoinColumn(name = "fk_usuario", nullable = false, insertable = false, updatable = false)
public Usuario getUsuario() {
return this.usuario;
}
public void setUsuario(Usuario usuario) {
this.usuario = usuario;
}
@OneToOne
@JoinColumn(name = "fk_autorizacoes", nullable = false, insertable = false, updatable = false)
public Autorizacoes getAutorizacoes() {
return this.autorizacoes;
}
public void setAutorizacoes(Autorizacoes autorizacoes) {
this.autorizacoes = autorizacoes;
}
}

Autorizacoes.java

@Entity
@Table(name = "autorizacoes")
public class Autorizacoes implements java.io.Serializable {
private int id;
private String nome;
private String descricao;
public Autorizacoes() {
}
public Autorizacoes(String nome) {
this.nome = nome;
}
public Autorizacoes(String nome, String descricao) {
this.nome = nome;
this.descricao = descricao;
}
@Id
@Column(name = "id", unique = true, nullable = false)
@GeneratedValue(strategy=GenerationType.AUTO)
public int getId() {
return this.id;
}
public void setId(int id) {
this.id = id;
}
@Column(name = "nome", nullable = false, length = 16)
public String getNome() {
return this.nome;
}
public void setNome(String nome) {
this.nome = nome;
}
@Column(name = "descricao", length = 140)
public String getDescricao() {
return this.descricao;
}
public void setDescricao(String descricao) {
this.descricao = descricao;
}
}

Projet complet disponible sur github

--> https://github.com/klebermo/webapp_horario_livre

InformationsquelleAutor Kleber Mota | 2014-04-02
  1. 65

    Vous devez ajouter fetch=FetchType.EAGER à l'intérieur de votre ManyToMany annotations à extraire automatiquement de retour de l'enfant entités:

    @ManyToMany(fetch = FetchType.EAGER)

    Une meilleure option serait de mettre en place un printemps transactionManager en ajoutant les lignes suivantes à votre fichier de configuration spring:

    <bean id="transactionManager"
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<tx:annotation-driven />

    Vous pouvez ensuite ajouter un @Transactional annotation de votre méthode d'authentification comme suit:

    @Transactional
public Authentication authenticate(Authentication authentication)

    Ce sera le début d'une db transaction pour la durée de la méthode d'authentification permettant à toute collection lazy être récupérées à partir de la db comme et quand vous essayez de les utiliser.

    • En fait, j'ai l'transactionManager configuré dans mon application, et je l'utilise dans mes classes DAO. Si j'essaie de l'utiliser dans la méthode d'authentifier de AuthenticationProvider comme vous l'avez suggéré, j'ai une erreur Causés par: java.lang.IllegalArgumentException: ne Peut pas fixer des com.horariolivre.de sécurité.CustomAuthenticationProvider domaine com.horariolivre.de sécurité.SecurityConfig.authenticationProvider à $Proxy36. Je reçois la même erreur si j'utilise l'ajouter fetchType=FetchType.IMPATIENT à l'intérieur de mon ManyToMany annotation (et je peux l'utiliser dans un seul attribut - j'ai trois du même type dans ma classe d'Entité Usuario).
    • Eh bien, vous devez marcher l'enfant entités que vous souhaitez utiliser à l'intérieur d'une Transaction pour éviter la LazyInitializationException. Depuis votre transactionnelle annotation est à l'ofa de niveau sur une méthode générique, vous ne voudrez probablement pas à le faire, vous devrez mettre en place un service de classe en face de la dao qui a l' @Transactional limites de l'intérieur où vous pouvez marcher à l'enfant désiré entités
    InformationsquelleAutor jcmwright80
  2. 21

    Ajout de la propriété suivante à votre persistence.xml peut résoudre votre problème temporairement

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

    Comme @vlad-mihalcea dit que c'est un antipattern et ne permet pas de résoudre l'initialisation tardive problème complètement, initialiser vos associations avant la clôture de la transaction et de l'utilisation des Otd à la place.

    InformationsquelleAutor Mohammad-Hossein Jamali
  3. 17

    La meilleure façon de gérer le LazyInitializationException est d'utiliser le JOIN FETCH directive pour toutes les entités que vous avez besoin de récupérer le long.

    De toute façon, NE l'utilisez PAS des Anti-Modèles comme le suggère quelques réponses:

    Parfois, un DTO projection est un meilleur choix que l'extraction des entités, et de cette façon, vous n'aurez pas de LazyInitializationException.

    • Pouvez-vous s'il vous plaît examiner ici aussi? -stackoverflow.com/questions/39637121/...
    • extraction de jointure est l'équivalent de chargement agressif. Qui peut ne pas être toujours possible ni efficace. Aussi la façon habituelle d'aller chercher de l'objet n'est pas via des requêtes jpql. Le fait que la session ouverte est vue est un antipattern est un long shot, et honnêtement, je suis en désaccord. Il doit être utilisé avec prudence, évidemment, mais il y a beaucoup de parfaitement bien des cas d'utilisation qui en bénéficient.
    • Non, c'est PAS. Open Session in View est hack et un signe que les entités sont récupérés, même pour lire uniquement les projections. Il n'y a pas une telle chose comme un beaucoup de parfaitement bien des cas d'utilisation qui en bénéficient, peu importe comment dur vous essayez de le justifier. Il n'y a aucune excuse pour récupérer plus de données que vous avez vraiment ont besoin, comme il n'y a aucune excuse pour les fuites de la récupération de données à l'extérieur des limites de l'affichage et de la couche de service.
    • SALUT Vlad, Pouvez-vous expliquer pourquoi CHERCHER de JOINTURE n'est pas équivalent à l'désireux de chargement. Je vais dans cet article : blog.arnoldgalovics.com/2017/02/27/... . Et il dit: "c'est Une bonne idée de charger la relation à la fois que vous chargez la Société mère de l'entité. Cela peut être fait avec une Extraction Rejoindre" . Donc, il est impatient de chargement. N'est-ce pas?
    • Désireux de leader implique l'ajout de FetchType.EAGER à vos associations. JOIN FETCH est pour FetchType.LAZY les associations qui doivent être récupérés avec impatience lors de la requête en temps.
    InformationsquelleAutor Vlad Mihalcea
  4. 8

    La raison en est que lorsque vous utilisez le lazy load, la fermeture de la session.

    Il y a deux solutions.

    1. N'utilisez pas le lazy load.

      Ensemble lazy=false en XML ou un Ensemble @OneToMany(fetch = FetchType.EAGER) Dans l'annotation.

    2. Utiliser le lazy load.

      Ensemble lazy=true en XML ou un Ensemble @OneToMany(fetch = FetchType.LAZY) Dans l'annotation.

      et ajouter OpenSessionInViewFilter filter dans votre web.xml

    De détail, Voir mon post.

    https://stackoverflow.com/a/27286187/1808417

    • OpenSessionInViewFilter est aussi un anti-pattern. Je suggère également de ne jamais mettre une cartographie très envie qu'il y aura de nombreux cas, où vous n'avez pas besoin de ces données à la HÂTE collection et vous serez en tirant vers le bas de façon plus de données que celles des cas d'utilisation de besoin et de réduire considérablement vos performances. Veuillez conserver tous les mappages de PARESSEUX et d'ajouter une jointure récupère vos questions sur place.
    InformationsquelleAutor saneryee
  5. 7

    Moi aussi j'avais ce problème quand je faisais des Tests unitaires. Une Solution très Simple à ce problème est l'utilisation @Transactional annotation qui conserve la session ouverte jusqu'à la fin de l'exécution.

    • Êtes-vous de l'utilisation d'Hibernate Transational ou JPA Transactionnelle?
    • J'ai utilisé Hibernate
    InformationsquelleAutor KarthikaSrinivasan
  6. 4

    Vous pouvez utiliser hibernate paresseux initialiseur.

    Ci-dessous le code que vous pouvez consulter.

    Ici PPIDO est l'objet de données qui je veux récupérer

    Hibernate.initialize(ppiDO);
if (ppiDO instanceof HibernateProxy) {
ppiDO = (PolicyProductInsuredDO) ((HibernateProxy) ppiDO).getHibernateLazyInitializer()
.getImplementation();
ppiDO.setParentGuidObj(policyDO.getBasePlan());
saveppiDO.add(ppiDO);
proxyFl = true;
}
    InformationsquelleAutor Mitesh C
  7. 3

    Personnalisé de votre AuthenticationProvider classe doivent être annotées avec les éléments suivants:

    @Transactional

    Cela permettra de s'assurer de la présence de la session hibernate-là.

    InformationsquelleAutor Bilal Ahmed Yaseen
  8. 1

    Je crois plutôt que l'activation désireux d'extraction, - il un sens pour ré-initialiser votre entité où son besoin pour éviter LazyInitializationException exception

    Hibernate.initialize(your entity);
    InformationsquelleAutor Pravin
  9. 1

    Tout d'abord, je tiens à dire que tous les utilisateurs qui se dit sur les paresseux et les transactions ont droit. Mais dans mon cas, il y a une légère différence est que j'ai utilisé le résultat de @Transactional méthode dans un test et qui a été à l'extérieur réel de la transaction, alors je suis ce paresseux exception.

    Ma méthode de service:

    @Transactional
User get(String uid) {};

    Mon code de test:

    User user = userService.get("123");
user.getActors(); //org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role

    Ma solution à ce problème est d'habillage que le code d'une autre opération, comme ceci:

    List<Actor> actors = new ArrayList<>();
transactionTemplate.execute((status) 
-> actors.addAll(userService.get("123").getActors()));
    InformationsquelleAutor vk23
  10. 1

    Pour ceux qui ont ce problème avec la collection des enums ici est de savoir comment le résoudre:

    @Enumerated(EnumType.STRING)
@Column(name = "OPTION")
@CollectionTable(name = "MY_ENTITY_MY_OPTION")
@ElementCollection(targetClass = MyOptionEnum.class, fetch = EAGER)
Collection<MyOptionEnum> options;
    InformationsquelleAutor Sasha Shpota
  11. 0

    Ajouter l'annotation 

    @JsonManagedReference

    Par exemple:

    @ManyToMany(cascade=CascadeType.ALL)
@JoinTable(name = "autorizacoes_usuario", joinColumns = { @JoinColumn(name = "fk_usuario") }, inverseJoinColumns = { @JoinColumn(name = "fk_autorizacoes") })
@JsonManagedReference
public List<AutorizacoesUsuario> getAutorizacoes() {
return this.autorizacoes;
}
    InformationsquelleAutor Mauricio