हाइबरनेट LazyInitializationException को ठीक करने के लिए कैसे: आलसी भूमिकाओं के संग्रह को शुरू करने में विफल रहा, प्रॉक्सी को प्रारंभ नहीं कर सका - कोई सत्र नहीं

Question

मेरे स्प्रिंग प्रोजेक्ट के कस्टम ऑथेंटिकेशनपॉइडर में, मैं लॉग इन उपयोगकर्ता के अधिकारियों की सूची पढ़ने की कोशिश कर रहा हूं, लेकिन मैं निम्नलिखित त्रुटि का सामना कर रहा हूं:

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)

स्टैकऑवरफ्लो में यहां से अन्य विषयों को पढ़ना, मैं समझता हूं कि यह इस तरह से होता है कि इस प्रकार की श्रद्धांजलि फ्रेमवर्क द्वारा नियंत्रित की जाती है, लेकिन मैं अपने मामले का कोई समाधान नहीं निकाल सकता। कोई इंगित कर सकता है कि मैं क्या गलत कर रहा हूं और इसे ठीक करने के लिए मैं क्या कर सकता हूं?

मेरे कस्टम प्रमाणीकरण का कोड है:

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

}

मेरी इकाई वर्ग हैं:

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;
    }
}

गिटहब पर उपलब्ध पूर्ण परियोजना

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

Comments

अपने अधिकारियों को उत्सुकता से प्राप्त करें या OpenSessionInViewFilter का उपयोग करें।

— बार्ट

यह ठीक है कि मैं यह देखने की कोशिश कर रहा हूं कि कैसे करना है। मैंने जो कोशिश की है वह इस प्रकार है: सूची <Autorizacoes> Authority = user.getAutorizacoes () , उपयोगकर्ता नाम के आवंटन से एक ही फ़ंक्शन के अंदर, PasswordAuthenticationToken , लेकिन फिर भी काम नहीं करता है।

— क्लेबर मोटा

@ManyToMany(cascade=CascadeType.ALL, fetch = FetchType.EAGER)

— बार्ट

ठीक है, मैं कोशिश करता हूं, लेकिन फिर भी काम नहीं करता है। मेरे इकाई वर्ग अद्यतन: github.com/klebermo/webapp_horario_livre/blob/master/src/com/... , मेरे वर्तमान AuthenticationProvider: github.com/klebermo/webapp_horario_livre/blob/master/src/com/...

— Kleber मोटा

कैसे

— मार्टिन श्रोडर

Answer 1

fetch=FetchType.EAGERबच्चे की संस्थाओं को स्वचालित रूप से वापस खींचने के लिए आपको अपने कईTMMany एनोटेशन के अंदर जोड़ने की जरूरत है :

@ManyToMany(fetch = FetchType.EAGER)

एक बेहतर विकल्प यह होगा कि आप अपने स्प्रिंग कॉन्फ़िगरेशन फ़ाइल में निम्न जोड़कर एक स्प्रिंग ट्रांजेक्शन मैनजर लागू करें:

<bean id="transactionManager"
    class="org.springframework.orm.hibernate4.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory" />
</bean>

<tx:annotation-driven />

फिर आप अपनी प्रामाणिक विधि में एक @ वर्णनात्मक एनोटेशन जोड़ सकते हैं:

@Transactional
public Authentication authenticate(Authentication authentication)

यह तब प्रमाणीकरण विधि की अवधि के लिए एक db लेन-देन शुरू करेगा, जिससे किसी भी आलसी संग्रह को db से पुनर्प्राप्त करने की अनुमति मिलेगी और जब आप उनका उपयोग करने का प्रयास करेंगे।

Comments

दरअसल, मेरे पास मेरे आवेदन में कॉन्फ़िगर किया गया लेन-देन प्रबंधक है, और मैं इसे अपने डीएओ कक्षाओं में उपयोग करता हूं। अगर मैं आपके द्वारा सुझाए गए प्रमाणीकरणपावडर से प्रमाणित विधि में उपयोग करने की कोशिश करता हूं, तो मुझे एक त्रुटि मिलती है: java.lang.IllegalArgumentException: com.horariolivre.cecurity.CustomAuthenticationProvider फ़ील्ड com.horariolivre.securitySuritySurityCuritySurityCuritySurityCuritySurityCuritySurityCuritySurityCurity के द्वारा सेट नहीं किया जा सकता है। । अगर मुझे मेरे अनेकTotMany एनोटेशन के अंदर भ्रूण (टाइप) भ्रूण (भ्रूण) = FetchType.EAGER का उपयोग करने में एक ही त्रुटि मिलती है (और मैं केवल एक एट्रीब्यूट में इसका उपयोग कर सकता हूं - मेरे एंटिटी क्लास सियारियो में तीन तरह के हैं)

— क्लेबर मोटा

वैसे आपको LazyInitializationException से बचने के लिए उन चाइल्ड एंटिटीज़ को चलना होगा, जिन्हें आप Transaction के भीतर उपयोग करना चाहते हैं। चूँकि आपका व्यवहारिक एनोटेशन एक सामान्य विधि पर डाओ स्तर पर होता है, आप शायद ऐसा नहीं करना चाहेंगे, इसलिए आपको दाओ के सामने एक सेवा वर्ग को लागू करने की आवश्यकता होगी, जिसकी @Transactional सीमाएँ हैं जिसके भीतर से आप चल सकते हैं वांछित बाल संस्थाएँ

— jcmwright80

भविष्य के लिए इसका सामना करने वाले किसी व्यक्ति के लिए प्रोटिप; @ ट्रांसलेशन को एक सार्वजनिक पद्धति पर होना चाहिए। यदि ऐसा नहीं है, तो यह काम नहीं करेगा। कोई चेतावनी हो भी सकती है और नहीं भी।

— निकोलस

लाने के लिए इस्तेमाल किया प्रकार और यह पूरी तरह से काम किया है, सवाल है कि @Transactional काउंटर भाग के लिए उत्सुक लाने का उपयोग करने में क्या अंतर है

— ऑस्टिन

@AustineGwa प्रमुख अंतर जुड़ने के लिए उत्सुकता को जोड़ रहा है इसका मतलब होगा कि बाल संस्थाओं की सूची हमेशा DB से वापस खींच ली जाएगी जब भी मुख्य इकाई को लोड किया जाता है तो संभावित कार्यक्षमता हिट होती है यदि केवल कार्यक्षमता के क्षेत्र होते हैं जिसकी केवल आवश्यकता होती है मुख्य इकाई से डेटा, इसलिए लेन-देन और आलसी लोडिंग का उपयोग करने से आपको वापस खींचे जा रहे डेटा की मात्रा पर अधिक नियंत्रण मिलता है, लेकिन यह पूरी तरह से आपके आवेदन पर निर्भर करता है और उन मामलों का उपयोग करता है जो आपके लिए सही है।

— jcmwright80 15

Answer 2

संभाल करने का सबसे अच्छा तरीकाLazyInitializationExceptionJOIN FETCH उन सभी संस्थाओं के लिए निर्देश का उपयोग करना है जिन्हें आपको लाने की आवश्यकता है।

वैसे भी, कुछ उत्तरों द्वारा सुझाए गए निम्न प्रतिमानों का उपयोग न करें:

• दृश्य में खुला सत्र
• hibernate.enable_lazy_load_no_trans

कभी-कभी, DTO प्रोजेक्शन संस्थाओं को लाने की तुलना में एक बेहतर विकल्प है, और इस तरह, आपको कोई भी नहीं मिलेगा LazyInitializationException।

Comments

लाने के लिए उत्सुक लाने के बराबर है। जो हमेशा संभव नहीं है और न ही कुशल है। साथ ही ऑब्जेक्ट लाने का सामान्य तरीका jpql प्रश्नों के माध्यम से नहीं है। तथ्य यह है कि खुले सत्र में दृश्य एक एंटीपैटर्न है एक लंबा शॉट है, और ईमानदारी से, मैं असहमत हूं। यह सावधानी के साथ इस्तेमाल किया जाएगा, जाहिर है, लेकिन कई पूरी तरह से ठीक उपयोग के मामले हैं जो इससे लाभान्वित होते हैं।

— Fer.marino

नहीं, यह नहीं है । ओपन सेशन इन व्यू हैक है और एक संकेत है कि संस्थाओं को केवल अनुमानों को पढ़ने के लिए लाया जाता है। ऐसी कोई बहुत अच्छी तरह से उपयोग किए जाने वाले मामले नहीं हैं जो इससे लाभान्वित हों , चाहे आप इसे सही ठहराने की कितनी भी कोशिश कर लें। आपके लिए वास्तव में जरूरत से ज्यादा डेटा लाने का कोई बहाना नहीं है, साथ ही ट्रांजैक्शनल सर्विस लेयर की सीमाओं के बाहर डेटा लाने के लिए कोई बहाना नहीं है।

— व्लाद मिहालसी

HI व्लाद, क्या आप यह बता सकते हैं कि FETCH JOIN उत्सुक लोडिंग के बराबर क्यों नहीं है। मैं इस लेख के माध्यम से जा रहा हूँ: blog.arnoldgalovics.com/2017/02/27/… । और यह कहता है "एक बेहतर विचार यह है कि आप जिस समय माता-पिता - कंपनी - इकाई को लोड कर रहे हैं, उस संबंध को लोड करें। यह एक फ़ेच जॉइन के साथ किया जा सकता है"। तो यह एक उत्सुक लोड हो रहा है। है ना?

— Geek

ईगर अग्रणी का अर्थ FetchType.EAGERहै अपने संघों को जोड़ना । जॉइन FETCH उन FetchType.LAZYसंगठनों के लिए है जिन्हें क्वेरी-टाइम पर उत्सुकता से लाने की आवश्यकता है।

— व्लाद मिहालसी

Answer 3

अपनी दृढ़ता के लिए निम्नलिखित संपत्ति जोड़ना। xml आपकी समस्या को अस्थायी रूप से हल कर सकता है

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

जैसा कि @ vlad-mihalcea ने कहा कि यह एक एंटीपैटर्न है और यह आलसी इनिशियलाइज़ेशन समस्या को पूरी तरह से हल नहीं करता है, लेन-देन को बंद करने से पहले अपने संगठनों को इनिशियलाइज़ करें और इसके बजाय डीटीओ का उपयोग करें।

Answer 4

मुझे भी यह समस्या थी जब मैं यूनिट टेस्टिंग कर रहा था। इस समस्या का एक बहुत ही सरल समाधान है @ ट्रान्सएक्टेंशियल एनोटेशन का उपयोग करना जो निष्पादन के अंत तक सत्र को खुला रखता है।

Comments

क्या आप हाइबरनेट ट्रांसेशनल या जेपीए ट्रांसेक्शनल का उपयोग कर रहे हैं?

— jDub9

मैंने हाइबरनेट

— कार्तिकश्रीनिवासन

Answer 5

कारण यह है कि जब आप आलसी लोड का उपयोग करते हैं, तो सत्र बंद हो जाता है।

दो समाधान हैं।

1. आलसी लोड का उपयोग न करें।

   lazy=falseXML में सेट करें या @OneToMany(fetch = FetchType.EAGER)एनोटेशन में सेट करें ।

2. आलसी लोड का उपयोग करें।

   lazy=trueXML में सेट करें या @OneToMany(fetch = FetchType.LAZY)एनोटेशन में सेट करें ।

   और OpenSessionInViewFilter filterअपने में जोड़ेंweb.xml

विस्तार से देखें मेरी पोस्ट

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

Comments

OpenSessionInViewFilter भी एक विरोधी पैटर्न है। मैं यह भी सुझाव देता हूं कि ईएजीईआर के लिए कभी भी मैपिंग सेट न करें क्योंकि ऐसे कई मामले होंगे जहां आपको ईएजीईआर संग्रह में उस डेटा की आवश्यकता नहीं होती है और आप उन डेटा मामलों की तुलना में अधिक डेटा नीचे खींच रहे होंगे जो आपके प्रदर्शन की आवश्यकता को कम करते हैं और आपके प्रदर्शन को बहुत कम करते हैं। कृपया सभी मैपिंग LAZY रखें और इसके बजाय अपनी क्वेरी में ज्वाइन भ्रूण जोड़ें।

— user1567291

Answer 6

आपके कस्टम प्रमाणीकरण Provider वर्ग को निम्नलिखित के साथ एनोटेट किया जाना चाहिए:

@Transactional

यह सुनिश्चित करेगा कि हाइबरनेट सत्र की उपस्थिति वहां भी हो।

Answer 7

आप हाइबरनेट आलसी इनिलाइज़र का उपयोग कर सकते हैं।

नीचे वह कोड है जिसे आप संदर्भित कर सकते हैं।
यहां PPIDOडेटा ऑब्जेक्ट है जिसे मैं पुनः प्राप्त करना चाहता हूं

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

Answer 8

जो लोग इस समस्या के लिए enums के संग्रह के साथ यहाँ है कि यह कैसे हल करने के लिए है:

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

Comments

यह मेरे लिए काम करता है। मैंने @Transactional को जोड़ने के विकल्प का भी परीक्षण किया और यह काम भी करता है। लेकिन मैं इस विकल्प को चुनता हूं।

— रिक दाना

Answer 9

सबसे पहले मैं यह कहना चाहूंगा कि आलसी और लेनदेन के बारे में कहने वाले सभी उपयोगकर्ता सही थे। लेकिन मेरे मामले में थोड़ा अंतर था कि मैंने एक परीक्षण में @ ट्रेंसेक्शनल विधि के परिणाम का उपयोग किया था और यह वास्तविक लेनदेन से बाहर था इसलिए मुझे यह आलसी अपवाद मिला।

मेरी सेवा विधि:

@Transactional
User get(String uid) {};

मेरा परीक्षण कोड:

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

मेरा समाधान इस कोड को इस तरह से दूसरे लेनदेन में लपेटना था:

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

Answer 10

मेरा मानना ​​है कि उत्सुकता को सक्षम करने के बजाय, यह आपकी इकाई को फिर से शुरू करने के लिए समझ में आता है, जहां LazyInitializationExceptionअपवाद से बचने के लिए इसकी आवश्यकता है

Hibernate.initialize(your entity);

Answer 11

JaVers का उपयोग करने वालों के लिए , एक ऑडिटेड इकाई वर्ग को देखते हुए, आप अपवाद के कारण गुणों को अनदेखा करना चाह सकते हैं LazyInitializationException(उदाहरण के लिए उपयोग करके@DiffIgnore एनोटेट ) के ।

यह ऑब्जेक्ट अंतरों की गणना करते समय उन गुणों को अनदेखा करने के लिए रूपरेखा बताता है, इसलिए यह लेन-देन के दायरे से बाहर संबंधित वस्तुओं को डीबी से पढ़ने की कोशिश नहीं करेगा (इस प्रकार अपवाद का कारण बनता है)।

Answer 12

एक आम बात यह है कि @Transactionalअपनी सेवा वर्ग से ऊपर रखें।

@Service
@Transactional
public class MyServiceImpl implements MyService{
...
}

Answer 13

एनोटेशन जोड़ें

@JsonManagedReference

उदाहरण के लिए:

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