Org.hibernate.LazyInitializationException: could not initialize proxy - no SessionFetchType.LAZ

alextr · Novembro 21, 2013, 3:05pm

Estou tendo problemas em consulta dados de uma entidade com a seguinte declaração em sua entidade:

  @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL, targetEntity = OcorrenciaManutencao.class)
   @JoinColumn(name = "id_ocorrenciaManutencao")

na pagina jsf tenho a seguinte tabela:

  <p:dataTable id="tabelaOs" var="oco" value="#{gerenciarOcorrenciaBean.ocorrenciasListAux}"
                         emptyMessage="Nenhuma ocorrência aberta" rendered="#{gerenciarOcorrenciaBean.usuLogado.alocaOcorrencia == true}">  

                <f:facet name="header">  
                    Ocorrências Abertas
                </f:facet> 
                <p:columnGroup type="header">
                    <p:row>
                        <p:column  style="width: 3em" headerText="Nº O.S"/>
                        <p:column  headerText="DATA SOLICITADO"/>
                        <p:column  headerText="Solicitante"/>
                        <p:column  headerText="Manutencao"/>
                        <p:column  style="width: 8em"  headerText="Status"/>
                        <p:column  style="width: 3em"/>
                    </p:row>
                </p:columnGroup>
                <p:subTable var="o" value="#{oco.ocorrencias}">  
                    <f:facet name="header">  
                        #{oco.tipo}   
                    </f:facet>    
                    <p:column style="#{o.urgenteAlto or o.urgenteBaixo or o.urgenteMedio == true? 'color: red' : red}">
                        <h:outputText value="#{o.id}"/>
                    </p:column>
                    <p:column style="#{o.urgenteAlto or o.urgenteBaixo or o.urgenteMedio == true? 'color: red' : red}">
                        <h:outputText value="#{o.dataSolicitacao}">
                            <f:convertDateTime pattern="dd/MM/yyyy HH:mm" timeZone="GMT-3"/>
                        </h:outputText>
                    </p:column>
                    <p:column style="#{o.urgenteAlto or o.urgenteBaixo or o.urgenteMedio == true? 'color: red' : red}">
                        <h:outputText value="#{o.usuarioSolicitante.nome}" title="RAMAL: #{o.usuarioSolicitante.ramal} - EMAIL:#{o.usuarioSolicitante.email_corp}"/>
                    </p:column>
                    <p:column style="#{o.urgenteAlto or o.urgenteBaixo or o.urgenteMedio == true? 'color: red' : red}">
                        <h:outputText value="#{o.ocorrenciaManutencao.motivo}"/> // NESSA PARTE DE PUXAR O MOTIVO DA ENTIDADE OCORRENCIA MANUTENCAO DA O //ERRO
                    </p:column>
                    <p:column style="#{o.urgenteAlto or o.urgenteBaixo or o.urgenteMedio == true? 'color: red' : red}">
                        <h:outputText value="#{o.statusOcorrencia == 1? 'Aberta':'' 
                                               or o.statusOcorrencia == 2? 'EM ANDAMENTO':''
                                               or o.statusOcorrencia == 3? 'FECHADA':''
                                               or o.statusOcorrencia == 4? 'CANCELADA':''}"/>
                    </p:column>
                    <p:column>
                        <p:commandButton id="btAlocar" icon="ui-icon-key" title="Alocar Usuários" actionListener="#{gerenciarOcorrenciaBean.buscaOcorrencia(o,oco.tipo)}"/>
                    </p:column>
                </p:subTable>  
                <p:columnGroup type="footer">  
                    <p:row>  
                        <p:column/>
                        <p:column/>
                        <p:column footerText="TOTAL: " style="text-align:right"/>  
                        <p:column footerText="#{gerenciarOcorrenciaBean.ocorrencias.size()}" />  
                        <p:column/>
                    </p:row>  
                </p:columnGroup>  
            </p:dataTable>

Entendo o porque o erro acontece, pois a entidade está declarada como FetchType.LAZY, estou errado nessa conclusão?
Porém não faço ideia de como achar uma solução para esse problema, alguém pode me ajuda?

Hebert_Coelho · Novembro 21, 2013, 3:07pm

Esse post explica o problema e mostra soluções:

http://uaihebert.com/?p=1367

alextr · Novembro 21, 2013, 3:40pm

Em certa parte funcionou, mudei de Lazy para EAGER, porém não sei se vai pode mudar, é necessário fazer uma conversão disso, mais obrigado pela ajuda, obrigado.

Hebert_Coelho · Novembro 21, 2013, 3:41pm

[quote=alextr]Em certa parte funcionou, mudei de Lazy para EAGER, porém não sei se vai pode mudar, é necessário fazer uma conversão disso, mais obrigado pela ajuda, obrigado.[/quote]Oq seria conversão?

alextr · Novembro 21, 2013, 4:35pm

vamos complicar um pouco, com EAGER funcionou, porém não posso deixar com Eager tem que ser LAZY, pois na mesma entidade possui vários lazys e eagers:


@Entity
@Table(name = "ocorrencia", schema = "xxxxxxxxx")
@SequenceGenerator(name = "ocorrencia_seq", sequenceName = "ocorrencia_seq")
public class Ocorrencia implements Serializable {

    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO, generator = "ocorrencia_seq")
    private Long id;
    //VARIÁVEIS ----------------------------------------------------------------
    @Column(name = "JustificaPendencia")
    private String jutificaPendencia;
    @Column(name = "JustificaCancela")
    private String justificaCancela;
    @Column(name = "StatusOcorrencia")
    private Integer statusOcorrencia;
    @Column(name = "urgenteBaixo")
    private Boolean urgenteBaixo = Boolean.FALSE;
    @Column(name = "urgenteMedio")
    private Boolean urgenteMedio = Boolean.FALSE;
    @Column(name = "urgenteAlto")
    private Boolean urgenteAlto = Boolean.FALSE;
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "dataSolicitacao", updatable = false)
    private Date dataSolicitacao;
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "dataExecucao")
    private Date dataExecucao;
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "dataAlocado")
    private Date dataAlocado;
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "dataSolicitaCancela")
    private Date dataSolicitaCancelamento;
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "dataCancela")
    private Date dataCancela;
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "dataConfirmaCancela")
    private Date dataConfirmaCancela;
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "dataJustifica")
    private Date dataJustica;
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "dataFechamento")
    private Date dataFechamento;
    //--------------------------------------------------------------------------
    //RELACIONAMENTOS @ManyToOne -----------------------------------------------
    @ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, targetEntity = Usuario.class)
    @JoinColumn(name = "id_usuarioSolicitanta", updatable = false)
    private Usuario usuarioSolicitante;
    @ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, targetEntity = Usuario.class)
    @JoinColumn(name = "id_usuarioAlocou")
    private Usuario usuarioAlocou;
    @ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, targetEntity = Usuario.class)
    @JoinColumn(name = "id_usuarioCancela")
    private Usuario usuarioCancela;
    @ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, targetEntity = Usuario.class)
    @JoinColumn(name = "id_usuarioConfirmaCancela")
    private Usuario usuarioConfirmaCancela;
    @ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, targetEntity = Usuario.class)
    @JoinColumn(name = "id_usuarioFechamento")
    private Usuario usuarioFechamento;
    @ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, targetEntity = Usuario.class)
    @JoinColumn(name = "id_usuarioSolicitaFechamento")
    private Usuario usuarioSolicitaFechamento;
    @ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, targetEntity = Usuario.class)
    @JoinColumn(name = "id_usuarioJustifica")
    private Usuario usuarioJustifica;
    @ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, targetEntity = Unidade.class)
    @JoinColumn(name = "id_unidade")
    private Unidade unidade;
    //--------------------------------------------------------------------------
    //RELACIONAMENTOS OneToOne -----------------------------------------------------------------
    @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL, targetEntity = OcorrenciaLink.class)
    @JoinColumn(name = "id_ocorrenciaLink")
    private OcorrenciaLink ocorrenciaLink;
    @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL, targetEntity = OcorrenciaTesteLink.class)
    @JoinColumn(name = "id_ocorrenciaTLink")
    private OcorrenciaTesteLink ocorrenciaTesteLink;
    @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL, targetEntity = OcorrenciaOperacao.class)
    @JoinColumn(name = "id_ocorrenciaOperacao")
    private OcorrenciaOperacao ocorrenciaOperacao;
    @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL, targetEntity = OcorrenciaManutencao.class)
    @JoinColumn(name = "id_ocorrenciaManutencao")
    private OcorrenciaManutencao ocorrenciaManutencao;
    @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL, targetEntity = OcorrenciaSuporte.class)
    @JoinColumn(name = "id_ocorrenciaSuporte")
    private OcorrenciaSuporte ocorrenciaSuporte;
    @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL, targetEntity = OcorrenciaNews.class)
    @JoinColumn(name = "id_ocorrenciaNews")
    private OcorrenciaNews ocorrenciaNews;
    @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL, targetEntity = OcorrenciaTelecom.class)
    @JoinColumn(name = "id_ocorrenciaTelecom")
    private OcorrenciaTelecom ocorrenciaTelecom;
    @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL, targetEntity = OcorrenciaFalha.class)
    @JoinColumn(name = "id_ocorrenciaFalha")
    private OcorrenciaFalha ocorrenciaFalha;
    //--------------------------------------------------------------------------
    //RELACIONAMENTOS @OneToMany-------------------------------------------------
    @OneToMany(fetch = FetchType.LAZY, cascade = {CascadeType.ALL}, mappedBy = "ocorrenciaUsuarioPK.ocorrencia")
    private List<OcorrenciaUsuario> ocorrenciasUsuarios;
    @OneToMany(fetch= FetchType.LAZY,cascade= CascadeType.ALL, mappedBy="ocorrencia",targetEntity=Comment.class)
    private List<Comment> comments;
    
    //--------------------------------------------------------------------------
    //Getters' and Setters------------------------------------------------------

    
}

ou seja se eu deixa-se EAGER irei prejudicar o desempenho do meu sistema.
Além disso a tabela onde será mostrado os valores incluindo o motivo da entidade ocorrenciaManutencao é populada de um jeito diferente:

Eu possuo uma entidade(que nao é de persistencia) que me auxilia nisso, ela é responsavel por consultar e me buscar a ocorrencia, que junto com ela vem o id da ocorrenciaManutencao:

[code]

public class OcorrenciasAux implements Serializable{
private String tipo;
private List ocorrenciaImpls = new ArrayList();
private List ocorrencias = new ArrayList();

public List<Ocorrencia> getOcorrencias() {
    return ocorrencias;
}

public void setOcorrencias(List<Ocorrencia> ocorrencias) {
    this.ocorrencias = ocorrencias;
}


public OcorrenciasAux(String tipo) {
    this.tipo = tipo;
}

public String getTipo() {
    return tipo;
}

public void setTipo(String tipo) {
    this.tipo = tipo;
}

public List<OcorrenciaImpl> getOcorrenciaImpls() {
    return ocorrenciaImpls;
}

public void setOcorrenciaImpls(List<OcorrenciaImpl> ocorrenciaImpls) {
    this.ocorrenciaImpls = ocorrenciaImpls;
}

}

E então eu passo uma outra chamada OcorrenciaImpl que me pega alguns dado para me ajudar a popular a tabela e a sua subtable:


public class OcorrenciaImpl implements Serializable {

    private Integer id;
    private Unidade unidade;
    private Usuario usuarioSolicitante;
    private Date dataSolicitacao;
    private Integer status;
    private Usuario usuarioCancela;
    private List<OcorrenciaUsuario> usuariosAlocado;

    public OcorrenciaImpl(Integer id, Unidade unidade, Usuario usuarioSolicitante, Date dataSolicitacao, Integer status, Usuario usuarioCancela, List<OcorrenciaUsuario> usuariosAlocado) {
        this.id = id;
        this.unidade = unidade;
        this.usuarioSolicitante = usuarioSolicitante;
        this.dataSolicitacao = dataSolicitacao;
        this.status = status;
        this.usuarioCancela = usuarioCancela;
        this.usuariosAlocado = usuariosAlocado;
    }

    


    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Unidade getUnidade() {
        return unidade;
    }

    public void setUnidade(Unidade unidade) {
        this.unidade = unidade;
    }

    public Usuario getUsuarioSolicitante() {
        return usuarioSolicitante;
    }

    public void setUsuarioSolicitante(Usuario usuarioSolicitante) {
        this.usuarioSolicitante = usuarioSolicitante;
    }

    public Date getDataSolicitacao() {
        return dataSolicitacao;
    }

    public void setDataSolicitacao(Date dataSolicitacao) {
        this.dataSolicitacao = dataSolicitacao;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    public List<OcorrenciaUsuario> getUsuariosAlocado() {
        return usuariosAlocado;
    }

    public void setUsuariosAlocado(List<OcorrenciaUsuario> usuariosAlocado) {
        this.usuariosAlocado = usuariosAlocado;
    }

    public Usuario getUsuarioCancela() {
        return usuarioCancela;
    }

    public void setUsuarioCancela(Usuario usuarioCancela) {
        this.usuarioCancela = usuarioCancela;
    }
    
    
}

depois de tudo em seu lugar, eu vou para o meu método de popular a tabela e a sua subtable:

   public void populaOcorrenciasUnidade() {
        ocorrencias = new ArrayList<Ocorrencia>();
        ocorrenciasListAux = new ArrayList<OcorrenciasAux>();

        buscaOcorrencias("todos");
        OcorrenciasAux links = new OcorrenciasAux("link");
        OcorrenciasAux testeLinks = new OcorrenciasAux("testelink");
        OcorrenciasAux manutencao = new OcorrenciasAux("manutenção");
        OcorrenciasAux operacao = new OcorrenciasAux("operação");
        OcorrenciasAux falha = new OcorrenciasAux("falha");
        OcorrenciasAux news = new OcorrenciasAux("news");
        OcorrenciasAux telecom = new OcorrenciasAux("telecom");
        OcorrenciasAux suporte = new OcorrenciasAux("suporte");
        statusOs=1;
ocorrencias = ocorrenciaFacade.buscarOcorrenciaUnidade(UsuarioLogadoUtils.usuarioLogado().getUnidade().getUnidade()); 

for (Ocorrencia o : ocorrencias) {
            if (o.getOcorrenciaLink() != null) {
                ocoLink = 0;
                links.getOcorrencias().add(o);
              ocoLink = links.getOcorrencias().size();
              
            } else if (o.getOcorrenciaManutencao() != null) {
                ocoManutencao = 0;
                
    
                manutencao.getOcorrencias().add(o);
                ocoManutencao = manutencao.getOcorrencias().size();
               
            } else if (o.getOcorrenciaOperacao() != null) {
                ocoOpercao = 0;
                operacao.getOcorrencias().add(o);
                ocoOpercao = operacao.getOcorrencias().size();
            } else if (o.getOcorrenciaFalha() != null) {
                ocoFalhas = 0;
                falha.getOcorrencias().add(o);
                ocoFalhas = falha.getOcorrencias().size();
            } else if (o.getOcorrenciaNews() != null) {
                ocoNews = 0;
                news.getOcorrencias().add(o);
                ocoNews = news.getOcorrencias().size();
                
            } else if (o.getOcorrenciaTelecom() != null) {
                ocoTelecom = 0;
                telecom.getOcorrencias().add(o);
                ocoTelecom = telecom.getOcorrencias().size();
            } else if (o.getOcorrenciaSuporte() != null) {
                ocoSuporte = 0;
                suporte.getOcorrencias().add(o);
                ocoSuporte = suporte.getOcorrencias().size();
            } else if (o.getOcorrenciaTesteLink() != null) {
                ocoTesteLink = 0;
                testeLinks.getOcorrencias().add(o);
                ocoTesteLink = testeLinks.getOcorrencias().size();
            }
        }
//        if (!links.getOcorrencias().isEmpty()) {
//            ocorrenciasListAux.add(links);
//        }
        if (!manutencao.getOcorrencias().isEmpty()) {
            ocorrenciasListAux.add(manutencao);
        }
//        if (!operacao.getOcorrencias().isEmpty()) {
//            ocorrenciasListAux.add(operacao);
//        }
//        if (!falha.getOcorrencias().isEmpty()) {
//            ocorrenciasListAux.add(falha);
//        }
        if (!news.getOcorrencias().isEmpty()) {
            ocorrenciasListAux.add(news);
        }
//        if (!telecom.getOcorrencias().isEmpty()) {
//            ocorrenciasListAux.add(telecom);
//        }
//        if (!suporte.getOcorrencias().isEmpty()) {
//            ocorrenciasListAux.add(suporte);
//           
//        }
//        if (!testeLinks.getOcorrencias().isEmpty()) {
//            ocorrenciasListAux.add(testeLinks);
//        }
    }

e o meu facede que busca:


public List<Ocorrencia> buscarOcorrenciaUnidade(String unidadeBusca) {
        
        Session session;
        
        if (em.getDelegate() instanceof EntityManagerImpl) {
            EntityManagerImpl entityManagerImpl = (EntityManagerImpl) em.getDelegate();
            session = entityManagerImpl.getSession();
        } else {
            session = (Session) em.getDelegate();
        }
        Criteria crit = session.createCriteria(Ocorrencia.class);
        Disjunction ou = Restrictions.disjunction();
        
        crit.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
        
        if (unidadeBusca != null) {
            crit.createAlias("unidade", "u");
            crit.add(Restrictions.eq("u.unidade", unidadeBusca));
        }
        
        
        ou.add(Restrictions.eq("statusOcorrencia", Integer.parseInt("1")));
        ou.add(Restrictions.eq("statusOcorrencia",  Integer.parseInt("2")));
        crit.add(ou);
      
        
      
       
        crit.addOrder(Order.desc("urgenteAlto"));
        crit.addOrder(Order.desc("urgenteMedio"));
        crit.addOrder(Order.desc("urgenteBaixo"));
        crit.addOrder(Order.asc("dataSolicitacao"));
        
        return crit.list();
    }

Hebert_Coelho · Novembro 21, 2013, 4:38pm

Desculpe, você postou tanto código que eu me perdi.

Vou deixar outra pessoa te ajudar. até mais.

alextr · Novembro 21, 2013, 4:40pm

O loco? se assusta não, eu ainda resumi bastante =)

system · Dezembro 30, 2015, 3:01pm

Org.hibernate.LazyInitializationException: could not initialize proxy - no SessionFetchType.LAZ

Cursos de Mobile

Cursos de Programação

Cursos de Front-end

Cursos de DevOps

Cursos de Design & UX

Cursos de Business

Cursos de Data & BI