public TransactionInterceptor() 
{

}

Create a new TransactionInterceptor.

Transaction manager and transaction attributes still need to be set.

Also see:

setTransactionManager
setTransactionAttributes(java.util.Properties)
setTransactionAttributeSource(TransactionAttributeSource)

 public TransactionInterceptor(PlatformTransactionManager ptm,
    Properties attributes) 
{
		setTransactionManager(ptm);
		setTransactionAttributes(attributes);
}

Create a new TransactionInterceptor.

Parameters:

ptm - the transaction manager to perform the actual transaction management

attributes - the transaction attributes in properties format

Also see:

setTransactionManager
setTransactionAttributes(java.util.Properties)

 public TransactionInterceptor(PlatformTransactionManager ptm,
    TransactionAttributeSource tas) 
{
		setTransactionManager(ptm);
		setTransactionAttributeSource(tas);
}

Create a new TransactionInterceptor.

Parameters:

ptm - the transaction manager to perform the actual transaction management

tas - the attribute source to be used to find transaction attributes

Also see:

setTransactionManager
setTransactionAttributeSource(TransactionAttributeSource)

 public Object invoke(MethodInvocation invocation) throws Throwable 
{
		// Work out the target class: may be < code >null< /code >.
		// The TransactionAttributeSource should be passed the target class
		// as well as the method, which may be from an interface.
		Class targetClass = (invocation.getThis() != null ? invocation.getThis().getClass() : null);
		// If the transaction attribute is null, the method is non-transactional.
		final TransactionAttribute txAttr =
				getTransactionAttributeSource().getTransactionAttribute(invocation.getMethod(), targetClass);
		final String joinpointIdentification = methodIdentification(invocation.getMethod());
		if (txAttr == null || !(getTransactionManager() instanceof CallbackPreferringPlatformTransactionManager)) {
			// Standard transaction demarcation with getTransaction and commit/rollback calls.
			TransactionInfo txInfo = createTransactionIfNecessary(txAttr, joinpointIdentification);
			Object retVal = null;
			try {
				// This is an around advice: Invoke the next interceptor in the chain.
				// This will normally result in a target object being invoked.
				retVal = invocation.proceed();
			}
			catch (Throwable ex) {
				// target invocation exception
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
			finally {
				cleanupTransactionInfo(txInfo);
			}
			commitTransactionAfterReturning(txInfo);
			return retVal;
		}
		else {
			// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
			try {
				Object result = ((CallbackPreferringPlatformTransactionManager) getTransactionManager()).execute(txAttr,
						new TransactionCallback() {
							public Object doInTransaction(TransactionStatus status) {
								TransactionInfo txInfo = prepareTransactionInfo(txAttr, joinpointIdentification, status);
								try {
									return invocation.proceed();
								}
								catch (Throwable ex) {
									if (txAttr.rollbackOn(ex)) {
										// A RuntimeException: will lead to a rollback.
										if (ex instanceof RuntimeException) {
											throw (RuntimeException) ex;
										}
										else {
											throw new ThrowableHolderException(ex);
										}
									}
									else {
										// A normal return value: will lead to a commit.
										return new ThrowableHolder(ex);
									}
								}
								finally {
									cleanupTransactionInfo(txInfo);
								}
							}
						});
				// Check result: It might indicate a Throwable to rethrow.
				if (result instanceof ThrowableHolder) {
					throw ((ThrowableHolder) result).getThrowable();
				}
				else {
					return result;
				}
			}
			catch (ThrowableHolderException ex) {
				throw ex.getCause();
			}
		}
}