diff --git a/org.springframework.orm/src/main/java/org/springframework/orm/jdo/JdoTransactionManager.java b/org.springframework.orm/src/main/java/org/springframework/orm/jdo/JdoTransactionManager.java index 2202cad489..e109f86894 100644 --- a/org.springframework.orm/src/main/java/org/springframework/orm/jdo/JdoTransactionManager.java +++ b/org.springframework.orm/src/main/java/org/springframework/orm/jdo/JdoTransactionManager.java @@ -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() + "]"); diff --git a/org.springframework.orm/src/main/java/org/springframework/orm/jpa/JpaTransactionManager.java b/org.springframework.orm/src/main/java/org/springframework/orm/jpa/JpaTransactionManager.java index 4ee8be543d..88a8b4d29e 100644 --- a/org.springframework.orm/src/main/java/org/springframework/orm/jpa/JpaTransactionManager.java +++ b/org.springframework.orm/src/main/java/org/springframework/orm/jpa/JpaTransactionManager.java @@ -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() + "]"); diff --git a/org.springframework.orm/src/main/java/org/springframework/orm/jpa/vendor/HibernateJpaDialect.java b/org.springframework.orm/src/main/java/org/springframework/orm/jpa/vendor/HibernateJpaDialect.java index 71f83fb924..151b602006 100644 --- a/org.springframework.orm/src/main/java/org/springframework/orm/jpa/vendor/HibernateJpaDialect.java +++ b/org.springframework.orm/src/main/java/org/springframework/orm/jpa/vendor/HibernateJpaDialect.java @@ -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()); } diff --git a/org.springframework.transaction/src/main/java/org/springframework/transaction/interceptor/DelegatingTransactionAttribute.java b/org.springframework.transaction/src/main/java/org/springframework/transaction/interceptor/DelegatingTransactionAttribute.java index 9c895a5e37..9fd02d5a9e 100644 --- a/org.springframework.transaction/src/main/java/org/springframework/transaction/interceptor/DelegatingTransactionAttribute.java +++ b/org.springframework.transaction/src/main/java/org/springframework/transaction/interceptor/DelegatingTransactionAttribute.java @@ -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(); - } - } diff --git a/org.springframework.transaction/src/main/java/org/springframework/transaction/support/DelegatingTransactionDefinition.java b/org.springframework.transaction/src/main/java/org/springframework/transaction/support/DelegatingTransactionDefinition.java new file mode 100644 index 0000000000..8e15758e22 --- /dev/null +++ b/org.springframework.transaction/src/main/java/org/springframework/transaction/support/DelegatingTransactionDefinition.java @@ -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(); + } + +}