“org.hibernate.TransactionException：不支持嵌套事务”但我没有嵌套事务答案

【问题标题】："org.hibernate.TransactionException: nested transactions not supported" but I didn't nest transactions“org.hibernate.TransactionException：不支持嵌套事务”但我没有嵌套事务
【发布时间】：2016-06-30 07:33:17
【问题描述】：

根据我的阅读，当您在提交前一个事务之前尝试开始事务时会发生此异常。但是，我不明白为什么在我的情况下会出现此异常。

我有一个带有以下 servlet 的 Web 应用程序：

@RestController
public class Hello {

/***** DAO's *******/
@Autowired
CompteDAO compteDAO;


@RequestMapping("/")
public String index() {

    String response = "";   

    /***** COMPTE TEST *****/

    response = response + "======== COMPTE TEST ========= \n";

    response = response + "Compte list : \n";


   ArrayList<Compte> comptes = (ArrayList<Compte>) compteDAO.getAllComptes();

   for(int i = 0; i < comptes.size(); i++) {
       response = response + comptes.get(i).getNomUtilisateur() + "\n";
   }

   response = response + "\n" + "Compte name = ";       
    return response;
}

这是我的 Compte 对象：

public class Compte {

    public int id;
    public String nomUtilisateur;
    public String motDePasse;
    public int typeCompte;
    public String courriel;
    public String cleAPI;
    public boolean visibleLorsDeLaCreation;
    public int joursDisponibilite;
    public int heuresDisponibilite;


    public Compte(){

    }

    public Compte(String nomUtilisateur, String motDePasse, int typeCompte, String courriel, String cleAPI,
            boolean visibleLorsDeLaCreation, int joursDisponibilite, int heuresDisponibilite) {
        this.nomUtilisateur = nomUtilisateur;
        this.motDePasse = motDePasse;
        this.typeCompte = typeCompte;
        this.courriel = courriel;
        this.cleAPI = cleAPI;
        this.visibleLorsDeLaCreation = visibleLorsDeLaCreation;
        this.joursDisponibilite = joursDisponibilite;
        this.heuresDisponibilite = heuresDisponibilite;
    }
    /** Getters and setters omitted **/
}

这是我的 DAO 的界面：

public interface CompteDAO {

    public List<Compte> getAllComptes();    
}

这是它的实现：

@Repository
public class CompteDaoImpl implements CompteDAO {

@Autowired
public SessionFactory sessionFactory;

public CompteDaoImpl() {
}   


@Override
public List<Compte> getAllComptes() {
    Session currentSession = sessionFactory.getCurrentSession();
    List<Compte> comptes;
    comptes = new ArrayList<Compte>(currentSession.createCriteria(Compte.class).list());
    return comptes;
}

另外，这是我的 Spring 配置：

@Configuration  
@EnableTransactionManagement  
@PropertySource({ "classpath:application.properties" })  
@ComponentScan({ "ca.etsmtl.gti525, ca.etsmtl.gti525.pojo" })  
public class PersistenceConfig  
{  
  @Autowired  
  private Environment env;  

  @Bean  
  public LocalSessionFactoryBean sessionFactory() {  
     LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();  
     sessionFactory.setDataSource(restDataSource());  
     sessionFactory.setPackagesToScan(new String[] { "ca.etsmtl.gti525" });  
     sessionFactory.setHibernateProperties(hibernateProperties());
     sessionFactory.setMappingResources(new String[] {  "mapping/Compte.hbm.xml" });

     return sessionFactory;  
  }  

 @Bean  
  public DataSource restDataSource() {  
     BasicDataSource dataSource = new BasicDataSource();  
     dataSource.setDriverClassName(env.getProperty("jdbc.driverClassName"));  
     dataSource.setUrl(env.getProperty("jdbc.url"));  
     dataSource.setUsername(env.getProperty("jdbc.user"));  
     dataSource.setPassword(env.getProperty("jdbc.pass"));  

     return dataSource;  
}

  @Bean
  public CompteDaoImpl compteDAO () {
      CompteDaoImpl compteDAO = new CompteDaoImpl();
      return compteDAO;
  }

  @Bean
  public SessionManagerFilter sessionManagerFilter () {
      SessionManagerFilter sessionManagerFilter = new SessionManagerFilter();
      return sessionManagerFilter;
  }

  @Bean  
  @Autowired  
  public HibernateTransactionManager transactionManager(SessionFactory sessionFactory) {  
     HibernateTransactionManager txManager = new HibernateTransactionManager();  
     txManager.setSessionFactory(sessionFactory);  

     return txManager;  
  }  

  @Bean  
  public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {  
     return new PersistenceExceptionTranslationPostProcessor();  
  }  

  Properties hibernateProperties() {  
     return new Properties() {  
        {  
           setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));  
           setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));  
           setProperty("hibernate.globally_quoted_identifiers", "true");  
        }  
     };  
  }  
}

相关的 application.properties 文件包含以下几行：

# jdbc.X
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost/gti525
jdbc.user=root
jdbc.pass=vente

# hibernate.X
hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.show_sql=false
hibernate.hbm2ddl.auto=create-drop
hibernate.current_session_context_class=thread

最后，我有以下 servlet 过滤器，我开始交易：

@Transactional
public class SessionManagerFilter implements Filter {

    @Autowired
    SessionFactory sessionFactory;


    @Override
    public void destroy() {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
         try {  
                Session currentSession = sessionFactory.getCurrentSession();
                currentSession.beginTransaction();  

                // Call the next filter (continue request processing)  
                chain.doFilter(request, response);  

                // Commit and cleanup  
                sessionFactory.getCurrentSession().getTransaction().commit(); 

            } catch (StaleObjectStateException staleEx) {  
                // Rollback, close everything, possibly compensate for any permanent changes  
                // during the conversation, and finally restart business conversation. Maybe  
                // give the user of the application a chance to merge some of his work with  
                // fresh data... what you do here depends on your applications design.  
                throw staleEx;  
            } catch (Throwable ex) {  
                // Rollback only  
                ex.printStackTrace();  
                try {  
                    if (sessionFactory.getCurrentSession().getTransaction().isActive()) {  
                        sessionFactory.getCurrentSession().getTransaction().rollback();  
                    }  
                } catch (Throwable rbEx) {  

                }  

                throw new ServletException(ex);  
            }  
    }

    @Override
    public void init(FilterConfig arg0) throws ServletException {

    }

}

在 web.xml 文件中映射如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
  <display-name>sitevente2</display-name>

     <filter>  
        <filter-name>SessionManagerFilter</filter-name>  
        <filter-class>ca.etsmtl.gti525.SessionManagerFilter</filter-class> 
        <!-- <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>    -->
    </filter>  

    <filter-mapping>  
        <filter-name>SessionManagerFilter</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping> 


</web-app>

当在 SessionManagerFilter 的 doFilter() 方法中调用 beginTransaction() 方法时，我得到以下堆栈跟踪：

org.hibernate.TransactionException: nested transactions not supported
at org.hibernate.engine.transaction.spi.AbstractTransactionImpl.begin(AbstractTransactionImpl.java:154)
at org.hibernate.internal.SessionImpl.beginTransaction(SessionImpl.java:1435)
at ca.etsmtl.gti525.SessionManagerFilter.doFilter(SessionManagerFilter.java:41)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
at java.lang.reflect.Method.invoke(Unknown Source)
at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:302)
at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:190)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157)
at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:99)
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:281)
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:208)
at com.sun.proxy.$Proxy73.doFilter(Unknown Source)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:240)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:207)
at org.springframework.web.filter.RequestContextFilter.doFilterInternal(RequestContextFilter.java:99)
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:240)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:207)
at org.springframework.web.filter.HttpPutFormContentFilter.doFilterInternal(HttpPutFormContentFilter.java:87)
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:240)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:207)
at org.springframework.web.filter.HiddenHttpMethodFilter.doFilterInternal(HiddenHttpMethodFilter.java:77)
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:240)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:207)
at org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:121)
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:240)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:207)
at org.springframework.boot.context.web.ErrorPageFilter.doFilter(ErrorPageFilter.java:120)
at org.springframework.boot.context.web.ErrorPageFilter.access$000(ErrorPageFilter.java:61)
at org.springframework.boot.context.web.ErrorPageFilter$1.doFilterInternal(ErrorPageFilter.java:95)
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107)
at org.springframework.boot.context.web.ErrorPageFilter.doFilter(ErrorPageFilter.java:113)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:240)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:207)
at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:212)
at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:106)
at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:502)
at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:141)
at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:79)
at org.apache.catalina.valves.AbstractAccessLogValve.invoke(AbstractAccessLogValve.java:616)
at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:88)
at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:522)
at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1095)
at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:672)
at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1500)
at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.run(NioEndpoint.java:1456)
at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
at java.lang.Thread.run(Unknown Source)
2016-03-14 22:14:32.120 ERROR 7284 --- [nio-8080-exec-2]     o.s.t.i.TransactionInterceptor           : Application exception overridden by commit exception

我不知道我做错了什么。这个框架一定有一些我不明白的地方。如果您能帮帮我，我将不胜感激。

谢谢！ :)

【问题讨论】：

您在什么时候看到异常？任何堆栈跟踪？
我刚刚编辑了这个问题。抱歉，我忘记了堆栈跟踪！
你可以尝试像这样设置会话上下文类属性：setProperty("hibernate.current_session_context_class", env.getProperty("hibernate.current_session_context_class"));
我按照你的建议做了，但我仍然得到同样的错误

标签： java spring hibernate session transactions

【解决方案1】：

好的，上面的代码有一些问题。您似乎将Transactional 会话与HTTP 会话混淆了。他们是两个不同的东西。 Transactional 会话是数据库调用。您将数据库调用包装在事务中，以便如果出现问题，整个事情都会回滚。如果您要使用 RESTful 架构，则不应该使用 HTTP 会话，因为 HTTP 会话意味着您将状态存储在应用程序的某个位置。 REST 操作应该是幂等的（独立且可重复）。使用 RESTful 架构，您应该能够执行数千次相同的调用并获得相同的结果，并且不会影响应用程序的任何其他部分。

在 Spring 中，通常有 3 个单独的层。您的控制器管理特定对象的 HTTP 请求和响应，因此您将拥有 CompteController 和其他对象的控制器。这些控制器关注这些对象的 RESTful 操作。 GET、POST、PUT 和 DELETE 请求由控制器处理。控制器通常会通过调用服务类来做到这一点。服务类用于管理事务、操作对象和封装业务逻辑。 DAO 类纯粹用于数据库访问。

您遇到异常是因为您尝试在事务会话旁边使用 HTTP 会话。由于许多不同的原因，这是错误的，并且会导致许多问题，因为这不是应该使用 @Transcational 的方式。

我会重组你的代码如下：

控制器：

@RestController
public class CompteController { 

   @Autowired
   private CompteService compteService;

   @RequestMapping(value="/", method=RequestMethod.GET)
   public List<Compte> getAllCompte() throws Exception {
       /** Because you've used `@RestController` you've indicated that you want your object return in JSON format by this method. **/
       return compteService.getAllCompte();
   }
   /** methods here to handle GET, POST, PUT and DELETE requests**/

}

服务层

public interface CompteService {

    public Compte getCompte(int id);

    public List<Compte> getAllCompte();

    /** Other methods to create, update, manipulate and delete Compte objects **/
}

服务实现

@Service
public class CompteServiceImpl implements CompteService {

    @Autowired
    private CompteDAO compteDao;

    @Override
    @Transctional
    public Compte getCompte(int id) {
        return compteDao.getCompte(id);
    }
    @Override
    @Transcational
    public List<Compte> getAllCompte() {
        return compteDao.getAllCompte();
    }

}

这里的@Transactional注解，会取到负责创建、打开、维护和关闭数据库连接的HibernateTransactionManager。这发生在您注释 @Transactional 的方法周围。如果将@Transactional 放在类上，则所有类方法都将包装在一个事务中。如果抛出异常，则HibernateTransactionManager 将回滚事务并将异常传播回控制器。

道：

public interface CompteDAO {

    public Compte findCompte(int id);

    public List<Compte> findAllCompte();

}

DAO 实现：

@Repository
public class CompteDAOImpl implements CompteDAO {

    @Autowired
    private SessionFactory sessionFactory;

    @Override
    public List<Compte> getAllComptes() {
        Session currentSession = sessionFactory.getCurrentSession();
        List<Compte> comptes = currentSession.createCriteria(Compte.class).list()
        return comptes;
    }
}

您不需要将 CompteDAOImpl 声明为 @Bean，因为您使用的是 @ComponentScan，它将获取带有 @Controller、@RestController、@Service、@Repository、@987654346 注释的类@ 和其他一些人。这些类将可用于自动装配到您的其他类中。

上面的代码分离使得单独测试你的 DAO、服务和控制器变得非常容易。它还将应用程序的逻辑与从数据库中获取对象分开。如果您认为需要显式管理数据库连接，那么一定是出了问题。

如果您特别想捕捉 StaleObjectStateException 并在发生这种情况时做一些不同的事情，那么您可以执行以下操作：

@ControllerAdvice
public class ExceptionHandlerController {

        protected static final Logger logger = LogManager.getLogger(ExceptionHandlerController.class);

    @ExceptionHandler(StaleObjectStateException.class)
    public ResponseEntity<String> handleStaleObjectStateException(StaleObjectStateException  e){
        logger.error("A stale object state exception has been thrown", e);
        /** Will return a HTTP 500 if you throw this exception **/
        return new ReponseEntity<String(HttpStatus.INTERNAL_SERVER_ERROR);
     }
}

进一步阅读 Hibernate 和 Spring（披露：我就该主题创建的问答）：

【讨论】：

在Controller级别启动事务。这种风格不保证一个休息调用要么作为一个整体提交，要么什么都不提交。所以它的行为与问题的版本不同。
怎么样？如果发生异常，则让 Spring 回滚事务并在此控制器内部或使用 @ControllerAdvice 注释的专用异常处理控制器处理异常
我了解到开发人员倾向于在控制器中做不止一件事。这包括调用不同的服务方法。因此，例如，我调用了一个可以正常工作的 delete x 方法，而不是一个引发异常的 add y 方法。在这种情况下，您可能会以损坏的数据结束。
当然，尽管 X 和 Y 是独立的实体，并且 Y 失败的事实不会以任何方式影响 X。如果不是，我同意您需要将其包装在同一事务中。此外，如果它们是单独的实体，则应该是单独的 REST 调用来创建每个实体。
如果控制器的实现方式比你的权利要“正确”。但如果在生活中看到很多假设:)

【解决方案2】：

您在应用程序中使用了两个不同的事务管理系统。

详细说明：

在 SessionManagerFilter 中使用 @Transactional
currentSession.beginTransaction();

我从未在过滤器上测试过@Transactional，因为我通常在@RestController 中开始我的事务，但这取决于你。

【讨论】：

我评论了 currentSession.beginTransaction() 行，它在同一类的这一行中给了我一个空指针异常： Session currentSession = sessionFactory.getCurrentSession();
那么如果我使用@Transactional，事务将自己创建？
在我看来，您要么遵循一个糟糕的教程，要么将不同的混合在一起。 (at)EnableTransactionManagement 激活 spring 事务管理。这将由 (at)Transactiontal 方法触发。这基本上意味着 Spring 跟踪的每个方法调用（例如，这些不是类内部调用）根据传播启动一个事务（如果没有，则默认为启动一个）。但我不确定 Spring 在过滤器中会处理什么。
过滤器用于过滤和操作不同类型的网络请求。您可以有一个 HTTP 过滤器、一个 FTP 过滤器、一个 SSH 过滤器等，它们不应该用于事务管理。详情见我的回答。
如果他想要以更正确的方式谷歌为 OpenSessionInView 提供类似的东西。这被认为是一种反模式，但基本上就是他所做的。