@Transactional 源码解析

1.springboot 下@Transactional使用方式

在springboot框架下，事务管理只要在实现类方法上增加@Transactional这个注解就可以了。

    @Transactional
    @Override
    public int insertMapiInterfaceCallConfig(InterfaceCallConfigDomain mapiInterfaceCallConfig) {
   
   
        return mapiInterfaceCallConfigMapper.insertMapiInterfaceCallConfig(mapiInterfaceCallConfig);
    }

2.spring是怎么处理事务的

spring 是通过aop 的方式来管理事务的，具体来看如下代码

事务aop处理类TransactionInterceptor

package org.springframework.transaction.interceptor;
@SuppressWarnings("serial")
public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {
   
   
    

	@Override
	@Nullable
	public Object invoke(MethodInvocation invocation) throws Throwable {
   
   
		// Work out the target class: may be {@code null}.
		// The TransactionAttributeSource should be passed the target class
		// as well as the method, which may be from an interface.
		Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

		// Adapt to TransactionAspectSupport's invokeWithinTransaction...
		return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
	}
}

调用TransactionAspectSupport的invokeWithinTransaction
分三种情况

1. 响应式编程事务处理
2. 命令式编程事务处理
3. 没有事务的方法处理

如下代码：

public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {
   
   
    @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 TransactionManager tm = determineTransactionManager(txAttr);
         #1. 响应式编程事务处理 
		if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
   
   
			ReactiveTransactionSupport txSupport = this.transactionSupportCache.computeIfAbsent(method, key -> {
   
   
				if (KotlinDetector.isKotlinType(method.getDeclaringClass()) && KotlinDelegate.isSuspend(method)) {
   
   
					throw new TransactionUsageException(
							"Unsupported annotated transaction on suspending function detected: " + method +
							". Use TransactionalOperator.transactional extensions instead.");
				}
				ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(method.getReturnType());
				if (adapter == null) {
   
   
					throw new IllegalStateException("Cannot apply reactive transaction to non-reactive return type: " +
							method.getReturnType());
				}
				return new ReactiveTransactionSupport(adapter);
			});
			return txSupport.invokeWithinTransaction(
					method, targetClass, invocation, txAttr, (ReactiveTransactionManager) tm);
		}
        # 2. 命令式编程事务处理 
		PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
		final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

		if (txAttr ==