web-dev-qa-db-fra.com

Impossible de revenir en arrière, connexion fermée

Récemment, j'ai mis à niveau tous mes fichiers jar vers la dernière version (Spring 4.2.x, JPA et Hibernate).

Maintenant, je suis confronté à des problèmes avec les cas de test. Voici le stackTrace du test ...

org.springframework.transaction.TransactionSystemException: Could not roll back JPA transaction; nested exception is javax.persistence.PersistenceException: unexpected error when rollbacking
    at org.springframework.orm.jpa.JpaTransactionManager.doRollback(JpaTransactionManager.Java:548)
    at org.springframework.transaction.support.AbstractPlatformTransactionManager.processRollback(AbstractPlatformTransactionManager.Java:853)
    at org.springframework.transaction.support.AbstractPlatformTransactionManager.rollback(AbstractPlatformTransactionManager.Java:830)
    at org.springframework.test.context.transaction.TransactionContext.endTransaction(TransactionContext.Java:125)
    at org.springframework.test.context.transaction.TransactionalTestExecutionListener.afterTestMethod(TransactionalTestExecutionListener.Java:218)
    at org.springframework.test.context.TestContextManager.afterTestMethod(TestContextManager.Java:313)
    at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.Java:93)
    at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.Java:86)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.Java:271)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.Java:241)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.Java:87)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.Java:238)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.Java:63)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.Java:236)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.Java:53)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.Java:229)
    at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.Java:61)
    at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.Java:70)
    at org.junit.runners.ParentRunner.run(ParentRunner.Java:309)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.Java:180)
    at org.Eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.Java:50)
    at org.Eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.Java:38)
    at org.Eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.Java:467)
    at org.Eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.Java:683)
    at org.Eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.Java:390)
    at org.Eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.Java:197)
Caused by: javax.persistence.PersistenceException: unexpected error when rollbacking
    at org.hibernate.jpa.internal.TransactionImpl.rollback(TransactionImpl.Java:111)
    at org.springframework.orm.jpa.JpaTransactionManager.doRollback(JpaTransactionManager.Java:544)
    ... 25 more
Caused by: org.hibernate.TransactionException: rollback failed
    at org.hibernate.engine.transaction.spi.AbstractTransactionImpl.rollback(AbstractTransactionImpl.Java:217)
    at org.hibernate.jpa.internal.TransactionImpl.rollback(TransactionImpl.Java:108)
    ... 26 more
Caused by: org.hibernate.TransactionException: unable to rollback against JDBC connection
    at org.hibernate.engine.transaction.internal.jdbc.JdbcTransaction.doRollback(JdbcTransaction.Java:167)
    at org.hibernate.engine.transaction.spi.AbstractTransactionImpl.rollback(AbstractTransactionImpl.Java:211)
    ... 27 more
Caused by: Java.sql.SQLRecoverableException: Closed Connection
    at Oracle.jdbc.driver.PhysicalConnection.rollback(PhysicalConnection.Java:3948)
    at org.hibernate.engine.transaction.internal.jdbc.JdbcTransaction.doRollback(JdbcTransaction.Java:163)
    ... 28 more

Il dit que la connexion est fermée ... et ne peut pas revenir en arrière. la connexion au pool de hibernate auto ferme-t-elle la connexion? Quelqu'un a-t-il une idée de la cause de cela?

Edit: Code de test ajouté (le test est volumineux si plus d’informations sont nécessaires, je les éditerai à nouveau)

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "testConfig.xml" })
@Transactional
@TransactionConfiguration(transactionManager = "test.txManager", defaultRollback = true)
public class ControllerTest {
... logs ... 

    @Autowired
    private Controller controller;
    static final String testIdValue = "114294";
    ... other decorations...

    private Request createRequest() throws Exception {
        Request r = new Request();
        r.setTask(true);
        other set for test values...
        r.assignTaskList(...);
        ...
        return r;
    }

    @Test
    public void assignEndpointsForsSynchTest() throws Exception {

        Request req = createRequest();

        try {
            Response resp = Controller
                    .assignTask(req);
            assertTrue(req.SUCCESSFUL);
        } catch (Exception e) {
            log.info(e.getMessage());
            fail("Unexpected Exception");
        }
    }

}

Pour le fichier XML

<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
    http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
                    ">

    <bean id="log4jInitialization"
        class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
        <property name="targetClass" value="org.springframework.util.Log4jConfigurer" />
        <property name="targetMethod" value="initLogging" />
        <property name="arguments">
            <list>
                <value>classpath:log4j.properties</value>
            </list>
        </property>
    </bean>

    <bean id="test.dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource"
        lazy-init="false">
        <property name="driverClassName" value="org.h2.Driver" />
        <property name="url"
            value="jdbc:h2:mem:test_mem;DB_CLOSE_DELAY=-1;MODE=Oracle" />
    </bean>

    <jdbc:initialize-database data-source="test.dataSource">
        <jdbc:script location="com/sky/ac/core/engine/comp/schema.sql" />
        <jdbc:script location="com/sky/ac/core/engine/comp/test_data.sql" />
    </jdbc:initialize-database>


    <bean id="test.txManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="test.entityMgrFactory" />
        <property name="jpaDialect"> <!-- to support mixed jpaDAO and jdbcTemplateDAO access -->
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
        </property>
    </bean>

    <bean id="test.entityMgrFactory"
        class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="persistenceUnitName" value="paPersistence" />
        <property name="packagesToScan">
            <list>
                <value>com.sky.ac.core.lock.data</value>
                <value>com.sky.ac.core.vs.dao.jpa</value>
                <value>com.sky.ac.core.sr.data</value>
                <value>com.sky.ac.core.rule.data</value>
                <value>com.sky.ac.core.util.data</value>
                <value>com.sky.ac.core.trace.data</value> 
            </list>
        </property>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="database" value="Oracle" />
            </bean>
        </property>
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">false</prop>
                <prop key="hibernate.cache.provider_class">org.hibernate.cache.NoCacheProvider</prop>
                <prop key="hibernate.id.new_generator_mappings">true</prop>
                <prop key="hibernate.connection.release_mode">after_statement</prop>
            </props>
        </property>
        <property name="dataSource" ref="test.dataSource" />
    </bean>

    <tx:annotation-driven transaction-manager="test.txManager"/>

    <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />

....bean class defs....
javaspringhibernatejpa
17
logger

Arrêtez d'utiliser H2 en mode serveur, utilisez-le en mode intégré pour supporte la restauration @Transactional.

L'exception ci-dessus est levée parce que H2 en mode serveur ne prenant pas en charge l'annulation de transaction, il est auto-commit par défaut. Une fois que votre requête est exécutée, elle est automatiquement validée et la session est fermée. Par conséquent, l'annulation provoque l'exception qui est levée.

Pour utiliser H2 en mode intégré, ajoutez le fichier jar à classpath et remplacez le bean de source de données par <jdbc:embedded-database id="dataSource" type="H2" />. Dans votre cas, la valeur sera id="test.dataSource".

Voici quelques problèmes connus de H2 utilisés en mode serveur:

Ma recommandation est d'utiliser une base de données qui prend bien en charge les transactions avec validation et restauration pour les tests, par exemple. MySQL InnoDB .

S'il vous plaît laissez-moi savoir si vous continuez à avoir l'exception même après avoir essayé cela.

1
SyntaX

Impossible d'annuler la transaction JPA; L'exception imbriquée est javax.persistence.PersistenceException: erreur inattendue lors de l'annulation.

cela signifie qu'il y a eu une déconnexion.

Pour résoudre les problèmes de déconnexion et permettre à jpa de se reconnecter au serveur de base de données, application.properties file doit contenir les propriétés suivantes.

spring.datasource.connection-test-query=SELECT 1
spring.datasource.test-while-idle=true
spring.datasource.test-on-borrow=true
spring.datasource.validation-interval=10000
spring.datasource.log-validation-errors=true
spring.datasource.validation-query=SELECT 1
0
Ravindra babu

Il y avait un bug assez similaire dans Spring 3.2.2 RELEASE (Jira SPR-10395 ) avec Hibernate 4.2.

Cependant, vous utilisez une autre version de Spring. Le problème semble être dans Hibernate Entity Manager. (au moins dans la version finale 4.2.5).

Essayez de changer cette dépendance Hibernate (upgrade ou drowngrade):

 <dependency>
     <groupId>org.hibernate</groupId>
     <artifactId>hibernate-entitymanager</artifactId>
     <version>4.x.x</version>
 </dependency>
0
André Blaszczyk