root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

Jpa/JdoTransactionManager passes resolved timeout into Jpa/JdoDialect's beginTransaction; HibernateJpaDialect applies timeout onto native Hibernate Transaction before begin call (SPR-5195)

This commit is contained in:
Juergen Hoeller 2009-09-08 22:35:32 +00:00
parent 414d6633ea
commit 45dc856993
5 changed files with 121 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
org.springframework.orm/src/main/java/org/springframework/orm/jdo/JdoTransactionManager.java
View File

@ -35,6 +35,7 @@ import org.springframework.transaction.TransactionException;
import org.springframework.transaction.TransactionSystemException;
import org.springframework.transaction.support.AbstractPlatformTransactionManager;
import org.springframework.transaction.support.DefaultTransactionStatus;
import org.springframework.transaction.support.DelegatingTransactionDefinition;
import org.springframework.transaction.support.ResourceTransactionManager;
import org.springframework.transaction.support.TransactionSynchronizationManager;
@ -299,7 +300,7 @@ public class JdoTransactionManager extends AbstractPlatformTransactionManager
"on a single DataSource, no matter whether JDO or JDBC access.");
}
PersistenceManager pm = null;
PersistenceManager pm;
try {
if (txObject.getPersistenceManagerHolder() == null ||
@ -314,13 +315,19 @@ public class JdoTransactionManager extends AbstractPlatformTransactionManager
pm = txObject.getPersistenceManagerHolder().getPersistenceManager();
// Delegate to JdoDialect for actual transaction begin.
Object transactionData = getJdoDialect().beginTransaction(pm.currentTransaction(), definition);
final int timeoutToUse = determineTimeout(definition);
Object transactionData = getJdoDialect().beginTransaction(pm.currentTransaction(),
new DelegatingTransactionDefinition(definition) {
@Override
public int getTimeout() {
return timeoutToUse;
}
});
txObject.setTransactionData(transactionData);
// Register transaction timeout.
int timeout = determineTimeout(definition);
if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
txObject.getPersistenceManagerHolder().setTimeoutInSeconds(timeout);
if (timeoutToUse != TransactionDefinition.TIMEOUT_DEFAULT) {
txObject.getPersistenceManagerHolder().setTimeoutInSeconds(timeoutToUse);
}
// Register the JDO PersistenceManager's JDBC Connection for the DataSource, if set.
@ -328,8 +335,8 @@ public class JdoTransactionManager extends AbstractPlatformTransactionManager
ConnectionHandle conHandle = getJdoDialect().getJdbcConnection(pm, definition.isReadOnly());
if (conHandle != null) {
ConnectionHolder conHolder = new ConnectionHolder(conHandle);
if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
conHolder.setTimeoutInSeconds(timeout);
if (timeoutToUse != TransactionDefinition.TIMEOUT_DEFAULT) {
conHolder.setTimeoutInSeconds(timeoutToUse);
}
if (logger.isDebugEnabled()) {
logger.debug("Exposing JDO transaction as JDBC transaction [" + conHolder.getConnectionHandle() + "]");

19
org.springframework.orm/src/main/java/org/springframework/orm/jpa/JpaTransactionManager.java
View File

@ -42,6 +42,7 @@ import org.springframework.transaction.TransactionException;
import org.springframework.transaction.TransactionSystemException;
import org.springframework.transaction.support.AbstractPlatformTransactionManager;
import org.springframework.transaction.support.DefaultTransactionStatus;
import org.springframework.transaction.support.DelegatingTransactionDefinition;
import org.springframework.transaction.support.ResourceTransactionManager;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.util.CollectionUtils;
@ -327,13 +328,19 @@ public class JpaTransactionManager extends AbstractPlatformTransactionManager
EntityManager em = txObject.getEntityManagerHolder().getEntityManager();
// Delegate to JpaDialect for actual transaction begin.
Object transactionData = getJpaDialect().beginTransaction(em, definition);
final int timeoutToUse = determineTimeout(definition);
Object transactionData = getJpaDialect().beginTransaction(em,
new DelegatingTransactionDefinition(definition) {
@Override
public int getTimeout() {
return timeoutToUse;
}
});
txObject.setTransactionData(transactionData);
// Register transaction timeout.
int timeout = determineTimeout(definition);
if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
txObject.getEntityManagerHolder().setTimeoutInSeconds(timeout);
if (timeoutToUse != TransactionDefinition.TIMEOUT_DEFAULT) {
txObject.getEntityManagerHolder().setTimeoutInSeconds(timeoutToUse);
}
// Register the JPA EntityManager's JDBC Connection for the DataSource, if set.
@ -341,8 +348,8 @@ public class JpaTransactionManager extends AbstractPlatformTransactionManager
ConnectionHandle conHandle = getJpaDialect().getJdbcConnection(em, definition.isReadOnly());
if (conHandle != null) {
ConnectionHolder conHolder = new ConnectionHolder(conHandle);
if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
conHolder.setTimeoutInSeconds(timeout);
if (timeoutToUse != TransactionDefinition.TIMEOUT_DEFAULT) {
conHolder.setTimeoutInSeconds(timeoutToUse);
}
if (logger.isDebugEnabled()) {
logger.debug("Exposing JPA transaction as JDBC transaction [" + conHolder.getConnectionHandle() + "]");

8
org.springframework.orm/src/main/java/org/springframework/orm/jpa/vendor/HibernateJpaDialect.java vendored
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2008 the original author or authors.
* Copyright 2002-2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -18,7 +18,6 @@ package org.springframework.orm.jpa.vendor;
import java.sql.Connection;
import java.sql.SQLException;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceException;
@ -38,7 +37,7 @@ import org.springframework.transaction.TransactionException;
/**
* {@link org.springframework.orm.jpa.JpaDialect} implementation for
* Hibernate EntityManager. Developed and tested against Hibernate 3.2.
* Hibernate EntityManager. Developed and tested against Hibernate 3.3.
*
* @author Costin Leau
* @author Juergen Hoeller
@ -50,6 +49,9 @@ public class HibernateJpaDialect extends DefaultJpaDialect {
public Object beginTransaction(EntityManager entityManager, TransactionDefinition definition)
throws PersistenceException, SQLException, TransactionException {
if (definition.getTimeout() != TransactionDefinition.TIMEOUT_DEFAULT) {
getSession(entityManager).getTransaction().setTimeout(definition.getTimeout());
}
super.beginTransaction(entityManager, definition);
return prepareTransaction(entityManager, definition.isReadOnly(), definition.getName());
}

45
org.springframework.transaction/src/main/java/org/springframework/transaction/interceptor/DelegatingTransactionAttribute.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2008 the original author or authors.
* Copyright 2002-2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -18,7 +18,7 @@ package org.springframework.transaction.interceptor;
import java.io.Serializable;
import org.springframework.util.Assert;
import org.springframework.transaction.support.DelegatingTransactionDefinition;
/**
* {@link TransactionAttribute} implementation that delegates all calls to a given target
@ -29,7 +29,8 @@ import org.springframework.util.Assert;
* @author Juergen Hoeller
* @since 1.2
*/
public abstract class DelegatingTransactionAttribute implements TransactionAttribute, Serializable {
public abstract class DelegatingTransactionAttribute extends DelegatingTransactionDefinition
implements TransactionAttribute, Serializable {
private final TransactionAttribute targetAttribute;
@ -39,31 +40,11 @@ public abstract class DelegatingTransactionAttribute implements TransactionAttri
* @param targetAttribute the target TransactionAttribute to delegate to
*/
public DelegatingTransactionAttribute(TransactionAttribute targetAttribute) {
Assert.notNull(targetAttribute, "Target attribute must not be null");
super(targetAttribute);
this.targetAttribute = targetAttribute;
}
public int getPropagationBehavior() {
return this.targetAttribute.getPropagationBehavior();
}
public int getIsolationLevel() {
return this.targetAttribute.getIsolationLevel();
}
public int getTimeout() {
return this.targetAttribute.getTimeout();
}
public boolean isReadOnly() {
return this.targetAttribute.isReadOnly();
}
public String getName() {
return this.targetAttribute.getName();
}
public String getQualifier() {
return this.targetAttribute.getQualifier();
}
@ -72,20 +53,4 @@ public abstract class DelegatingTransactionAttribute implements TransactionAttri
return this.targetAttribute.rollbackOn(ex);
}
@Override
public boolean equals(Object obj) {
return this.targetAttribute.equals(obj);
}
@Override
public int hashCode() {
return this.targetAttribute.hashCode();
}
@Override
public String toString() {
return this.targetAttribute.toString();
}
}

84
org.springframework.transaction/src/main/java/org/springframework/transaction/support/DelegatingTransactionDefinition.java Normal file
View File

@ -0,0 +1,84 @@
/*
* Copyright 2002-2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.transaction.support;
import java.io.Serializable;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.util.Assert;
/**
* {@link TransactionDefinition} implementation that delegates all calls to a given target
* {@link TransactionDefinition} instance. Abstract because it is meant to be subclassed,
* with subclasses overriding specific methods that are not supposed to simply delegate
* to the target instance.
*
* @author Juergen Hoeller
* @since 3.0
*/
public abstract class DelegatingTransactionDefinition implements TransactionDefinition, Serializable {
private final TransactionDefinition targetDefinition;
/**
* Create a DelegatingTransactionAttribute for the given target attribute.
* @param targetAttribute the target TransactionAttribute to delegate to
*/
public DelegatingTransactionDefinition(TransactionDefinition targetDefinition) {
Assert.notNull(targetDefinition, "Target definition must not be null");
this.targetDefinition = targetDefinition;
}
public int getPropagationBehavior() {
return this.targetDefinition.getPropagationBehavior();
}
public int getIsolationLevel() {
return this.targetDefinition.getIsolationLevel();
}
public int getTimeout() {
return this.targetDefinition.getTimeout();
}
public boolean isReadOnly() {
return this.targetDefinition.isReadOnly();
}
public String getName() {
return this.targetDefinition.getName();
}
@Override
public boolean equals(Object obj) {
return this.targetDefinition.equals(obj);
}
@Override
public int hashCode() {
return this.targetDefinition.hashCode();
}
@Override
public String toString() {
return this.targetDefinition.toString();
}
}