Springboot事务的实现原理

刺骨的言语ヽ痛彻心扉 2023-02-17 03:54 28阅读 0赞

### Springboot事务的实现原理 ###

1.  Spring实现事务的方式分为编程式和声明式，其中声明式是最为常见的，声明式事务的实现又分为XML配置文件、@Transactional注解两种实现方式，SpringBoot因为取消了XML配置文件的书写，所以SpringBoot中的事务主要是使用@Transactional注解来实现的，下面从源码角度分析其原理
2.  已知@Transactional事务实现的原理是基于AOP来实现的，在之前的博客中详细讲解了AOP的实现原理：动态代理+拦截链，由此可以大概推测出@Transactional的实现逻辑：Spring有一个针对@Transactional的增强器（拦截器）Interceptor，在bean实例初始化的最后一步会调用带该拦截器的拦截器链增强@Transactional注解的方法，并且生成代理类  
    ![事务流程][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1_size_16_color_FFFFFF_t_70]

@Transactional注解

/** * Alias for {@link #transactionManager}. * @see #transactionManager */
 	@AliasFor("transactionManager")
 	String value() default "";
 
 	/** * A qualifier value for the specified transaction. * May be used to determine the target transaction manager, * matching the qualifier value (or the bean name) of a specific * {@link org.springframework.transaction.PlatformTransactionManager} * bean definition. * @since 4.2 * @see #value */
 	@AliasFor("value")
 	String transactionManager() default "";
 
 	/** * The transaction propagation type. * Defaults to {@link Propagation#REQUIRED}. * @see org.springframework.transaction.interceptor.TransactionAttribute#getPropagationBehavior() */
 	Propagation propagation() default Propagation.REQUIRED;
 
 	/** * The transaction isolation level. * Defaults to {@link Isolation#DEFAULT}. * @see org.springframework.transaction.interceptor.TransactionAttribute#getIsolationLevel() */
 	Isolation isolation() default Isolation.DEFAULT;
 
 	/** * The timeout for this transaction. * Defaults to the default timeout of the underlying transaction system. * @see org.springframework.transaction.interceptor.TransactionAttribute#getTimeout() */
 	int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
 
 	/** * {@code true} if the transaction is read-only. * Defaults to {@code false}. * This just serves as a hint for the actual transaction subsystem; * it will not necessarily cause failure of write access attempts. * A transaction manager which cannot interpret the read-only hint will * not throw an exception when asked for a read-only transaction * but rather silently ignore the hint. * @see org.springframework.transaction.interceptor.TransactionAttribute#isReadOnly() */
 	boolean readOnly() default false;
 
 	/** * Defines zero (0) or more exception {@link Class classes}, which must be * subclasses of {@link Throwable}, indicating which exception types must cause * a transaction rollback. * By default, a transaction will be rolling back on {@link RuntimeException} * and {@link Error} but not on checked exceptions (business exceptions). See * {@link org.springframework.transaction.interceptor.DefaultTransactionAttribute#rollbackOn(Throwable)} * for a detailed explanation. * This is the preferred way to construct a rollback rule (in contrast to * {@link #rollbackForClassName}), matching the exception class and its subclasses. * Similar to {@link org.springframework.transaction.interceptor.RollbackRuleAttribute#RollbackRuleAttribute(Class clazz)}. * @see #rollbackForClassName * @see org.springframework.transaction.interceptor.DefaultTransactionAttribute#rollbackOn(Throwable) */
 	Class<? extends Throwable>[] rollbackFor() default { };
 
 	/** * Defines zero (0) or more exception names (for exceptions which must be a * subclass of {@link Throwable}), indicating which exception types must cause * a transaction rollback. * This can be a substring of a fully qualified class name, with no wildcard * support at present. For example, a value of {@code "ServletException"} would * match {@code javax.servlet.ServletException} and its subclasses. * NB: Consider carefully how specific the pattern is and whether * to include package information (which isn't mandatory). For example, * {@code "Exception"} will match nearly anything and will probably hide other * rules. {@code "java.lang.Exception"} would be correct if {@code "Exception"} * were meant to define a rule for all checked exceptions. With more unusual * {@link Exception} names such as {@code "BaseBusinessException"} there is no * need to use a FQN. * Similar to {@link org.springframework.transaction.interceptor.RollbackRuleAttribute#RollbackRuleAttribute(String exceptionName)}. * @see #rollbackFor * @see org.springframework.transaction.interceptor.DefaultTransactionAttribute#rollbackOn(Throwable) */
 	String[] rollbackForClassName() default { };
 
 	/** * Defines zero (0) or more exception {@link Class Classes}, which must be * subclasses of {@link Throwable}, indicating which exception types must * not cause a transaction rollback. * This is the preferred way to construct a rollback rule (in contrast * to {@link #noRollbackForClassName}), matching the exception class and * its subclasses. * Similar to {@link org.springframework.transaction.interceptor.NoRollbackRuleAttribute#NoRollbackRuleAttribute(Class clazz)}. * @see #noRollbackForClassName * @see org.springframework.transaction.interceptor.DefaultTransactionAttribute#rollbackOn(Throwable) */
 	Class<? extends Throwable>[] noRollbackFor() default { };
 
 	/** * Defines zero (0) or more exception names (for exceptions which must be a * subclass of {@link Throwable}) indicating which exception types must not * cause a transaction rollback. * See the description of {@link #rollbackForClassName} for further * information on how the specified names are treated. * Similar to {@link org.springframework.transaction.interceptor.NoRollbackRuleAttribute#NoRollbackRuleAttribute(String exceptionName)}. * @see #noRollbackFor * @see org.springframework.transaction.interceptor.DefaultTransactionAttribute#rollbackOn(Throwable) */
 	String[] noRollbackForClassName() default { };

![注解对应的方法][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1_size_16_color_FFFFFF_t_70 1]

###### 事务的隔离级别 ######

/** * Use the default isolation level of the underlying datastore. * All other levels correspond to the JDBC isolation levels. * @see java.sql.Connection */
    	DEFAULT(TransactionDefinition.ISOLATION_DEFAULT),
    
    	/** * A constant indicating that dirty reads, non-repeatable reads and phantom reads * can occur. This level allows a row changed by one transaction to be read by * another transaction before any changes in that row have been committed * (a "dirty read"). If any of the changes are rolled back, the second * transaction will have retrieved an invalid row. * @see java.sql.Connection#TRANSACTION_READ_UNCOMMITTED */
    	READ_UNCOMMITTED(TransactionDefinition.ISOLATION_READ_UNCOMMITTED),
    
    	/** * A constant indicating that dirty reads are prevented; non-repeatable reads * and phantom reads can occur. This level only prohibits a transaction * from reading a row with uncommitted changes in it. * @see java.sql.Connection#TRANSACTION_READ_COMMITTED */
    	READ_COMMITTED(TransactionDefinition.ISOLATION_READ_COMMITTED),
    
    	/** * A constant indicating that dirty reads and non-repeatable reads are * prevented; phantom reads can occur. This level prohibits a transaction * from reading a row with uncommitted changes in it, and it also prohibits * the situation where one transaction reads a row, a second transaction * alters the row, and the first transaction rereads the row, getting * different values the second time (a "non-repeatable read"). * @see java.sql.Connection#TRANSACTION_REPEATABLE_READ */
    	REPEATABLE_READ(TransactionDefinition.ISOLATION_REPEATABLE_READ),
    
    	/** * A constant indicating that dirty reads, non-repeatable reads and phantom * reads are prevented. This level includes the prohibitions in * {@code ISOLATION_REPEATABLE_READ} and further prohibits the situation * where one transaction reads all rows that satisfy a {@code WHERE} * condition, a second transaction inserts a row that satisfies that * {@code WHERE} condition, and the first transaction rereads for the * same condition, retrieving the additional "phantom" row in the second read. * @see java.sql.Connection#TRANSACTION_SERIALIZABLE */
    	SERIALIZABLE(TransactionDefinition.ISOLATION_SERIALIZABLE);

###### TransactionInterceptor拦截器 ######

关于拦截器链如何形成并且执行的，这里不做赘述，这里主要关注针对@Transactional注解的拦截器。

@Override
 	public Object invoke(final 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, new InvocationCallback() { 
 			@Override
 			public Object proceedWithInvocation() throws Throwable { 
 				return invocation.proceed();
 			}
 		});
 	}

*  跟一下invokeWithinTransaction 函数，省去不必要的代码，这里可以清晰的看到，该拦截器实现事务的方式和我们在DAO层手动实现事务差不多，都是先开启事务，再执行，如果异常则回滚，否则提交事务，只不过这里把执行的逻辑换成了递归执行拦截链了

/** * General delegate for around-advice-based subclasses, delegating to several other template * methods on this class. Able to handle {@link CallbackPreferringPlatformTransactionManager} * as well as regular {@link PlatformTransactionManager} implementations. * @param method the Method being invoked * @param targetClass the target class that we're invoking the method on * @param invocation the callback to use for proceeding with the target invocation * @return the return value of the method, if any * @throws Throwable propagated from the target invocation */
 	protected Object invokeWithinTransaction(Method method, Class<?> targetClass, final InvocationCallback invocation)
 			throws Throwable { 
 
 		// If the transaction attribute is null, the method is non-transactional.
 		final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
 		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) { 
 				// target invocation exception
 				completeTransactionAfterThrowing(txInfo, ex);
 				throw ex;
 			}
 			finally { 
 				cleanupTransactionInfo(txInfo);
 			}
 			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,
 						new TransactionCallback<Object>() { 
 							@Override
 							public Object doInTransaction(TransactionStatus 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;
 			}
 		}
 	}

[JDBC实现事务的代码实现][JDBC]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200612115800921.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200612121435937.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1,size_16,color_FFFFFF,t_70
[JDBC]: https://blog.csdn.net/a909082823/article/details/89073247