it-swarm.com.de

Rollback konnte nicht durchgeführt werden, Verbindung wurde geschlossen

Kürzlich habe ich alle meine JAR-Dateien auf die neueste Version aktualisiert (Spring 4.2.x, JPA und Hibernate).

Nun habe ich einige Probleme mit den Testfällen. Hier ist der stackTrace des Tests ...

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

Es sagt, dass die Verbindung geschlossen ist und kein Rollback möglich ist. Schließt die Poolverbindung aus dem Ruhezustand die Verbindung automatisch? Hat jemand eine Idee, woran es liegt?

Edit: Testcode hinzugefügt (der Test ist umfangreich, wenn mehr Informationen benötigt werden, die ich erneut bearbeiten werde)

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

}

Für die XML-Datei

<?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....
17
logger

Beenden Sie die Verwendung von H2 im Servermodus, verwenden Sie es im eingebetteten Modus für @Transactional-Rollback unterstützen.

Die obige Ausnahmebedingung wird ausgelöst, da H2 im Servermodus kein Transaktionsrollback unterstützt. Es wird standardmäßig automatisch festgeschrieben. Sobald Ihre Abfrage ausgeführt wird, wird sie automatisch festgeschrieben und die Sitzung wird geschlossen. Daher verursacht das Rollback die Ausnahme, die ausgelöst wird.

Um H2 im eingebetteten Modus zu verwenden, fügen Sie jar Klassenpfad hinzu und ersetzen Sie die Datenquellen-Bean durch <jdbc:embedded-database id="dataSource" type="H2" />. In Ihrem Fall lautet der Wert id="test.dataSource".

Hier sind einige bekannte Probleme in H2 bei Verwendung im Servermodus:

Meine Empfehlung ist die Verwendung einer Datenbank, die Transaktionen mit Commit und Rollback zum Testen gut unterstützt, z. MySQL InnoDB .

Bitte lassen Sie mich wissen, wenn Sie die Ausnahme weiterhin haben, nachdem Sie dies versucht haben.

1
SyntaX

JPA-Transaktion konnte nicht rückgängig gemacht werden; geschachtelte Ausnahme ist javax.persistence.PersistenceException: unerwarteter Fehler beim Rollbacking.

es bedeutet, dass es eine Unterbrechung gab.

Um Probleme mit dem Verbindungsabbruch zu beheben und jpa in die Lage zu versetzen, die Verbindung zum Datenbankserver wiederherzustellen, sollte application.properties file folgende Eigenschaften enthalten.

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

In Spring 3.2.2 RELEASE (Jira SPR-10395 ) mit Hibernate 4.2 gab es einen ähnlichen Fehler.

Sie verwenden jedoch eine andere Spring-Version. Das Problem scheint in Hibernate Entity Manager zu liegen. (mindestens in 4.2.5 endgültige Version).

Versuchen Sie, diese Abhängigkeit vom Ruhezustand zu ändern (Upgrade oder Ertränkungsgrad):

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