问题：

“org.hibernate.TransactionException:不支持嵌套事务”，但我没有嵌套事务

锺离烈

2023-03-14

据我所知，当您尝试在提交前一个事务之前开始一个事务时，会发生这种异常。然而，我不明白为什么在我的情况下会有这种例外。

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

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

关联的应用程序。属性文件包含以下行：

# 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 {

    }

}

这是在网络上映射的。如下所示的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（）方法中调用该方法时，我得到以下Stack Trace：

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

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

谢谢！：）

共有2个答案

柯良骏

2023-03-14

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

详细内容：

在SessionManagerFilter中使用@Transactional

我从来没有在过滤器上测试过@Transactional，因为我通常在@RestController中启动我的事务，但这取决于你。

江烨伟

2023-03-14

好的，上面的代码有几处错误。您似乎混淆了事务性会话和HTTP会话。它们是两种不同的东西。事务会话是数据库调用。将数据库调用封装在事务中，这样，如果出现问题，整个事务就会回滚。如果要使用RESTful体系结构，就不应该使用HTTP会话，因为HTTP会话意味着要在应用程序中的某个位置存储状态。REST操作应该是幂等的（独立的和可重复的）。使用RESTful体系结构，您应该能够执行数千次相同的调用并获得相同的结果，而不会影响应用程序的任何其他部分。

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

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

我将按照以下方式重新构造您的代码：

控制器：

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

您不需要将comptedaImpl声明为@Bean，因为您使用的是@ComponentScan，它将拾取带有@Controller、@RestController、@Service、@Repository、@Component和其他一些注释的类。这些类将可用于自动连接到其他类中。

上述代码分离使得隔离测试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（披露：Q

使用Hibernate注释创建不同的关系
渴望vs懒惰取类型
自动配电实际上是如何工作的/Spring期望如何使用

类似资料：

删除时出现“ org.hibernate.TransactionException：不支持嵌套事务”错误

问题内容：运行removeUserFromConference方法时，遇到以下异常：道方法：模型类：问题答案：您可能已经开始了一笔交易，并尝试开始另一笔交易而没有提交或回滚上一笔交易。使用程序化事务划分时的惯用法如下：这很麻烦且容易出错，这就是为什么使用EJB或Spring具有声明式事务如此有用的原因之一。
为什么JTA不支持嵌套事务

问题内容： JTA为什么不支持嵌套事务？是因为实现它们的复杂性（我对此表示怀疑）还是某些设计原则？问题答案：（正如@Piotr Nowicki指出的那样，JTA 确实允许嵌套事务，但这不是强制性的可选操作。）为什么？这是无法确定地回答的问题之一，除非您是做出决定时“在房间里”的人之一。将嵌套事务作为规范的一部分包括在内可能是固有的复杂性。或当时明显的复杂性；即他们不知道他们知道如何做一个
Postgres支持嵌套事务还是自治事务？

我有一种情况，我必须提交一部分代码作为它自己的事务。我已经创建了一个表：以及plpython3u语言中的函数：第一种情况: 表中的条目正确：1、2、4 第二种情况：表中的值未填充我希望或应该添加到表中，但出乎意料的是没有插入任何值。我想象函数打开了一个新的子事务，它不应该依赖于父事务。如果我是对的，请告诉我。 Postgres中是否存在自主交易？或者我必须修改我的plpython3u函
JTA嵌套事务锁

环境：我们有一个应用程序部署在 JBoss 4.2.3.GA 服务器中，它使用Hibernate 3.4 和 JTA 1.0。有一个导入器创建或更新某些实体，然后导入一些数据。由于多种原因，大部分导入是在新事务中完成的，在每个事务中，在外部事务中创建/更新的实体可能会再次更新。调用序列类似于以下伪代码：服务1：服务2：问题：现在的问题是，我们最终会遇到一个竞争条件，有几个事务试图锁定
如何避免嵌套事务不支持的错误？

问题内容：我需要确保许多并发用户能够访问数据库。虽然在每次提交后我都关闭了会话，但是有时我的代码遇到以下错误，但是当我几次执行相同的操作时，它会超过错误并可以正常工作。我的hibernate状态是4.2.1。我的密码 HibernateUtil 组态问题答案：在您的“我的代码”代码段中，可能存在一些问题：发生异常时，没有阻止关闭会话的块您正在打电话，但这与有所不同。因此，不会清除。
PostgreSQL 8.2中的嵌套事务？

问题内容：我正在研究应用数据库架构更新的脚本。我已经使用start transaction / commit设置了所有的SQL更新脚本。我在命令行上将这些脚本传递给psql。现在，我需要在一个事务中同时应用多个脚本。到目前为止，我想出的唯一解决方案是从原始脚本集中删除启动事务/提交，然后将它们卡在新的启动事务/提交块中。我正在编写perl脚本来即时执行此操作。实际上，我想要嵌套事务，但是我无

“org.hibernate.TransactionException:不支持嵌套事务”，但我没有嵌套事务

共有2个答案

相关问答

相关文章

相关阅读

相关工具

相关文档