Spring Hibernate惰性获取集合事务不工作

我完全糊涂了，我一直在用hibernate创建我的第一个Spring应用程序，当从我的数据库懒洋洋地加载对象时，我似乎无法发现我的错误

我的模型如下

团队课程

@Entity
public class Team {

    @Id
    @Column
    @GeneratedValue(strategy=GenerationType.AUTO)
    private int id;
    @Column
    private String name;
    @Column
    private String description;

    @OneToMany(fetch=FetchType.LAZY , cascade = CascadeType.ALL, mappedBy="team")
    @JsonIgnore
    public List<Person> members;

    //Constructors and setters getters ommited
}

@Entity
@Table(name="`person`")
public class Person {

    @Id
    @Column
    @GeneratedValue(strategy=GenerationType.AUTO)
    private int id;
    @Column
    private String name;

    @ManyToOne(fetch=FetchType.LAZY)
    @JoinColumn(name="team")
    @JsonIgnore
    private Team team;

    //omitted constructor and methods
}

然后，我的数据访问对象都遵循与此相同的模式

@Repository
public class TeamDaoImpl implements TeamDao {

    @Autowired
    private SessionFactory session;

    @Override
    public void add(Team team) {
        session.getCurrentSession().save(team);
    }

    @Override
    public void edit(Team team) {
        session.getCurrentSession().update(team);
    }

    @Override
    public void delete(int teamId) {
        session.getCurrentSession().delete(getTeam(teamId));
    }

    @Override
    public Team getTeam(int teamId) {
        return (Team) session.getCurrentSession().get(Team.class, teamId);
    }

    @Override
    public List getAllTeam() {
        return session.getCurrentSession().createQuery("from Team").list();
    }

}

在所有这些方法中，我确保使用当前会话来执行这些操作。据我所知，这确保它将这些调用放入服务类中创建的现有事务中，如下所示：

@Service
public class PersonServiceImpl implements PersonService {

    Logger log = Logger.getLogger(PersonServiceImpl.class);

    @Autowired
    PersonDao personDao;

    @Autowired
    TeamDao teamDao;

    //Ommitted other methods

    @Transactional
    public List getPeopleForTeam(int teamId) {
        log.info("Getting people for team with id " + teamId);
        Team team = teamDao.getTeam(teamId);
        return team.getMembers();
    }

}

我的理解是，

@Transactional

注释应该将该方法放入单个事务中

这一切编译的很好，但当我运行它，我得到以下错误

org.springframework.http.converter.HttpMessageNotWritableException: Could not write JSON: failed to lazily initialize a collection of role: model.Team.members, no session or session was closed; nested exception is 
com.fasterxml.jackson.databind.JsonMappingException: failed to lazily initialize a collection of role: model.Team.members, no session or session was closed
    org.springframework.http.converter.json.MappingJackson2HttpMessageConverter.writeInternal(MappingJackson2HttpMessageConverter.java:207)     

org.springframework.http.converter.AbstractHttpMessageConverter.write(AbstractHttpMessageConverter.java:179)    

org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor.writeWithMessageConverters(AbstractMessageConverterMethodProcessor.java:148)  
org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor.writeWithMessageConverters(AbstractMessageConverterMethodProcessor.java:90)   
org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor.handleReturnValue(RequestResponseBodyMethodProcessor.java:189)     
org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite.handleReturnValue(HandlerMethodReturnValueHandlerComposite.java:69)     
org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:122)     
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandleMethod(RequestMappingHandlerAdapter.java:745)    
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:686)    
org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:80)    
org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:925)    
org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:856)     
org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:936)  
org.springframework.web.servlet.FrameworkServlet.doGet(FrameworkServlet.java:827)   
javax.servlet.http.HttpServlet.service(HttpServlet.java:621)    
org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:812)     
javax.servlet.http.HttpServlet.service(HttpServlet.java:728)    
org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:51)

我做错了什么？我对@Transactional注释的理解是否不正确？如果是这样的话，我应该如何在对象内部延迟加载集合，而在某些事务方法中获取它们呢

编辑：

这是我的spring配置的相关部分

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close" p:driverClassName="${jdbc.driverClassName}"
        p:url="${jdbc.databaseuri}" p:username="${jdbc.username}"  />



 <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="configLocation">
            <value>classpath:hibernate.cfg.xml</value>
        </property>
        <property name="configurationClass">
            <value>org.hibernate.cfg.AnnotationConfiguration</value>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">${jdbc.dialect}</prop>
                <prop key="hibernate.show_sql">true</prop>
            </props>
        </property>
  </bean>

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

类路径：hibernate.cfg.xml
org.hibernate.cfg.AnnotationConfiguration
${jdbc.dial}
真的

这是配置的另一部分

    <mvc:annotation-driven>
        <mvc:message-converters>
            <!-- Use the HibernateAware mapper instead of the default -->
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <bean class="com.bt.opsscreens.mappers.HibernateAwareObjectMapper" />
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

这是控制器的一部分

@RequestMapping(value="/{teamId}/people", method=RequestMethod.GET)
    public @ResponseBody List<Person> getPeopleForTeam(@PathVariable int teamId) {
        return personService.getPeopleForTeam(teamId);
    }

@RequestMapping（value=“/{teamId}/people”，method=RequestMethod.GET）
public@ResponseBody List getPeopleForTeam（@PathVariable int teamId）{
returnpersonservice.getPeopleForTeam（teamId）；
}

您可能从控制器调用服务方法（例如）。发生了什么：

-controller method
    -call service method
        -start transaction
              -hibernate do lazy loading
        -end transaction
    -end service method
    you try to access somethind from the lazy initialied list, but no hibernate transaction    here
-end controller method

延迟加载意味着hibernate有一个代理对象，它只存储实体的id，并且只在需要时执行select语句（例如，访问实体的某些属性）。 您可以在视图中查看

打开会话

，但这被认为是不好的做法。 试着急切地去拿收藏品

编辑： 1） Hibernate要求在事务中执行所有操作 e、 g

2） 延迟加载：Hibernate创建代理对象 （不向争议裁决委员会发出声明）。当你 尝试访问代理时，会向数据库发送一条语句 然后检索结果（这需要在hibernate事务中）

3） Spring通过以下方式简化了事务管理 用AOP截取给定的方法。首先它开始了 事务，然后调用该方法并提交或回滚它

getPeopleForTeam（）返回代理。然后在交易之外的某个地方

---

您访问了某些属性，hibernate试图触发select语句。

您正在访问hibernate会话之外的延迟加载集合，因此，您应该在模型中的每个

@OneToMany

注释之前，从惰性加载更改为渴望加载，或者添加注释

@JsonIgnore

，我面临同样的问题

@JsonIgnore

为我工作，我的理解是，您可以获取对象集并以编程方式使用它，但对于JSON HTTP响应，它被忽略。

我找到了解决此问题的另一个解决方案

您可以显式加载方法中的对象，以便在JSON解析器需要时已经创建了该方法。我试过了，这对我很有效

我的例子是：

public Company getCompany(Long companyId){

    Company company = companyDao.findById(companyId);
    // For avoiding Lazy initialization error. If not done, JSON serializer is unhappy
    // as Address object is not created till that moment when JSON serialization is done.
    for(Address address: company.getAddressSet() ){
        addressDao.findById(address.getId());
    }
    return company;
}

---

但我是否没有访问成员列表并从事务中返回成员？我怎样才能避开这件事？我可以强迫它自己加载成员吗？我也不想急于获取。我想懒洋洋地去表演。但我似乎无法访问这些对象的内容，即使在事务中也是如此，因此我感到困惑。您确定您的事务管理器配置正确吗？您能给我看一下spring配置吗？看一下本教程，了解如何在短时间内配置事务管理器。您需要将会话工厂传递给事务管理器，以便它可以在方法之前启动事务，然后关闭它（使用AOP）。尝试返回新集合->返回新ArrayList（team.getMembers（））；问题似乎出在您的控制器中。您介意发布代码吗？I（或者更准确地说是Evgney）似乎已经解决了我的问题，让我在从事务返回列表中的第一个元素之前访问它。这是否强制它加载列表中的所有对象，而不是返回某种形式的代理？我正在添加控制器，但如果它有帮助的话。'team.getMembers（）'）只返回代理，即没有实际数据。这就是延迟加载的全部意义；）因此，只有当您访问列表中的一项时，Hibernate才会加载某些内容。所以在你的控制器中，列表还没有初始化。Brilliant@JsonIgnore暂时帮了我的忙。。谢谢，@JsonIngore真的有用吗？惰性加载和JsonIgnore是两个不同的东西。

public Company getCompany(Long companyId){

    Company company = companyDao.findById(companyId);
    // For avoiding Lazy initialization error. If not done, JSON serializer is unhappy
    // as Address object is not created till that moment when JSON serialization is done.
    for(Address address: company.getAddressSet() ){
        addressDao.findById(address.getId());
    }
    return company;
}