/*
* Copyright 2002-2018 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
*
* https://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.jta;
import javax.transaction.Status;
import javax.transaction.Synchronization;
import javax.transaction.TransactionManager;
import javax.transaction.UserTransaction;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.lang.Nullable;
import org.springframework.transaction.support.TransactionSynchronization;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.util.Assert;
Adapter that implements the JTA Synchronization interface delegating to an underlying Spring TransactionSynchronization. Useful for synchronizing Spring resource management code with plain
JTA / EJB CMT transactions, despite the original code being built for
Spring transaction synchronization.
Author: Juergen Hoeller See Also: - registerSynchronization.registerSynchronization
- TransactionSynchronization
Since: 2.0
/**
* Adapter that implements the JTA {@link javax.transaction.Synchronization}
* interface delegating to an underlying Spring
* {@link org.springframework.transaction.support.TransactionSynchronization}.
*
* <p>Useful for synchronizing Spring resource management code with plain
* JTA / EJB CMT transactions, despite the original code being built for
* Spring transaction synchronization.
*
* @author Juergen Hoeller
* @since 2.0
* @see javax.transaction.Transaction#registerSynchronization
* @see org.springframework.transaction.support.TransactionSynchronization
*/
public class SpringJtaSynchronizationAdapter implements Synchronization {
protected static final Log logger = LogFactory.getLog(SpringJtaSynchronizationAdapter.class);
private final TransactionSynchronization springSynchronization;
@Nullable
private UserTransaction jtaTransaction;
private boolean beforeCompletionCalled = false;
Create a new SpringJtaSynchronizationAdapter for the given Spring
TransactionSynchronization and JTA TransactionManager.
Params: - springSynchronization – the Spring TransactionSynchronization to delegate to
/**
* Create a new SpringJtaSynchronizationAdapter for the given Spring
* TransactionSynchronization and JTA TransactionManager.
* @param springSynchronization the Spring TransactionSynchronization to delegate to
*/
public SpringJtaSynchronizationAdapter(TransactionSynchronization springSynchronization) {
Assert.notNull(springSynchronization, "TransactionSynchronization must not be null");
this.springSynchronization = springSynchronization;
}
Create a new SpringJtaSynchronizationAdapter for the given Spring
TransactionSynchronization and JTA TransactionManager.
Note that this adapter will never perform a rollback-only call on WebLogic, since WebLogic Server is known to automatically mark the transaction as rollback-only in case of a beforeCompletion exception. Hence, on WLS, this constructor is equivalent to the single-arg constructor.
Params: - springSynchronization – the Spring TransactionSynchronization to delegate to
- jtaUserTransaction – the JTA UserTransaction to use for rollback-only setting in case of an exception thrown in
beforeCompletion (can be omitted if the JTA provider itself marks the transaction rollback-only in such a scenario, which is required by the JTA specification as of JTA 1.1).
/**
* Create a new SpringJtaSynchronizationAdapter for the given Spring
* TransactionSynchronization and JTA TransactionManager.
* <p>Note that this adapter will never perform a rollback-only call on WebLogic,
* since WebLogic Server is known to automatically mark the transaction as
* rollback-only in case of a {@code beforeCompletion} exception. Hence,
* on WLS, this constructor is equivalent to the single-arg constructor.
* @param springSynchronization the Spring TransactionSynchronization to delegate to
* @param jtaUserTransaction the JTA UserTransaction to use for rollback-only
* setting in case of an exception thrown in {@code beforeCompletion}
* (can be omitted if the JTA provider itself marks the transaction rollback-only
* in such a scenario, which is required by the JTA specification as of JTA 1.1).
*/
public SpringJtaSynchronizationAdapter(TransactionSynchronization springSynchronization,
@Nullable UserTransaction jtaUserTransaction) {
this(springSynchronization);
if (jtaUserTransaction != null && !jtaUserTransaction.getClass().getName().startsWith("weblogic.")) {
this.jtaTransaction = jtaUserTransaction;
}
}
Create a new SpringJtaSynchronizationAdapter for the given Spring
TransactionSynchronization and JTA TransactionManager.
Note that this adapter will never perform a rollback-only call on WebLogic, since WebLogic Server is known to automatically mark the transaction as rollback-only in case of a beforeCompletion exception. Hence, on WLS, this constructor is equivalent to the single-arg constructor.
Params: - springSynchronization – the Spring TransactionSynchronization to delegate to
- jtaTransactionManager – the JTA TransactionManager to use for rollback-only setting in case of an exception thrown in
beforeCompletion (can be omitted if the JTA provider itself marks the transaction rollback-only in such a scenario, which is required by the JTA specification as of JTA 1.1)
/**
* Create a new SpringJtaSynchronizationAdapter for the given Spring
* TransactionSynchronization and JTA TransactionManager.
* <p>Note that this adapter will never perform a rollback-only call on WebLogic,
* since WebLogic Server is known to automatically mark the transaction as
* rollback-only in case of a {@code beforeCompletion} exception. Hence,
* on WLS, this constructor is equivalent to the single-arg constructor.
* @param springSynchronization the Spring TransactionSynchronization to delegate to
* @param jtaTransactionManager the JTA TransactionManager to use for rollback-only
* setting in case of an exception thrown in {@code beforeCompletion}
* (can be omitted if the JTA provider itself marks the transaction rollback-only
* in such a scenario, which is required by the JTA specification as of JTA 1.1)
*/
public SpringJtaSynchronizationAdapter(
TransactionSynchronization springSynchronization, @Nullable TransactionManager jtaTransactionManager) {
this(springSynchronization);
if (jtaTransactionManager != null && !jtaTransactionManager.getClass().getName().startsWith("weblogic.")) {
this.jtaTransaction = new UserTransactionAdapter(jtaTransactionManager);
}
}
JTA beforeCompletion callback: just invoked before commit. In case of an exception, the JTA transaction will be marked as rollback-only.
See Also:
/**
* JTA {@code beforeCompletion} callback: just invoked before commit.
* <p>In case of an exception, the JTA transaction will be marked as rollback-only.
* @see org.springframework.transaction.support.TransactionSynchronization#beforeCommit
*/
@Override
public void beforeCompletion() {
try {
boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
this.springSynchronization.beforeCommit(readOnly);
}
catch (RuntimeException | Error ex) {
setRollbackOnlyIfPossible();
throw ex;
}
finally {
// Process Spring's beforeCompletion early, in order to avoid issues
// with strict JTA implementations that issue warnings when doing JDBC
// operations after transaction completion (e.g. Connection.getWarnings).
this.beforeCompletionCalled = true;
this.springSynchronization.beforeCompletion();
}
}
Set the underlying JTA transaction to rollback-only.
/**
* Set the underlying JTA transaction to rollback-only.
*/
private void setRollbackOnlyIfPossible() {
if (this.jtaTransaction != null) {
try {
this.jtaTransaction.setRollbackOnly();
}
catch (UnsupportedOperationException ex) {
// Probably Hibernate's WebSphereExtendedJTATransactionLookup pseudo JTA stuff...
logger.debug("JTA transaction handle does not support setRollbackOnly method - " +
"relying on JTA provider to mark the transaction as rollback-only based on " +
"the exception thrown from beforeCompletion", ex);
}
catch (Throwable ex) {
logger.error("Could not set JTA transaction rollback-only", ex);
}
}
else {
logger.debug("No JTA transaction handle available and/or running on WebLogic - " +
"relying on JTA provider to mark the transaction as rollback-only based on " +
"the exception thrown from beforeCompletion");
}
}
JTA afterCompletion callback: invoked after commit/rollback. Needs to invoke the Spring synchronization's beforeCompletion at this late stage in case of a rollback, since there is no corresponding callback with JTA.
See Also:
/**
* JTA {@code afterCompletion} callback: invoked after commit/rollback.
* <p>Needs to invoke the Spring synchronization's {@code beforeCompletion}
* at this late stage in case of a rollback, since there is no corresponding
* callback with JTA.
* @see org.springframework.transaction.support.TransactionSynchronization#beforeCompletion
* @see org.springframework.transaction.support.TransactionSynchronization#afterCompletion
*/
@Override
public void afterCompletion(int status) {
if (!this.beforeCompletionCalled) {
// beforeCompletion not called before (probably because of JTA rollback).
// Perform the cleanup here.
this.springSynchronization.beforeCompletion();
}
// Call afterCompletion with the appropriate status indication.
switch (status) {
case Status.STATUS_COMMITTED:
this.springSynchronization.afterCompletion(TransactionSynchronization.STATUS_COMMITTED);
break;
case Status.STATUS_ROLLEDBACK:
this.springSynchronization.afterCompletion(TransactionSynchronization.STATUS_ROLLED_BACK);
break;
default:
this.springSynchronization.afterCompletion(TransactionSynchronization.STATUS_UNKNOWN);
}
}
}