logo标签列表

"org.hibernate.TransactionException: 不支持嵌套事务" 但我没有嵌套事务。

javaspringhibernatesessiontransactions
3

根据我所了解的，当你在提交之前尝试开始一个事务时会出现这个异常。然而，在我的情况下，我不明白为什么我会遇到这个异常。

我有一个包含以下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的接口：

以下是我的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 Filter，在这里开始了事务：
@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

我不知道我做错了什么。这个框架一定有我不理解的地方。如果您能帮我一下，我将非常感激。

谢谢！:)

你看到异常的具体位置了吗？有打印出来的堆栈跟踪吗？ - Sanj
我刚刚编辑了问题。抱歉，我忘记附上堆栈跟踪了！ - Xavier Jordi
你能否尝试像这样设置会话上下文类属性：setProperty("hibernate.current_session_context_class", env.getProperty("hibernate.current_session_context_class")); - Sanj
我按照你的建议做了，但仍然出现相同的错误。 - Xavier Jordi
2个回答
1

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

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

你之所以遇到异常是因为你试图在事务会话中使用HTTP会话。这是不正确的，会导致许多问题，因为这不是@Transactional的正确使用方式。
我建议按照以下方式重构代码：
控制器：
@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将回滚事务并将异常传播回控制器。

DAO：

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、@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&A）：

在控制器层启动事务。这种方式不能保证REST调用是全部提交还是全部不提交。因此，它的行为与问题版本不同。 - mh-dev
怎么做呢？如果发生异常，那么让Spring回滚事务并在此控制器内或使用@ControllerAdvice注释的专用异常处理控制器中处理异常。 - JamesENL
我了解到开发人员倾向于在控制器中执行多个操作，包括调用不同的服务方法。例如，我调用一个删除x的方法，它可以正常工作，然后调用一个添加y的方法，但是这个方法会抛出异常。在这种情况下，您可能会得到损坏的数据。 - mh-dev
当然，X和Y是独立的实体，Y失败并不会以任何方式影响X。如果不是这样，我同意您需要在同一事务中包装它。此外，如果它们是独立的实体，则应分别进行REST调用以创建每个实体。 - JamesENL
如果控制器以“正确的方式”实现，那么你是对的。但是，经历了太多的生活，不能这样假设 :) - mh-dev
显示剩余2条评论
0

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

具体来说：

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

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

我注释掉了currentSession.beginTransaction()这一行，但在同一个类中的这一行：Session currentSession = sessionFactory.getCurrentSession(); 却出现了空指针异常。 - Xavier Jordi
如果我使用 @Transactional，那么事务会自动创建吗？ - Xavier Jordi
对我来说，似乎你要么是在跟着一个糟糕的教程，要么是在混合不同的教程。 (at)EnableTransactionManagement 激活了 Spring 事务管理。这将由 (at)Transactional 方法触发。这基本上意味着每个方法调用都会被 Spring 跟踪（例如这些不是类内部调用），根据传播方式启动一个事务（如果没有，则默认启动一个）。但我不确定 Spring 在过滤器中会处理什么。 - mh-dev
过滤器用于过滤和操作不同类型的Web请求。您可以拥有HTTP过滤器、FTP过滤器、SSH过滤器等，它们不应该用于事务管理。有关详细信息，请参见我的答案。 - JamesENL
如果他想以更正确的方式实现类似的功能，可以搜索OpenSessionInView。虽然这被认为是一种反模式，但基本上就是他所做的。 - mh-dev
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接