@Nullable
	protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
			final InvocationCallback invocation) throws Throwable {

		// If the transaction attribute is null, the method is non-transactional.
		TransactionAttributeSource tas = getTransactionAttributeSource();
		final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
		final PlatformTransactionManager tm = determineTransactionManager(txAttr);
		final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

		if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
			// Standard transaction demarcation with getTransaction and commit/rollback calls.
			TransactionInfo txInfo = createTransactionIfNecessary(tm, 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.proceedWithInvocation();
			}
			catch (Throwable ex) {
				// aop对应目标方法报错
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
			finally {
				cleanupTransactionInfo(txInfo);
			}
			// aop对应目标方法正常执行进行事务提交
			commitTransactionAfterReturning(txInfo);
			return retVal;
		}

		else {
			final ThrowableHolder throwableHolder = new ThrowableHolder();

			// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
			try {
				Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr, status -> {
					TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
					try {
						return invocation.proceedWithInvocation();
					}
					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.
							throwableHolder.throwable = ex;
							return null;
						}
					}
					finally {
						cleanupTransactionInfo(txInfo);
					}
				});

				// Check result state: It might indicate a Throwable to rethrow.
				if (throwableHolder.throwable != null) {
					throw throwableHolder.throwable;
				}
				return result;
			}
			catch (ThrowableHolderException ex) {
				throw ex.getCause();
			}
			catch (TransactionSystemException ex2) {
				if (throwableHolder.throwable != null) {
					logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
					ex2.initApplicationException(throwableHolder.throwable);
				}
				throw ex2;
			}
			catch (Throwable ex2) {
				if (throwableHolder.throwable != null) {
					logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
				}
				throw ex2;
			}
		}
	}

@Override  
public final void commit(TransactionStatus status) throws TransactionException {  
   if (status.isCompleted()) {  
      throw new IllegalTransactionStateException(  
            "Transaction is already completed - do not call commit or rollback more than once per transaction");  
   }  
  
   DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;  
   if (defStatus.isLocalRollbackOnly()) {  
      if (defStatus.isDebug()) {  
         logger.debug("Transactional code has requested rollback");  
      }  
      processRollback(defStatus, false);  
      return;   }  
  
   if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {  
      if (defStatus.isDebug()) {  
         logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");  
      }  
      processRollback(defStatus, true);  
      return;   }  
  
   processCommit(defStatus);  
}

private void processRollback(DefaultTransactionStatus status, boolean unexpected) {  
   try {  
      boolean unexpectedRollback = unexpected;  
  
      try {  
         triggerBeforeCompletion(status);  
  
         if (status.hasSavepoint()) {  
            if (status.isDebug()) {  
               logger.debug("Rolling back transaction to savepoint");  
            }  
            status.rollbackToHeldSavepoint();  
         }  
         else if (status.isNewTransaction()) {  
            if (status.isDebug()) {  
               logger.debug("Initiating transaction rollback");  
            }  
            doRollback(status);  
         }  
         else {  
            // Participating in larger transaction  
            if (status.hasTransaction()) {  
               if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {  
                  if (status.isDebug()) {  
                     logger.debug("Participating transaction failed - marking existing transaction as rollback-only");  
                  }
                  // 对当前事务设置RollbackOnly=true
                  doSetRollbackOnly(status);  
               }  
               else {  
                  if (status.isDebug()) {  
                     logger.debug("Participating transaction failed - letting transaction originator decide on rollback");  
                  }  
               }  
            }  
            else {  
               logger.debug("Should roll back transaction but cannot - no transaction available");  
            }  
            // Unexpected rollback only matters here if we're asked to fail early  
            if (!isFailEarlyOnGlobalRollbackOnly()) {  
               unexpectedRollback = false;  
            }  
         }  
      }  
      catch (RuntimeException | Error ex) {  
         triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);  
         throw ex;  
      }  
  
      triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);  
  
      // Raise UnexpectedRollbackException if we had a global rollback-only marker  
      if (unexpectedRollback) {  
         throw new UnexpectedRollbackException(  
               "Transaction rolled back because it has been marked as rollback-only");  
      }  
   }  
   finally {  
      cleanupAfterCompletion(status);  
   }  
}

@Override  
@Transactional(rollbackFor = Exception.class)  
public void testRollbackOnly() {  
	String transactionName = TransactionSynchronizationManager.getCurrentTransactionName();  
	logger.info("com.lin.app.service.impl.TransactionalServiceImpl.testRollbackOnly:" + transactionName);  
	try {  
		self().rollbackOnlyA();  
	} catch (Exception e) {  
		logger.error("com.lin.app.service.impl.TransactionalServiceImpl.testRollbackOnly.error", e);  
	}  
	if (TransactionAspectSupport.currentTransactionStatus().isRollbackOnly()) {  
		TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();  
		logger.error("com.lin.app.service.impl.TransactionalServiceImpl.testRollbackOnly.isRollbackOnly");  
	}  
	Order order = new Order("ORDER" + "test");  
	orderMapper.insertSelective(order);  
}