Java Hibernate延迟初始化-延迟初始化集合失败_Java_Spring_Hibernate

Java Hibernate延迟初始化-延迟初始化集合失败

java spring hibernate

Java Hibernate延迟初始化-延迟初始化集合失败,java,spring,hibernate,Java,Spring,Hibernate,每当我试图从我的用户表中检索数据时，我都会遇到以下错误，我搜索了很多网页，试图找出可能的错误，但找不到任何错误，所以请有人告诉我我缺少了什么/我在这里有错误，来帮我一下好吗错误：错误：org.hibernate.LazyInitializationException-延迟初始化失败初始化角色集合：com.domain.crm.domain.role.users，否会话或会话已关闭 org.hibernate.LazyInitializationException:延迟初始化失败角色集合

每当我试图从我的用户表中检索数据时，我都会遇到以下错误，我搜索了很多网页，试图找出可能的错误，但找不到任何错误，所以请有人告诉我我缺少了什么/我在这里有错误，来帮我一下好吗

错误：

错误：org.hibernate.LazyInitializationException-延迟初始化失败初始化角色集合：com.domain.crm.domain.role.users，否会话或会话已关闭 org.hibernate.LazyInitializationException:延迟初始化失败角色集合：com.domain.crm.domain.role.users，无会话或会议闭幕

用户类别：

@Entity
@Table(name="COM_USER")
public class User {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
@Column(name="USER_ID")
private Long id;

@Column(name="USER_NAME",nullable=false,length=25,unique=true)
private String userName;

@ManyToOne(fetch=FetchType.EAGER)
@JoinColumn(name="ROLE_ID",nullable=false)
private Role role;
}

角色类别：

@Entity
@Table(name="COM_ROLE")
public class Role {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
@Column(name="ROLE_ID")
private Long id;

@Column(name="ROLE",nullable=false,unique=false)
private Integer Role;

@OneToMany(mappedBy="role")
private Set<User> users=new HashSet<User>();
}

@实体
@表（name=“COM\u角色”）
公共阶级角色{
@身份证
@GeneratedValue（策略=GenerationType.AUTO）
@列（name=“ROLE\u ID”）
私人长id；
@列（name=“ROLE”，nullable=false，unique=false）
私有整数角色；
@OneToMany（mappedBy=“角色”）
private Set users=new HashSet（）；
}

正在调用用户DAO类方法以收集所有用户：

public List<User> getUsers(Long page, Long pageSize) {
    Long start = (page-1)*pageSize;     
    return sessionfactory.getCurrentSession().createQuery("from User u ").setFirstResult(start.intValue()).setMaxResults(pageSize.intValue()).list();
}

public List getUsers（长页面，长页面大小）{
长起始=（第1页）*页面大小；
返回sessionfactory.getCurrentSession（）.createQuery（“从用户u”）.setFirstResult（start.intValue（））.setMaxResults（pageSize.intValue（））.list（）；
}

用户服务类方法：

@Transactional
public List<User> getUsers(Long page, Long pageSize) {
    return userdao.getUsers(page, pageSize);
}

@Transactional
公共列表getUsers（长页面、长页面大小）{
返回userdao.getUsers（页面，页面大小）；
}

调用该方法的控制器类：

@RequestMapping(value = "/users/list-user-data")
@ResponseBody
public UserListData listUserData(HttpServletRequest request, HttpServletResponse response, Model model) throws Exception {

    UserListData listData = new UserListData();

    String page = request.getParameter("page");
    Long pageLong = Long.parseLong(page);
    Long pageSize = (long)15;

    List<User> searchResults = iuserservice.getUsers(pageLong, pageSize);

    if( searchResults != null ){
        List<List<Object>> aaData = new ArrayList<List<Object>>();
        List<Object> listItem = null;

        for( User u : searchResults ){
            listItem = new ArrayList<Object>();
            listItem.add(u.getLastName());
            listItem.add(u.getFirstName());
            listItem.add(u.getUserName());
            listItem.add(u.getEmail());
            listItem.add(u.getRole());

            aaData.add(listItem);
        }
        listData.setAaData(aaData);
    }



    int totalCount = iuserservice.getAllUsersCount().intValue();

    System.out.println("Number of records in DB:  "+totalCount);
    listData.setiTotalRecords(totalCount);

    return listData;
}

@RequestMapping（value=“/users/list user data”）
@应答器
公共UserListData listUserData（HttpServletRequest请求、HttpServletResponse响应、模型）引发异常{
UserListData listData=新建UserListData（）；
String page=request.getParameter（“页面”）；
Long pageLong=Long.parseLong（第页）；
长页面大小=（长）15；
List searchResults=iuserservice.getUsers（pageLong，pageSize）；
if（searchResults！=null）{
List aaData=new ArrayList（）；
List listItem=null；
用于（用户u:搜索结果）{
listItem=新的ArrayList（）；
添加（u.getLastName（））；
add（u.getFirstName（））；
添加（u.getUserName（））；
添加（u.getEmail（））；
添加（u.getRole（））；
aaData.add（列表项）；
}
setAaData（aaData）；
}
int totalCount=iuserservice.GetAllUserScont（）.intValue（）；
System.out.println（“数据库中的记录数：“+totalCount”）；
listData.setiTotalRecords（totalCount）；
返回列表数据；
}

最后是我的pom.xml依赖项：

<properties>
    <java-version>1.6</java-version>
    <org.springframework-version>3.1.0.RELEASE</org.springframework-version>
    <org.aspectj-version>1.6.9</org.aspectj-version>
    <org.slf4j-version>1.5.10</org.slf4j-version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${org.springframework-version}</version>
        <exclusions>
            <!-- Exclude Commons Logging in favor of SLF4j -->
            <exclusion>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
             </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${org.springframework-version}</version>
    </dependency>
    <!-- AspectJ -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>${org.aspectj-version}</version>
    </dependency>   
    <!-- Logging -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>${org.slf4j-version}</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>jcl-over-slf4j</artifactId>
        <version>${org.slf4j-version}</version>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>${org.slf4j-version}</version>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.15</version>
        <exclusions>
            <exclusion>
                <groupId>javax.mail</groupId>
                <artifactId>mail</artifactId>
            </exclusion>
            <exclusion>
                <groupId>javax.jms</groupId>
                <artifactId>jms</artifactId>
            </exclusion>
            <exclusion>
                <groupId>com.sun.jdmk</groupId>
                <artifactId>jmxtools</artifactId>
            </exclusion>
            <exclusion>
                <groupId>com.sun.jmx</groupId>
                <artifactId>jmxri</artifactId>
            </exclusion>
        </exclusions>
        <scope>runtime</scope>
    </dependency>

    <!-- @Inject -->
    <dependency>
        <groupId>javax.inject</groupId>
        <artifactId>javax.inject</artifactId>
        <version>1</version>
    </dependency>

    <!-- Servlet -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.1</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
    <!-- Test -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.7</version>
        <scope>test</scope>
    </dependency>        
    <!-- Spring Security -->
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-core</artifactId>
        <version>3.1.3.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-web</artifactId>
        <version>3.1.3.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-config</artifactId>
        <version>3.1.3.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-taglibs</artifactId>
        <version>3.1.3.RELEASE</version>
        <type>jar</type>
        <scope>compile</scope>
    </dependency>       
    <!-- Mysql -->  
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>           
    <!-- Hibernate -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-entitymanager</artifactId>
        <version>3.6.0.Final</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>${org.springframework-version}</version>
    </dependency>       
    <!-- Commons DBCP -->   
    <dependency>
        <groupId>commons-dbcp</groupId>
        <artifactId>commons-dbcp</artifactId>
        <version>1.2.2</version>
    </dependency>   
    <dependency>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-resources-plugin</artifactId>
        <version>2.4.3</version>
    </dependency>   
    <dependency>
        <groupId>net.sf.jasperreports</groupId>
        <artifactId>jasperreports</artifactId>
        <version>5.2.0</version>
    </dependency>    
    <dependency>
        <groupId>commons-collections</groupId>
        <artifactId>commons-collections</artifactId>
        <version>3.1</version>
    </dependency>           
</dependencies>


1.6
3.1.0.1发布
1.6.9
1.5.10
org.springframework
spring上下文
${org.springframework版本}
公用记录
公用记录
org.springframework
SpringWebMVC
${org.springframework版本}
org.aspectj
aspectjrt
${org.aspectj版本}
org.slf4j
slf4j api
${org.slf4j版本}
org.slf4j
jcl-over-slf4j
${org.slf4j版本}
运行时
org.slf4j
slf4j-log4j12
${org.slf4j版本}
运行时
log4j
log4j
1.2.15
javax.mail
邮件
javax.jms
jms
com.sun.jdmk
jmxtools
com.sun.jmx
jmxri
运行时
javax.inject
javax.inject
1.
javax.servlet
servlet api
2.5
假如
javax.servlet.jsp
jsp api
2.1
假如
javax.servlet
jstl
1.2
朱尼特
朱尼特
4.7
测试
org.springframework.security
spring安全内核
3.1.3.1发布
org.springframework.security
spring安全网
3.1.3.1发布
org.springframework.security
spring安全配置
3.1.3.1发布
org.springframework.security
spring安全标记库
3.1.3.1发布
罐子
编译
mysql
mysql连接器java
5.1.6
org.hibernate
休眠实体管理器
3.6.0.1最终版本
org.springframework
春季甲虫
${org.springframework版本}
公共dbcp
公共dbcp
1.2.2
org.apache.maven.plugins
maven资源插件
2.4.3
net.sf.jasperreports
jasperreports
5.2.0
公地收藏
公地收藏
3.1

感谢您的时间

问题在于，

@OneToMany

关联在默认情况下是惰性的，当您调用

getUsers（）

时，您的服务方法中的会话已经关闭。解决这个问题的一种方法是急切地加载子记录但要小心，因为这可能会导致加载太多数据，这会减慢加载速度并耗尽内存。例如，在您的

角色

实体中，如果您将其设置为热切加载

用户

：

@OneToMany(mappedBy="role", fetch = FetchType.EAGER)
private Set<User> users=new HashSet<User>();
}

在某个地方（上面的代码中未显示），您正在访问

角色

实体中的

用户

集合字段的某些方法。

您无法从相同的事务加载

角色

集合，且该集合类型为“急取”。到沃

@Transactional
public UserListData getUserListData(Long page, Long pageSize) {
    List<User> searchResults = userdao.getUsers(page, pageSize);
    UserListData listData = new UserListData();
    if( searchResults != null ){
       List<List<Object>> aaData = new ArrayList<List<Object>>();
       List<Object> listItem = null;

        for( User u : searchResults ){
            listItem = new ArrayList<Object>();
            listItem.add(u.getLastName());
            listItem.add(u.getFirstName());
            listItem.add(u.getUserName());
            listItem.add(u.getEmail());
            listItem.add(u.getRole());

            aaData.add(listItem);
        }
        listData.setAaData(aaData);
    }
 return listData;
}

public List<User> getUsers(Long page, Long pageSize) {
    Long start = (page-1)*pageSize;     
    return sessionfactory.getCurrentSession().createQuery("FROM User u JOIN FETCH u.role ").setFirstResult(start.intValue()).setMaxResults(pageSize.intValue()).list();
}

@ManyToMany
@JoinTable(name = "user_role", joinColumns = @JoinColumn(name = "user_id"), inverseJoinColumns = @JoinColumn(name = "role_id"))
private Set<Role> role = new HashSet<Role>();

@Entity
@Table(name = "user_t")
public class User extends BaseEntity {

    @Column(name = "username", nullable = false, unique = true)
    private String userName;

    @Column(name = "password", nullable = false)
    private String password;

    @ManyToMany
    @JoinTable(name = "user_role", joinColumns = @JoinColumn(name = "user_id"), inverseJoinColumns = @JoinColumn(name = "role_id"))
    private Set<Role> role = new HashSet<Role>();

    // getters & setters
}

@Entity(name = "role_t")
public class Role extends BaseEntity {

    @Column(name = "role_name", nullable = false)
    private String roleName;

    public Role() {
    }

    public Role(String roleName) {
        this.roleName = roleName;
    }

    // getters & setters
}

public interface UserRepository extends JpaRepository<User, Long> {

    @Query("SELECT u FROM User u JOIN FETCH u.role WHERE u.userName = (:userName)")
    public User findByUserNameAndFetchRoles(@Param("userName") String userName);

    @Query("FROM User u JOIN FETCH u.role")
    public List<User> getAllUsersAndFetchRoles(); // **query that you would use!**
}