spring事务从底层掌握其实现原理

全面分析总结解决Could not transfer artifact org.apache.maven.plugins等此类问题的方法 全面分析总结解决Could not transfer artifact org.apache.maven.plugins,Could not transfer artifact xxx from/to xxx等此类问题的方法 阅读详情

流程介绍

主流程介绍

众所周知,Spring事务采用AOP的方式实现,我们从TransactionAspectSupport这个类开始分析。

  1. 获取事务的属性(@Transactional注解中的配置)
  2. 加载配置中的TransactionManager.
  3. 获取收集事务信息TransactionInfo
  4. 执行目标方法
  5. 出现异常,尝试处理。
  6. 清理事务相关信息
  7. 提交事务
//1. 获取@Transactional注解的相关参数
TransactionAttributeSource tas = getTransactionAttributeSource();
// 2. 获取事务管理器
	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.
		// 3. 获取TransactionInfo,包含了tm和TransactionStatus
		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.
			// 4.执行目标方法
			retVal = invocation.proceedWithInvocation();
		}
		catch (Throwable ex) {
		   //5.回滚
			// target invocation exception
			completeTransactionAfterThrowing(txInfo, ex);
			throw ex;
		}
		finally {
		  // 6. 清理当前线程的事务相关信息
			cleanupTransactionInfo(txInfo);
		}
		// 提交事务
		commitTransactionAfterReturning(txInfo);
		return retVal;
	}

doBegin做了什么

在执行createTransactionIfNecessary获取事务状态时,就准备好了开启事务的所有内容,主要是执行了JDBC的con.setAutoCommit(false)方法。同时处理了很多和数据库连接相关的ThreadLocal变量。

关键对象介绍

PlatformTransactionManager

TransactionManager是做什么的?它保存着当前的数据源连接,对外提供对该数据源的事务提交回滚操作接口,同时实现了事务相关操作的方法。一个数据源DataSource需要一个事务管理器。

属性:DataSource

内部核心方法:
public commit 提交事务
public rollback 回滚事务
public getTransaction 获得当前事务状态

protected doSuspend 挂起事务

protected doBegin 开始事务,主要是执行了JDBC的con.setAutoCommit(false)方法。同时处理了很多和数据库连接相关的ThreadLocal变量。

protected doCommit 提交事务
protected doRollback 回滚事务
protected doGetTransaction() 获取事务信息
final getTransaction 获取事务状态

获取对应的TransactionManager

@Nullable
	protected PlatformTransactionManager determineTransactionManager(@Nullable TransactionAttribute txAttr) {
		// Do not attempt to lookup tx manager if no tx attributes are set
		if (txAttr == null || this.beanFactory == null) {
			return getTransactionManager();
		}

		String qualifier = txAttr.getQualifier();
		//如果指定了Bean则取指定的PlatformTransactionManager类型的Bean
		if (StringUtils.hasText(qualifier)) {
			return determineQualifiedTransactionManager(this.beanFactory, qualifier);
		}
		//如果指定了Bean的名称,则根据bean名称获取对应的bean
		else if (StringUtils.hasText(this.transactionManagerBeanName)) {
			return determineQualifiedTransactionManager(this.beanFactory, this.transactionManagerBeanName);
		}
		else {
		// 默认取一个PlatformTransactionManager类型的Bean
			PlatformTransactionManager defaultTransactionManager = getTransactionManager();
			if (defaultTransactionManager == null) {
				defaultTransactionManager = this.transactionManagerCache.get(DEFAULT_TRANSACTION_MANAGER_KEY);
				if (defaultTransactionManager == null) {
					defaultTransactionManager = this.beanFactory.getBean(PlatformTransactionManager.class);
					this.transactionManagerCache.putIfAbsent(
							DEFAULT_TRANSACTION_MANAGER_KEY, defaultTransactionManager);
				}
			}
			return defaultTransactionManager;
		}
	}

可以看到,如果没有指定TransactionManager参数的话,会使用默认的一个实现,所以当程序中有多个数据库时,事务执行最好是指定事务管理器。

事务的信息TransactionInfo

TransactionInfo是对当前事务的描述,其中记录了事务的状态等信息。它记录了和一个事务所有的相关信息。它没有什么方法,只是对事务相关对象的一个组合。最关键的对象是TransactionStatus,它代表当前正在运行的是哪个事务。

1.核心属性:事务状态TransactionStatus
2.事务管理器
3.事务属性
4.上一个事务信息oldTransactionInfo,REQUIRE_NEW传播级别时,事务挂起后前一个事务的事务信息
在这里插入图片描述

当前事务状态TransactionStatus

通过TransactionManager的getTransaction方法,获取当前事务的状态。
具体是在AbstractPlatformTransactionManager中实现.
TransactionStatus被用来做什么:TransactionManager对事务进行提交或回滚时需要用到该对象
具体方法有:
在这里插入图片描述
作用:

  1. 判断当前事务是否是一个新的事务,否则加入到一个已经存在的事务中。事务传播级别REQUIRED和REQUIRE_NEW有用到。

  2. 当前事务是否携带保存点,嵌套事务用到。setRollbackOnly,isRollbackOnly,当子事务回滚时,并不真正回滚事务,而是对子事务设置一个标志位。

  3. 事务是否已经完成,已经提交或者已经回滚。

传播级别

介绍

Spring事务的传播级别描述的是多个使用了@Transactional注解的方法互相调用时,Spring对事务的处理。包涵的传播级别有:

1、REQUIRED, 如果当前线程已经在一个事务中,则加入该事务,否则新建一个事务。
2、SUPPORT, 如果当前线程已经在一个事务中,则加入该事务,否则不使用事务。
3、MANDATORY(强制的),如果当前线程已经在一个事务中,则加入该事务,否则抛出异常。
4、REQUIRES_NEW,无论如何都会创建一个新的事务,如果当前线程已经在一个事务中,则挂起当前事务,创建一个新的事务。
5、NOT_SUPPORTED,如果当前线程在一个事务中,则挂起事务。
6、NEVER,如果当前线程在一个事务中则抛出异常。
7、NESTED, 执行一个嵌套事务,有点像REQUIRED,但是有些区别,在Mysql中是采用SAVEPOINT来实现的。

挂起事务,指的是将当前事务的属性如事务名称,隔离级别等属性保存在一个变量中,同时将当前线程中所有和事务相关的ThreadLocal变量设置为从未开启过线程一样。Spring维护着一个当前线程的事务状态,用来判断当前线程是否在一个事务中以及在一个什么样的事务中,挂起事务后,当前线程的事务状态就好像没有事务。

现象描述

@Service
public class MyTsA {
    @Resource
    private UserServiceImpl userService;
    @Resource
    private MyTsB myTsB;

    @Transactional(rollbackFor = Exception.class)
    public void testNewRollback(){
        User user = new User();
        user.setId(1);
        user.setName("张三");
        userService.save(user);
        myTsB.save();
    }
}
    
@Service
public class MyTsB {
    @Resource
    private UserServiceImpl userService;
    @Transactional(rollbackFor = RuntimeException.class, propagation = ???)
    public void save(){
        User user = new User();
        user.setId(2);
        user.setName(“李四”)
        userService.save(user);
}

如上面所示有两个事务A和事务B,事务A方法中调用了事务B方法,区分两种回滚情况。
A提交,B回滚。
A回滚,B提交。

对于不同的传播级别:
1.当传播级别为为REQUIRED时,第一种情况A和B都会回滚。
2.。当传播级别为RQUIRED_NEW时,第一种情况A可以成功提交,B回滚,第二种情况A回滚,B可以正确提交,二者互不影响。(在A事务捕获B事务异常的情况下,保证A事务提交)
3.当传播级别为NESTED时,第一种情况A可以正常提交,B回滚,第二种情况二者都会回滚。

原理

我们从两个角度看他们的实现原理,一个是刚进入事务时,针对不同的传播级别,它们的行为有什么区别。另一个角度是当事务提交或者回滚时,传播级别对事务行为的影响。

首先在尝试获取事务信息时,如果当前已经存在一个事务,则会根据传播级别做一些处理:

隔离级别对开始事务的影响(获取TransactionStatus)

@Override
public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
  // 从当前的transactionManager获取DataSource对象
  // 然后以该DataSource对象为Key,
  // 去一个ThreadLocal变量中的map中获取该DataSource的连接
  // 然后设置到DataSourceTransactionObject中返回。
	Object transaction = doGetTransaction();
	// Cache debug flag to avoid repeated checks.
	boolean debugEnabled = logger.isDebugEnabled();
	if (definition == null) {
		// Use defaults if no transaction definition given.
		definition = new DefaultTransactionDefinition();
	}
// 如果当前线程已经在一个事务中了,则需要根据事务的传播级别
//来决定如何处理并获取事务状态对象
	if (isExistingTransaction(transaction)) {
		// Existing transaction found -> check propagation behavior to find out how to behave.
		return handleExistingTransaction(definition, transaction, debugEnabled);
	}
	// Check definition settings for new transaction.
	if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
		throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
	}
	// No existing transaction found -> check propagation behavior to find out how to proceed.
	if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
		throw new IllegalTransactionStateException(
				"No existing transaction found for transaction marked with propagation 'mandatory'");
	}
	else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
			definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
			definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
		SuspendedResourcesHolder suspendedResources = suspend(null);
		if (debugEnabled) {
			logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition);
		}
		try {
		  //如果当前不在一个事务中,则执行事务的准备操作
			boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
			// 构造事务状态对象,注意这里第三个参数为true,代表是一个新事务
			DefaultTransactionStatus status = newTransactionStatus(
					definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
			//执行begin操作,核心操作是设置隔离级别,执行   conn.setAutoCommit(false); 同时将数据连接绑定到当前线程
			doBegin(transaction, definition);
			// 针对事务相关属性如隔离级别,是否在事务中,设置绑定到当前线程
			prepareSynchronization(status, definition);
			return status;
		}
		catch (RuntimeException | Error ex) {
			resume(null, suspendedResources);
			throw ex;
		}
	}
	else {
		// Create "empty" transaction: no actual transaction, but potentially synchronization.
		if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
			logger.warn("Custom isolation level specified but no actual transaction initiated; " +
					"isolation level will effectively be ignored: " + definition);
		}
		boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
		return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
	}
}

可以看到,如果当前不存在事务时,创建一个新的TransactionStatus对象,否则进入到handleExistingTransaction。下面来看这个方法

1.如果是NEVER传播级别则抛出异常
2. 如果是不支持,则挂起事务,将当前事务对象设置为null,newTransaction设置为false,把线程的相关Threadlocal变量改的就像当前不存在事务一样
3. 如果是required_NEW的话,则挂起当前事务,同时创建一个新的事务,执行doBegin操作,设置newTransaction为true
4.如果是嵌入事务,则创建一个SAVEPOINT
5.对于REQUIRED传播级别会把newTransaction标志位设置为false

/**
 * Create a TransactionStatus for an existing transaction.
 */
private TransactionStatus handleExistingTransaction(
		TransactionDefinition definition, Object transaction, boolean debugEnabled)
		throws TransactionException {
    //如果是NEVER传播级别则抛出异常
	if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
		throw new IllegalTransactionStateException(
				"Existing transaction found for transaction marked with propagation 'never'");
	}
    // 如果是不支持,则挂起事务
	if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
		if (debugEnabled) {
			logger.debug("Suspending current transaction");
		}
		Object suspendedResources = suspend(transaction);
		boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
		//挂起事务同时将当前事务设置为null,newTransaction设置为false,把线程的相关Threadlocal变量改的就像当前不存在事务一样
		return prepareTransactionStatus(
				definition, null, false, newSynchronization, debugEnabled, suspendedResources);
	}
    //如果是required_NEW的话,则挂起当前事务,同时创建一个新的事务,执行doBegin操作
	if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
		if (debugEnabled) {
			logger.debug("Suspending current transaction, creating new transaction with name [" +
					definition.getName() + "]");
		}
		SuspendedResourcesHolder suspendedResources = suspend(transaction);
		try {
			boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
			DefaultTransactionStatus status = newTransactionStatus(
					definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
			doBegin(transaction, definition);
			prepareSynchronization(status, definition);
			return status;
		}
		catch (RuntimeException | Error beginEx) {
			resumeAfterBeginException(transaction, suspendedResources, beginEx);
			throw beginEx;
		}
	}
    // 如果是嵌入事务,则创建一个SAVEPOINT
	if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
		if (!isNestedTransactionAllowed()) {
			throw new NestedTransactionNotSupportedException(
					"Transaction manager does not allow nested transactions by default - " +
					"specify 'nestedTransactionAllowed' property with value 'true'");
		}
		if (debugEnabled) {
			logger.debug("Creating nested transaction with name [" + definition.getName() + "]");
		}
		if (useSavepointForNestedTransaction()) {
			// Create savepoint within existing Spring-managed transaction,
			// through the SavepointManager API implemented by TransactionStatus.
			// Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.
			DefaultTransactionStatus status =
					prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
			status.createAndHoldSavepoint();
			return status;
		}
		else {
			// Nested transaction through nested begin and commit/rollback calls.
			// Usually only for JTA: Spring synchronization might get activated here
			// in case of a pre-existing JTA transaction.
			boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
			DefaultTransactionStatus status = newTransactionStatus(
					definition, transaction, true, newSynchronization, debugEnabled, null);
			doBegin(transaction, definition);
			prepareSynchronization(status, definition);
			return status;
		}
	}

	// Assumably PROPAGATION_SUPPORTS or PROPAGATION_REQUIRED.
	if (debugEnabled) {
		logger.debug("Participating in existing transaction");
	}
//这里判断是否需要对已经存在的事务进行校验,这个可以通过AbstractPlatformTransactionManager.setValidateExistingTransaction(boolean)来设置,设置为true后需要校验当前事务的隔离级别和已经存在的事务的隔离级别是否一致 
	if (isValidateExistingTransaction()) {
		if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
			Integer currentIsolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
			if (currentIsolationLevel == null || currentIsolationLevel != definition.getIsolationLevel()) {
				Constants isoConstants = DefaultTransactionDefinition.constants;
				throw new IllegalTransactionStateException("Participating transaction with definition [" +
						definition + "] specifies isolation level which is incompatible with existing transaction: " +
						(currentIsolationLevel != null ?
								isoConstants.toCode(currentIsolationLevel, DefaultTransactionDefinition.PREFIX_ISOLATION) :
								"(unknown)"));
			}
		}
		if (!definition.isReadOnly()) {
			if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
				throw new IllegalTransactionStateException("Participating transaction with definition [" +
						definition + "] is not marked as read-only but existing transaction is");
			}
		}
	}
	// 如果不设置是否校验已经存在的事务,则对于REQUIRED传播级别会走到这里来,这里把newTransaction标志位设置为false,
	// 这里用的definition是当前事务的相关属性,所以隔离级别等依然是当前事务的(子事务),而不是已经存在的事务的隔离级别(父事务)
	boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
	return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
}

隔离级别对回滚事务的影响

1、如果newTransaction设置为ture,则真正执行回滚。
2、如果有保存点,则回滚到保存点。
3、否则不会真正回滚,而是设置回滚标志位。

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();
				}
				// 如果是新的事务,当传播级别为RUQUIRED_NEW时会走到这里来
				else if (status.isNewTransaction()) {
					if (status.isDebug()) {
						logger.debug("Initiating transaction rollback");
					}
					doRollback(status);
				}
				else {
				    // 加入到事务中,设置回滚状态,适用于REQUIRED传播级别
				    // 并不会真的回滚,而是设置回滚标志位
					// 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");
							}
							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);
		}
	}

隔离级别对提交事务的影响

1、就算事务方法没有抛出异常,走到了commit方法中,但是依然有可能回滚事务。
2、对于REQUIRED传播级别,即使父事务中没有抛出异常,但是子事务中已经设置了回滚标志,那么父事务依然会回滚
3、只有newTransaction标志位为true的事务才会真正执行commit操作。

@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;
	}
 // 对于REQUIRED传播级别,即使父事务中没有抛出异常,但是子事务中已经设置了回滚标志,那么父事务依然会回滚
	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);
}

在这里插入图片描述

为什么我的事务不生效

1.如果不是Innodb存储引擎,MyISAM不支持事务。
2.没有指定rollbackFor参数。
3. 没有指定transactionManager参数,默认的transactionManager并不是我期望的,以及一个事务中涉及到了多个数据库。
4. 如果AOP使用了JDK动态代理,对象内部方法互相调用不会被Spring的AOP拦截,@Transactional注解无效。
5. 如果AOP使用了CGLIB代理,事务方法或者类不是public,无法被外部包访问到,或者是final无法继承,@transactional注解无效。

squidpy 教程 1:在 AnnData 和 Squidpy 中导入空间数据 这些是 10x Genomics Visium 的 Space Ranger 输出提供的 keys,因此是第一个被采用的 keys。在这种情况下,我们假设空间坐标与像素具有相同的比例,因此我们将该值设置为 1。为此,我们将使用模拟数据集,并通过示例展示您应该注意的重要细节,以便利用 AnnData-Scanpy-Squidpy 生态系统的全部功能。并不是绝对必要的,但会节省您大量的输入,因为它是 Squidpy 和 Scanpy 的默认值。正如你所看到的,空间坐标被缩小了,图像被“放大”了。 阅读详情

相关推荐

无参考图像质量评估方法:BRISQUE、RankIQA、DIQA

常用的图像质量评估(IQA)分为无参考和有参考两种类型。常见的有参考图像质量评估方法有PSNR,SSIM以及VMAF。其中vmaf是针对视频来讲的,在它的评价方法里面添加了一些时域信息,如果应用于单张图片,需要做一些处理,如去除时域信息。有参考意味着图像质量是以参考图为基准。基于参考图像都是高清图像的假设,这些评价方法已经广泛应用于图像压缩以及图像传输、拼接之类的处理后图像的质量,假如这张参考图的质量本身就比较渣,那么该评价指标可信度就大大降低。

weixin_51732791的博客 3192

Spring事务实现原理及源码分析

Spring事务实现原理及源码分析流程介绍主流程关键对象介绍PlatformTransactionManager获取对应的TransactionManager事务的信息TransactionInfo当前事务状态TransactionStatus传播对象实现原理隔离级别对开始事务的影响(获取TransactionStatus)隔离级别对回滚事务的影响隔离级别对提交事务的影响 流程介绍 获取事务的属...

weixin_44366439的博客 4万+

高德地图爬虫

高德地图爬虫 工具:Pycharm,win10,Python3.6.4 1.需求分析 这篇爬虫和上一篇百度地图爬虫要求一样,百度地图爬虫我发现有一个auth参数会一直变化,一旦变化则获取的数据是不准确的,所以我上高德地图看了一下,高德地图没有这个反爬机制。但是高德地图大概爬取120个页面就会跳一次验证码,我这里是通过换IP解决这个问题的。 2.数据准备 同样我们需要全国地级市信息,用之前...

123的博客 1万+

Spring源码学习20

该篇幅是对createTransactionIfNecessary方法的分析 1.TransactionInfo.java /** * 用于保存事务信息的不透明对象。子类 * 必须将它传递回此类的方法,但不能看到它的内部 * */ protected final class TransactionInfo { /** * 事务管理器 */ priva...

大脸猫的博客 380

STM32 超声波模块输入捕获测距(标准库)

通道2设置为下降沿触发,触发瞬间会将CNT的记录到CCR2中,由于上升沿触发时已经将CNT置零所以此时的CNT的值就是高电平的持续时间。通道1设置为上升沿触发,触发的瞬间会将CNT的值记录到CCR1里面,同时设置通道1触发带有从模式,并把从模式设置为置零CNT。超声波传感器模块上面通常有两个超声波元器件,一个用于发射,一个用于接收。电路板上有四个引脚:VCC、GND、Trig(触发)、Echo(回应)。输入捕获原理可以看看这位大佬,感觉写的很清楚,工作电压与电流:5V,15mA。感测角度:不小于15度。

qq_62425900的博客 2083

基于fMRI数据计算脑脊液(CSF)与全脑BOLD信号的时间耦合分析

BOLD和CSF信号有多相似CSF信号要延迟多少时间才能最匹配BOLD信号BOLD-CSF的互相关公式lag:时间延迟采样点数BOLD信号CSF信号延迟时间点对应的相关系数。

Rose9614的博客 2984

spring的事务切面(上)

一个问题 在插入操作的事务最后抛出Exception异常,能否插入成功? Spring事务处理的设计概览 Spring的事务处理模板中的类层次接口 真正处理事务的是TransactionInterceptor,PlatformTransactionManager,AbstractionTransactionManager以及DataSourceTransactionManager,其他的类用来...

xiaovfight的专栏 2023

简单VASP计算INCAR设置(结构优化OPT、静态自洽SCF、能带BAND、态密度DOS)

改变 K 点、NBANDS、晶胞、ENCUT、POTCAR、自旋或 SOC 后要检查兼容性。该参数不参与物理计算,因此不会改变总能量、受力、应力或最终结构。如果研究的是金属、磁性材料、表面、二维材料、分子、缺陷、DFT+U、杂化泛函或强自旋轨道耦合体系,部分参数必须调整。适合已经用 IBRION = 2 预优化、力较小、自由度较多的结构。在 IBRION = 1、2、3 中,它只是内部缩放因子。“不能修改”不是程序禁止修改,而是修改后会改变理论模型、数值精度或能量参考,使结果不能直接比较。

weixin_51420530的博客 126

Spring事务的实现原理

Spring事务的实现原理

m0_54117624的博客 1万+

Python爬虫实战:贝壳找房二手房数据全维度抓取与成交分析(反爬突破+数据建模+可视化)

本次实战的核心不是“写爬虫脚本”,而是“构建一套贴合房产分析的贝壳找房数据抓取与分析体系”——从反爬突破保证数据获取的稳定性,到多维度分析挖掘房产的投资/居住价值,最终落地到具体的购房、投资决策。

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 2746

详解Agent Skills:让AI拥有更多专业能力(什么是Agent Skills?如何创建?如何使用?如何获取?)

本文分享如何将零散指令沉淀为可复用的 AI 能力模块🧩,介绍什么是Agent Skills?如何创建?如何获取?📚

XiaoqiangClub的博客 1274

@Transactional注解的使用

Transactional注解的底层实现是基于AOP和TransactionInterceptor拦截器来实现的,它使用了TransactionManager来管理事务,确保了在一个事务内执行的所有操作都是原子性、一致性、隔离性和持久性的。@Transactional 注解可以确保一个方法或类中的操作要么全部成功提交,要么全部回滚,从而保证数据的完整性和一致性。它适用于许多场景,包括数据库事务、业务逻辑、缓存更新、消息队列等。

米诺有糖吃 6152

把外部系统接到 SAP Build Process Automation 的两条路:前台直连与后台编排的完整范式

想把外部系统接入到你的【销售订单管理】审批流程,最稳妥的路径是:在流程里开一个,在 BTP 配好以为核心的 Destination,让前端经由approuter代理、后台通过 Cloud SDK 直连,任务处理用My Inbox或Task APIs,异步对接用。这套组合拳,既满足安全边界与运维规范,又能让前台与后台两个世界各取所需、自然衔接。SAP。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 1664

Spring事务实现的方式及底层原理

spring事务的实现方式 spring框架提供了两种事务实现方式:编程式事务、声明式事务 编程式事务:在代码中进行事务控制。优点:精度高。缺点:代码耦合度高 声明式事务:通过@Transactional注解实现事务控制 spring事务的底层原理 事务的操作本来应该由数据库进行控制,但是为了方便用户进行业务逻辑的控制,spring对事务功能进行了扩展实现。一般我们很少使用编程式事务,更多的是使用@Transactional注解实现。当使用了@Transactional注解后事务的自动功能就会关闭,由sp.

qq_34886456的博客 1万+

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

【Spring事务底层实现原理】

当调用这个代理对象的方法时,如果有事务处理,则会先关闭事务的自动功能,然后执行方法的具体业务逻辑,如果业务逻辑没有异常,那么代理逻辑就会直接提交,如果出现任何异常,那么直接进行回滚操作。应用启动时会创建一个代理类,把事务逻辑织入到代理类中,然后用代理类替代目标类,并放入上下文容器中。当实际调用目标类的事务方法时,被代理类拦截,先执行拦截器中的事务逻辑,再执行目标类的业务逻辑,最后处理异常回滚和提交。这样,当执行代理类的方法时,就会先执行事务拦截器中的事务逻辑,再执行目标类的业务逻辑。

我是Java程序员廖志伟,感谢朋友们的支持! 939

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

Spring之事务实现原理及其注解@Transactional底层和传播机制原理

本文介绍Spring之事务实现原理,以及注解@Transactional底层实现和7种传播传播机制原理//尝试获取一个事务对象 Object transaction = doGetTransaction();/*** 判断从上一个方法传递进来的事务属性是不是为空} /*** 判断是不是已经存在了事务对象(事务嵌套)//处理存在的事务 return handleExistingTransaction(definition , transaction , debugEnabled);

IUNIQUE技术册 1004

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

面试基础--- Spring 事务传播机制底层实现原理

严格遵循「同库用传播,跨库用分布式」原则REQUIRES_NEW 必须评估连接池最大容量嵌套事务场景必须测试数据库引擎支持情况事务方法间调用必须通过代理对象(AOPContext)

weixin_43290370的博客 1513

深入理解spring事务底层实现原理

事务 相信大家都在ATM机取过钱,但是是否有人考虑过它的流程是怎样的呢? 我们都知道,假如我们取300块钱,那么当这三百块钱从ATM机出来时,我们的账户相应的会减少300。这两个过程一定是要同时成功才算成功的。否则就会出现账户少了300.但是钱没出来,对于我们来说,我们损失了300.而如果钱出来了但是账户钱没扣掉的话,银行就会损失300.这两种情况都是不可取的。所以就需要保证要么大家一起成功,有一...

xiaobu201314的博客 2万+

为了更深入理解Spring事务的底层原理:通过AOP实现数据源的动态切换

为了更深入理解Spring事务的底层原理:通过AOP实现数据源的动态切换

小脚鱼的博客 535

spring中事务使用范例,事务传播机制实现逻辑,底层原理,事务回滚,事务嵌套

在java中处理数据库相关逻辑时一般都会用到事务相关处理,如果我们直接使用基于jdbc底层的事务处理,程序一般比较浮渣,spring的声明式事务处理让我们从繁杂的事务处理中得以解脱出来。 从前面的spring的其他相关底层实现我们知道,一般遇到相关schema解析的时候,spring都会获取META-INF/spring.handlers中获取对应schema解析处理类来进行处理,我们直接定位到spring事务处理模块spring-tx,获取到对应spring.handlers文件内容如下: http\:/

LeoHan 951

Spring5.0源码深度解析之SpringBean声明事务底层实现原理

Spring事务 Spring声明式事务让我们从复杂的事务处理中得到解脱,使我们再也不用去处理这些步骤:获得连接、关闭连接、事务提交和回滚操作。再也不需要在事务相关方法中处理大量的try..catch..finally代码。 Spring中事务的使用虽然已经相对简单的多,但是...

chuanyingcao2675的博客 965

标题:揭示 Spring 事务失效的典型场景及其底层实现原理——附代码示例

深入理解 Spring 事务的 AOP 增强机制和事务模板的工作原理,可以帮助我们准确识别并有效避免这些失效场景,确保事务管理在实际应用中发挥应有的作用。在同一个事务方法内部,直接调用同一类中其他事务方法,导致事务增强失效,因为 Spring 事务基于 AOP(面向切面编程)代理机制,内部方法调用绕过了代理层。在单个事务方法中同时操作不同数据源,若各个数据源对应的事务管理器不同,可能导致事务无法协调一致,从而失效。事务模板负责与具体的事务资源(如数据库连接)交互,执行事务的开启、提交、回滚等操作。

m0_46617601的博客 1459
上一篇: Redis到底有没有ACID事务
下一篇: ApplicationContextAware接口的setApplicationContext方法调用过程
Jack爱258
博客等级 码龄10年 1288粉丝 124原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值