Question

我正处于项目的开始阶段。所以我试图设计一个避免Hibernate LazyInitializationExceptions的架构。到目前为止，我的applicationContext.xml有：

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="configLocation">
        <value>/WEB-INF/hibernate.cfg.xml</value>
    </property>
    <property name="configurationClass">
        <value>org.hibernate.cfg.AnnotationConfiguration</value>
    </property>        
    <property name="hibernateProperties">
        <props>
            <prop key="hibernate.dialect">${hibernate.dialect}</prop>        
            <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>     
        </props>
    </property>
    <property name="eventListeners">
        <map>
            <entry key="merge">
                <bean class="org.springframework.orm.hibernate3.support.IdTransferringMergeEventListener"/>
            </entry>
        </map>
    </property>
</bean>

<bean id="dao" class="info.ems.hibernate.HibernateEMSDao" init-method="createSchema">
    <property name="hibernateTemplate">
        <bean class="org.springframework.orm.hibernate3.HibernateTemplate">
            <property name="sessionFactory" ref="sessionFactory"/>
            <property name="flushMode">
                <bean id="org.springframework.orm.hibernate3.HibernateAccessor.FLUSH_COMMIT" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean"/>                    
            </property>
        </bean>
    </property>        
    <property name="schemaHelper">
        <bean class="info.ems.hibernate.SchemaHelper">                                
            <property name="driverClassName" value="${database.driver}"/>
            <property name="url" value="${database.url}"/>
            <property name="username" value="${database.username}"/>
            <property name="password" value="${database.password}"/>
            <property name="hibernateDialect" value="${hibernate.dialect}"/>   
            <property name="dataSourceJndiName" value="${database.datasource.jndiname}"/>
        </bean>                
    </property>
</bean>

hibernate.cfg.xml：

<hibernate-configuration>
    <session-factory>       
        <mapping class="info.ems.models.User" />
        <mapping class="info.ems.models.Role" />
    </session-factory>
</hibernate-configuration>

Role.java：

@Entity
@Table(name="ROLE")
@Access(AccessType.FIELD)
public class Role implements Serializable {

    private static final long serialVersionUID = 3L;

    @Id
    @Column(name="ROLE_ID", updatable=false, nullable=false)
    @GeneratedValue(strategy = GenerationType.IDENTITY) 
    private long id;

    @Column(name="USERNAME")
    private String username;

    @Column(name="ROLE")
    private String role;

    public long getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }
}

User.java：

@Entity
@Table(name = "USER")
@Access(AccessType.FIELD)
public class User implements UserDetails, Serializable {

    private static final long serialVersionUID = 2L;

    @Id
    @Column(name = "USER_ID", updatable=false, nullable=false)
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;

    @Column(name = "USERNAME")
    private String username;

    @Column(name = "PASSWORD")
    private String password;

    @Column(name = "NAME")
    private String name;

    @Column(name = "EMAIL")
    private String email;

    @Column(name = "LOCKED")
    private boolean locked;

    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER, targetEntity = Role.class)
    @JoinTable(name = "USER_ROLE", joinColumns = { @JoinColumn(name = "USER_ID") }, inverseJoinColumns = { @JoinColumn(name = "ROLE_ID") })
    private Set<Role> roles;

    @Override
    public GrantedAuthority[] getAuthorities() {
        List<GrantedAuthorityImpl> list = new ArrayList<GrantedAuthorityImpl>(0);
        for (Role role : roles) {
            list.add(new GrantedAuthorityImpl(role.getRole()));
        }
        return (GrantedAuthority[]) list.toArray(new GrantedAuthority[list.size()]);
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return !isLocked();
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

    public long getId() {
        return id;
    }

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

    @Override
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Override
    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public boolean isLocked() {
        return locked;
    }

    public void setLocked(boolean locked) {
        this.locked = locked;
    }

    public Set<Role> getRoles() {
        return roles;
    }

    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }
}

HibernateEMSDao有两种方法可以从数据库中保存和加载用户：

public void saveUser(final User user) {     
    getHibernateTemplate().execute(new HibernateCallback() {

        @Override
        public Object doInHibernate(Session session) throws HibernateException, SQLException {
            session.flush();
            session.setCacheMode(CacheMode.IGNORE);
            session.save(user);
            session.flush();
            return null;
        }
    });     
}

public User getUser(final Long id) {
    return (User) getHibernateTemplate().execute(new HibernateCallback() {

        @Override
        public Object doInHibernate(Session session) throws HibernateException, SQLException {
            return session.get(User.class, id);
        }
    });
}

现在我测试了如果我将HibernateEMSDao#getUser实现为：

public User getUser(final Long id) {
    getHibernateTemplate().load(User.class, id);        
}

我正在使用LazyInitializationExcaption - 会话已关闭。但第一种方式是正常工作。所以我需要建议在不久的将来避免这种异常。任何一小部分信息都是可观的。

谢谢和问候。

注意：重启服务器后出现错误。

编辑：已添加代码：

public void saveUser(final User user) {     
    Session session = getSession();
    Transaction transaction = session.beginTransaction();
    session.save(user);
    transaction.commit();
    session.close();
}
public User getUser(final Long id) {
    Session session = getSession();
    session.enableFetchProfile("USER-ROLE-PROFILE");
    User user = (User) session.get(User.class, id);
    session.disableFetchProfile("USER-ROLE-PROFILE");
    session.close();
    return user;
}

Answer 1

在使用Hibernate，JPA或ORM时，处理延迟加载是一项持续的挑战。

不仅要防止LazyInitializationException发生，还要有效地进行查询。即使使用通用DAO，策略也应该尽可能多地获取您真正需要的数据。

Apress的Mike Keith出版的书Pro JPA 2专门论述了这一部分，但似乎并没有一个通用的解决方案。

有时它可以帮助进行FETCH连接。这确实意味着你不使用实体管理器的find方法，但是使用JPQL（或HQL，如果这是你的毒药）查询所有内容。您的DAO可以包含一些不同的方法，通过这种方式将实体图形提升到不同的级别。通常以这种方式相当有效地获取数据，但是在很多情况下，您可能会获取太多数据。

Mike Keith建议的另一个解决方案是利用extended persistence context。在这种情况下，上下文（Hibernate会话）不绑定到事务但保持打开状态。因此，实体保持连接并且延迟加载按预期工作。

您必须确保最终关闭扩展上下文。这样做的一种方法是让它由一个绑定到某个范围的有状态会话bean管理，例如：请求范围或会话范围。这样，bean将在此范围的末尾自动销毁，而这将自动关闭上下文。

然而，并非没有自己的问题。开放上下文将继续消耗内存并使其保持打开更长时间（通常比请求范围更长）可能会导致内存不足的严重风险。如果你知道你只与少数几个实体打交道就可以了，但你必须要小心。

依赖于延迟加载的另一个问题是众所周知的1 + N查询问题。迭代甚至中等大小的结果列表可能导致数百或数千个查询被发送到DB。我想我不必解释这会彻底破坏你的表现。

这个1 + N查询问题有时可以通过严重依赖二级缓存来解决。如果实体的数量不是那么大，并且它们不经常更新，那么确保它们都被缓存（使用Hibernate或JPA的第二级实体缓存）可以大大减少这个问题。但是......这是两个大的“如果”。如果您的主要实体仅引用未缓存的单个实体，您将再次获得数百个查询。

另一种方法是利用Hibernate中的fetch profile支持，可以部分地与其他方法结合使用。参考手册在此处有一节：http://docs.jboss.org/hibernate/core/3.5/reference/en/html/performance.html#performance-fetching-profiles

因此，对您的问题似乎没有一个明确的答案，但只有很多想法和做法都高度依赖于您的个人情况。

Answer 2

saveUser不应该刷新会话。刷新会议应该很少见。让Hibernate处理这个问题，你的应用程序将更有效率。

在这样的地方设置缓存模式也很奇怪。你为什么这样做？

关于使用load而不是使用get时出现异常的原因的解释：这是因为加载假定您知道实体存在。它不是执行select查询以从数据库获取用户数据，而是返回一个代理，它将在第一次在对象上调用方法时获取数据。如果在第一次调用方法时会话已关闭，则Hibernate无法再获取数据并抛出异常。应该很少使用load，除非在不必获取数据的情况下启动与现有对象的某种关系。在其他情况下使用get。

我避免使用LazyInitializationException的一般策略是：

尽可能使用附加物品。
文档通过返回分离对象的方法加载哪个图形，并对该图形确实已加载进行单元测试
更喜欢merge而不是upadate和saveOrUpdate。这些方法可以留下附加了某些对象的对象图，而其他对象则根据级联而分离。 merge没有遇到这个问题。

避免Hibernate LazyInitializationExceptions的体系结构

2 个答案: