Spring 事务管理

已于 2025-04-11 14:13:42 修改
阅读量811 收藏 26
点赞数 31
分类专栏： spring学习 文章标签： spring 数据库 sql java 后端 学习
于 2025-04-11 10:52:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/LYH2771994122/article/details/147138390
版权

Spring 事务管理

(个人学习记录)

本章主要记录spring事务的两种实现方式，及编程式事务和声明式事务（xml和注解方式），在实际过程中，我们绝大多数时候都是使用的声明式事务来实现我们的事务管理。对于事务的隔离级别和传播行为我们需要重点了解。

一、事务基础概念回顾

事务是一个最小的不可再分的工作单元。 一个事务对应一套完整的业务操作。事务管理是指这些操作要么全部成功执行，要么全部回滚，从而保证数据的一致性和完整性。

事务是一组原子性的操作，要么全部成功提交，要么全部失败回滚。它具有 ACID 四个特性：

  1. 原子性（Atomicity）：事务中的操作要么全部完成，要么全部不完成，不会出现部分完成的情况。

  2. 一致性（Consistency）：事务执行前后，数据库的完整性约束不会被破坏。例如，转账操作前后，两个账户的金额总和不变。

  3. 隔离性（Isolation）：多个事务并发执行时，一个事务的执行不能被其他事务干扰。不同的隔离级别决定了事务之间相互影响的程度。

  4. 持久性（Durability）：一旦事务提交，其所做的修改就会永久保存在数据库中，即使系统崩溃也不会丢失。

二、Spring 事务管理的优势

  1. 简化事务处理代码：使用 Spring 事务管理，开发者无需编写大量繁琐的事务处理代码，如事务的开始、提交、回滚等，只需通过简单的配置或注解即可实现事务管理。

  2. 支持多种事务管理方式：Spring 提供了编程式事务管理和声明式事务管理两种方式。声明式事务管理通过配置或注解的方式，将事务管理代码从业务逻辑中分离出来，使代码更加简洁，维护更加方便。

  3. 与多种持久化技术集成：Spring 事务管理可以与各种持久化技术（如 JDBC、Hibernate、JPA 等）无缝集成，无论你使用哪种持久化框架，都能轻松享受 Spring 事务管理带来的便利。

三、Spring对事务的支持

1、Spring实现事务的两种方式
  • 编程式事务

​ 通过编写代码的方式来实现事务的管理。

  • 声明式事务

​ 基于注解方式

​ 基于XML配置方式

2、Spring事务管理API

Spring对事务的管理底层实现方式是基于AOP实现的。采用AOP的方式进行了封装。所以Spring专门针对事务开发了一套API，API的核心接口如下：

image.png

PlatformTransactionManager接口：spring事务管理器的核心接口。在Spring6中它有两个实现：

  • DataSourceTransactionManager：支持JdbcTemplate、MyBatis、Hibernate等事务管理。
  • JtaTransactionManager：支持分布式事务管理。(了解即可)

下面我们将介绍一下PlatformTransactionManager接口

1. PlatformTransactionManager

PlatformTransactionManager接口是Spring提供的平台事务管理器，主要用于管理事务。该接口中提供了三个事务操作的方法，具体如下：

img

PlatformTransactionManager接口只是代表事务管理的接口，并不知道底层是如何管理事务的，具体如何管理事务则由它的实现类来完成。该接口常见的几个实现类如下,当底层采用不同的持久层技术时，系统只需使用不同的PlatformTransactionManager实现类即可。在SSM框架中，我们使用的是MyBatis，因此事务管理器我们选择的是DataSourceTransactionManager。

image.png

2. TransactionDefinition

TransactionDefinition接口是事务定义（描述）的对象，该对象中定义了事务基本属性，并提供了获取事务基本属性的方法，具体如下：

img

2.1. 事务基本属性
  • 传播行为（propagation behavior）：当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。Spring定义了七种传播行为，如下表所示
事务传播行为类型说明
PROPAGATION_REQUIRED如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。
PROPAGATION_SUPPORTS支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY使用当前的事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。
  • 隔离级别（isolation level）：定义了一个事务可能受其他并发事务的影响程度。多个事务并发运行，经常会操作相同的数据来完成各自的任务，可能会出现脏读，不可重复读和幻读的问题。隔离级别有四种，如下表
事务隔离级别类型说明
DEFAULTSpring中默认的事务隔离级别。以连接的数据库的事务隔离级别为准。
READ_UNCOMMITTEDSpring事务最弱的隔离级别。一个事务可以读取到另一个事务未提交的事务记录。容易出现脏读、不可重复读、幻读的问题。
READ_COMMITTED一个事务只能读取到已经提交的记录，不能读取未提交的记录。可以解决脏读问题，但仍出现不可重复读、幻读的问题。
REPEATBLE_READ一个事务可以多次从数据库读取某条记录，而且多次读取的那条记录都是一致的、相同的。可以避免脏读、不可重复读的问题，但仍可能出现幻读的问题。
SERIALIZABLESpring最强的隔离级别，一般不推荐使用。
  • 是否只读（isReadOnly）：如果一个方法内都是对数据库的select操作，那么可以设置方法事务为只读，数据库也会对该事务进行特定的优化。只读事务内不能有insert、update、delete的操作
  • 事务超时（timeout）：事务可能涉及对后端数据库的锁定，所以长时间的事务运行会不必要的占用数据库资源，设置事务超时时间可以及时释放资源
2.2. DefaultTransactionDefinition

DefaultTransactionDefinition是Spring提供的TransactionDefinition接口的默认实现类，该类定义的事务规则如下，传播行为默认为PROPAGATION_REQUIRED，隔离级别默认为数据库的隔离级别，MySQL的事务隔离级别是REPEATABLE READ。事务超时默认为永不超时并且事务不是只读的。

 class DefaultTransactionDefinition implements TransactionDefinition, Serializable {
	private int propagationBehavior = PROPAGATION_REQUIRED;
	private int isolationLevel = ISOLATION_DEFAULT;
	private int timeout = TIMEOUT_DEFAULT;
	private boolean readOnly = false;
	//略
}
3. TransactionStatus

TransactionStatus接口是事务的状态，它描述了某一时间点上事务的状态信息。该接口中包含6个方法，具体如下：

img

四、Spring编程式事务管理

本次的用例：在银行账户表(t_account)中有两个账户：用户A（0102030）和用户B（0103040），现在假设用户A需要向用户B转账1000元。

Spring提供了专门用于事务管理的API。要使用Spring实现事务管理需要引入spring-tx依赖，但是在SSM框架中，我们引入的spring-jdbc依赖中已经包含了spring-tx依赖，因此无须额外引入。

    <!-- spring-tx依赖  -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>6.1.8</version>
    </dependency>

使用Spring实现编程式事务管理，需要在业务逻辑方法中，定义事务的开始、正常执行后的事务提交和异常时的事务回滚。具体使用方法如下：

  1. 在Spring配置文件(spring-mybatis.xml)中配置一个事务管理器组件，提供对事务处理的全面支持和统一管理
<!--定义事务管理器 -->
<bean id="txManager"
      class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--关联数据源-->
    <property name="dataSource" ref="dataSource" />
</bean>
  1. 在业务逻辑组件中使用事务管理器组件实现事务管理功能。
@Service
public class AccountService {

	@Autowired
	private AccountMapper accountMapper;

	@Autowired
	private DataSourceTransactionManager txManager;

	public String moneyTransfer(String accountA, String accountB, double money) {
		//定义事务规则（隔离级别、传播行为）
		DefaultTransactionDefinition definition=new DefaultTransactionDefinition();
		//开启事务管理，并返回事务状态
		TransactionStatus status = txManager.getTransaction(definition);
		try {
			System.out.println("开始转账");
			// 获取A和B账户的详情
			Account A = accountMapper.selectAccount(accountA);
			Account B = accountMapper.selectAccount(accountB);
			//用户A账户减少相应金额
			accountMapper.updateMoney(accountA, A.getMoney() - money);
			//用户B账户增加相应金额
			accountMapper.updateMoney(accountB, B.getMoney() + money);
			txManager.commit(status); //提交事务
			return "success";
		} catch (Exception ex) {
			txManager.rollback(status); //如果出现异常回滚事务
			throw ex;
		}

	}
}

五、Spring声明式事务管理

编程式事务管理必须要在业务逻辑中包含额外的事务管理代码。和业务逻辑代码产生了耦合，产生了代码冗余，不方便代码的维护和扩展。

Spring声明式事务管理最大的优点在于开发者无需通过编程的方式来管理事务，只需在配置文件中进行相关的事务规则声明，就可以将事务应用到业务逻辑中。这使得开发人员可以更加专注于核心业务逻辑代码的编写，在一定程度上减少了工作量，提高了开发效率，所以在实际开发中，通常都推荐使用声明式事务管理。

Spring声明式事务管理通过AOP技术实现的事务管理，主要思想是将事务作为一个“切面”代码单独编写，然后通过AOP技术将事务管理的“切面”植入到业务目标类方法中。

Spring的声明式事务管理可以通过两种方式来实现，一种是基于XML的方式，另一种是基于注解的方式。

基于XML方式实现

基于XML方式的声明式事务是在配置文件中通过**tx:advice元素配置事务规则来实现的，然后通过使用aop:config编写的AOP配置**，让Spring自动对目标生成代理。tx:advice元素及其子元素如下图所示：

img

结合本次任务，基于XML方式实现银行转账操作的事务管理需要如下三个步骤：

  1. 添加spring-aspects依赖

因为要使用切面配置AOP相关语法，因此需要引入spring-aop和spring-aspects依赖，根据依赖传递性，spring-webmvc依赖会自动引入spring-aop，因此只需要额外添加spring-aspects依赖即可。

<!--spring和AspectJ整合依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>6.1.8</version>
    </dependency>
  1. 配置事务管理器

在Spring配置文件中配置事务管理器，事务管理器要关联我们配置中的数据源。(在spring-mybatis.xml中)

<!--定义事务管理器 -->
<bean id="txManager" 
      class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <!--关联数据源-->
  <property name="dataSource" ref="dataSource" />
</bean>
  1. 使用**tx:advice标签配置事务规则**，通过transaction-manager指定事务管理器，在tx:method标签中，通过name指定匹配的方法名，可以使用进行模糊匹配，对于不同类型的方法可以指定不同的事务规则。比如："find"表示以find开头的方法，传播行为为SUPPRORTS，表示支持当前事务，如果当前没有事务，就以非事务方式执行，read-only为只读。对于"moneyTransfer"方法，传播行为为必须在事务中执行，也就是为该方法加了事务。(在spring-mybatis.xml中)
<!-- 配置事务规则 -->
<tx:advice id="txAdvice" transaction-manager="txManager">
    <tx:attributes>
      <!-- 定义哪些方法需要进行事务处理，*表示任意字符，比如find*表示以find开头的方法 -->
      <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
      <tx:method name="add*" propagation="REQUIRED"/>
      <tx:method name="del*" propagation="REQUIRED"/>
      <tx:method name="update*" propagation="REQUIRED"/>
      <tx:method name="moneyTransfer" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>
  1. 使用**aop:config配置事务切面**，通过aop:pointcut配置切点，通过aop:advisor标签的advice-ref属性指定切点应用的事务规则，通过pointcut-ref属性指定关联的切点。(在spring-mybatis.xml中)
<!-- 定义切面 -->
<aop:config>
  <!-- 定义切点 -->
  <aop:pointcut expression="execution(* com.cg.service.*.*(..))" id="pointcut"/>
  <!-- 在指定的切点上应用事务规则 -->
  <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
</aop:config>

通过以上的配置，我们就可以通过XML配置文件的方式实现全局的配置。

基于注解方式实现

基于注解方式实现是通过使用**@Transactional注解**来实现方法的事务管理功能。

结合本次任务，具体实现步骤如下：

  1. 配置事务管理器

在Spring配置文件中配置事务管理器，事务管理器要关联我们配置中的数据源。(在spring-mybatis.xml中)

<!--定义事务管理器 -->
<bean id="txManager" 
      class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <!--关联数据源-->
  <property name="dataSource" ref="dataSource" />
</bean>

2.在Spring容器中注册事务注解驱动，需要通过transaction-manager属性关联我们的事务管理器(在spring-mybatis.xml中)

<!--注册事务注解驱动-->
<tx:annotation-driven transaction-manager="txManager"/>

3.在需要事务管理的类或方法上使用**@Transactional**注解。

  • 如果将注解添加在Bean类上，则表示事务的设置对整个Bean类的所有方法都起作用；
  • 如果将注解添加在Bean类中的某个方法上，则表示事务的设置只对该方法有效。
  • 使用@Transactional注解时，可以通过参数配置具体事务规则

img

结合本次任务，我们只需要在moneyTransfer方法上面加上@Transactional注解就可以对银行转账实现事务管理功能了。

@Service
public class AccountService {

	@Autowired
	private AccountMapper accountMapper;

	@Transactional  //事务管理注解
	public String moneyTransfer(String accountA, String accountB, double money) {
		System.out.println("开始转账");
		// 获取A和B账户的详情
		Account A = accountMapper.selectAccount(accountA);
		Account B = accountMapper.selectAccount(accountB);
		//用户A账户减少相应金额
		accountMapper.updateMoney(accountA, A.getMoney() - money);
		//用户B账户增加相应金额
		accountMapper.updateMoney(accountB, B.getMoney() + money);
		return "success";
	}
}

拓展

如果是基于配置类方式整合的SSM框架，要使用注解方式开启事务管理功能需要在对应配置类（SpringMyBatisConfig）中注册事务管理器（DataSourceTransactionManager）和开启注解驱动（@EnableTransactionManagement），配置类如下所示：SpringMyBatisConfig.java

@Configuration
@ComponentScan("com.cg.service")
@PropertySource("classpath:db.properties")
@EnableTransactionManagement //开启事务注解驱动
public class SpringMyBatisConfig {

    @Bean
    public DataSource dataSource(@Value("${jdbc.username}")String user,
                                 @Value("${jdbc.password}")String password,
                                 @Value("${jdbc.url}")String url,
                                 @Value("${jdbc.driver}")String driver){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUsername(user);
        dataSource.setPassword(password);
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driver);
        return dataSource;
    }

    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) throws IOException {
        //实例化SqlSessionFactory工厂
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        //设置数据源
        sqlSessionFactoryBean.setDataSource(dataSource);
        //mybatis框架核心配置
        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setMapUnderscoreToCamelCase(true);
        configuration.setAutoMappingBehavior(AutoMappingBehavior.FULL);
        configuration.setLogImpl(StdOutImpl.class);
        sqlSessionFactoryBean.setConfiguration(configuration);
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath:mapper/*.xml"));
        sqlSessionFactoryBean.setTypeAliasesPackage("com.cg.entity");
        return sqlSessionFactoryBean;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        //设置mapper接口和xml文件所在的共同包
        mapperScannerConfigurer.setBasePackage("com.cg.mapper");
        return mapperScannerConfigurer;
    }

    //向Spring容器中注册事务管理器
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        PlatformTransactionManager transactionManager=new DataSourceTransactionManager(dataSource);
        return transactionManager;
    }
}

声明式事务失效场景

  1. 失效场景1：使用try…catch…代码块捕获异常并处理，未抛出
@Transactional
	public String moneyTransfer(String accountA, String accountB, double money) {
		try{
			System.out.println("开始转账");
			// 获取A和B账户的详情
			Account A = accountMapper.selectAccount(accountA);
			Account B = accountMapper.selectAccount(accountB);
			//用户A账户减少相应金额
			accountMapper.updateMoney(accountA, A.getMoney() - money);
			int i= 1/0;//模拟以外异常
			//用户B账户增加相应金额
			accountMapper.updateMoney(accountB, B.getMoney() + money);
			return "success";
		}catch (Exception ex){
			return "fail";
		}
	}

原因分析：因为异常已经被捕获并处理，异常未抛出导致事务管理器未捕获到异常导致事务失效。

解决方案：去掉try…catch…代码块，或者将异常抛出去

@Transactional
	public String moneyTransfer(String accountA, String accountB, double money) {
			System.out.println("开始转账");
			// 获取A和B账户的详情
			Account A = accountMapper.selectAccount(accountA);
			Account B = accountMapper.selectAccount(accountB);
			//用户A账户减少相应金额
			accountMapper.updateMoney(accountA, A.getMoney() - money);
			int i= 1/0;//模拟以外异常
			//用户B账户增加相应金额
			accountMapper.updateMoney(accountB, B.getMoney() + money);
			return "success";
	}
  1. 失效场景2：抛出的异常不是RuntimeException异常及其子类。
@Transactional
	public String moneyTransfer(String accountA, String accountB, double money) throws Exception {
		try{
			System.out.println("开始转账");
			// 获取A和B账户的详情
			Account A = accountMapper.selectAccount(accountA);
			Account B = accountMapper.selectAccount(accountB);
			//用户A账户减少相应金额
			accountMapper.updateMoney(accountA, A.getMoney() - money);
			//模拟抛出异常，异常类型不是RuntimeException
			if(accountA.equals(accountB)){
				throw new Exception("账户不能为同一个账户");
			}
			//用户B账户增加相应金额
			accountMapper.updateMoney(accountB, B.getMoney() + money);
			return "success";
		}catch (Exception ex){
			throw ex;
		}
	}

原因分析：声明式异常处理默认只能捕获处理RuntimeException异常及其子类异常。对于其他类型的异常不会处理。

解决方案1：抛出异常时，异常类型要使用RuntimeException或者其子类，而不是Exception，特别是自定义的业务异常，一定要继承RuntimeException及其子类。

@Transactional
	public String moneyTransfer(String accountA, String accountB, double money) throws Exception {
		try{
			System.out.println("开始转账");
			// 获取A和B账户的详情
			Account A = accountMapper.selectAccount(accountA);
			Account B = accountMapper.selectAccount(accountB);
			//用户A账户减少相应金额
			accountMapper.updateMoney(accountA, A.getMoney() - money);
			//模拟抛出异常，异常类型是RuntimeException及其子类异常
			if(accountA.equals(accountB)){
				throw new RuntimeException("账户不能为同一个账户");
			}
			//用户B账户增加相应金额
			accountMapper.updateMoney(accountB, B.getMoney() + money);
			return "success";
		}catch (Exception ex){
			throw ex;
		}
	}

解决方案2：可以在@Transactional注解中通过配置rollbackFor属性指定异常类型为Exception，表示对所有异常都会出发事务管理机制。

@Transactional(rollbackFor = Exception.class)
	public String moneyTransfer(String accountA, String accountB, double money) throws Exception {
		try{
			System.out.println("开始转账");
			// 获取A和B账户的详情
			Account A = accountMapper.selectAccount(accountA);
			Account B = accountMapper.selectAccount(accountB);
			//用户A账户减少相应金额
			accountMapper.updateMoney(accountA, A.getMoney() - money);
			//模拟抛出异常，异常类型不是RuntimeException
			if(accountA.equals(accountB)){
				throw new Exception("账户不能为同一个账户");
			}
			//用户B账户增加相应金额
			accountMapper.updateMoney(accountB, B.getMoney() + money);
			return "success";
		}catch (Exception ex){
			throw ex;
		}
	}
  1. 失效场景3：在同一个类中，未加@Transactional注解方法调用了标记有@Transactional注解的方法，事务管理也会失效。
//未加@Transactional注解
public String moneyTransfer(String accountA, String accountB) throws Exception {
		return moneyTransfer(accountA,accountB,1000);
	}
	/**
	 * 转账操作，用户A账户向用户B账户转账
	 *
	 * @param accountA
	 *            用户A账户编号
	 * @param accountB
	 *            用户B账户编号
	 * @param money
	 *            转账金额
	 * @return 转账结果
	 */
	@Transactional(rollbackFor = Exception.class)
	public String moneyTransfer(String accountA, String accountB, double money) throws Exception {
		try{
			System.out.println("开始转账");
			// 获取A和B账户的详情
			Account A = accountMapper.selectAccount(accountA);
			Account B = accountMapper.selectAccount(accountB);
			//用户A账户减少相应金额
			accountMapper.updateMoney(accountA, A.getMoney() - money);
			//模拟抛出异常，异常类型不是RuntimeException
			if(accountA.equals(accountB)){
				throw new Exception("账户不能为同一个账户");
			}
			//用户B账户增加相应金额
			accountMapper.updateMoney(accountB, B.getMoney() + money);
			return "success";
		}catch (Exception ex){
			throw ex;
		}
	}

原因分析：方法未通过代理对象调用，无法触发事务管理。

解决方案：在每一个方法上都加上@Transactional注解或者尽量避免在同一个类中方法之间互相调用。

@Transactional(rollbackFor = Exception.class)
public String moneyTransfer(String accountA, String accountB) throws Exception {
		return moneyTransfer(accountA,accountB,1000);
	}
	/**
	 * 转账操作，用户A账户向用户B账户转账
	 *
	 * @param accountA
	 *            用户A账户编号
	 * @param accountB
	 *            用户B账户编号
	 * @param money
	 *            转账金额
	 * @return 转账结果
	 */
	@Transactional(rollbackFor = Exception.class)
	public String moneyTransfer(String accountA, String accountB, double money) throws Exception {
		try{
			System.out.println("开始转账");
			// 获取A和B账户的详情
			Account A = accountMapper.selectAccount(accountA);
			Account B = accountMapper.selectAccount(accountB);
			//用户A账户减少相应金额
			accountMapper.updateMoney(accountA, A.getMoney() - money);
			//模拟抛出异常，异常类型不是RuntimeException
			if(accountA.equals(accountB)){
				throw new Exception("账户不能为同一个账户");
			}
			//用户B账户增加相应金额
			accountMapper.updateMoney(accountB, B.getMoney() + money);
			return "success";
		}catch (Exception ex){
			throw ex;
		}
	}
什么是事务,以及事务的特性！
m0_38029796的博客
12-26 2395
什么是事务,以及事务的特性！
spring事务管理
10-27
### Spring事务管理详解 #### 一、Spring事务管理概述 Spring框架提供了强大的事务管理功能，使得开发者能够更方便地管理应用程序中的事务。Spring事务管理主要包括两种类型：编程式事务管理和声明式事务管理。 -...
什么是事务？事务的四个特征（ACID）
qq_44290077的博客
07-08 2万+
一、什么是事务？         **事务（Transaction）是访问并可能更新数据库中各项数据项的一个程序执行单元（unit）。**事务由事务开始（begin transaction）和事务结束（end transaction）之间执行的全体操作组成。         事务是一个不可分割的数据库操作序列，也是数据库并发控制的基本单位，其执行的结
什么是事务？事务的特性？
m0_71188683的博客
11-21 4640
在mysql中，事务是一种机制、一个操作序列，是访问和更新数据库的程序执行单元。事务中包含一个或多个数据库操作命令，会把所有的命令作为一个整体一起向系统提交或撤销操作请求，即这一组数据库命令要么都执行，要么都不执行。 php入门到就业线上直播课：进入学习 本教程操作环境：windows7系统、mysql5.6版本、Dell G3电脑。 数据库的事务（Transaction）是一种机制、一个操作序列，是访问和更新数据库的程序执行单元，包含了一组数据库操作命令。 事务把所有的命令作为一个整
什么是事务？
weixin_62993347的博客
02-08 7334
什么是事务？；事务的四个特征（ACID）；Sping是如何控制事务？——AOP；事务的传播方式；脏读、幻读、不可重复读；事务的隔离级别；Spring的事务注解
事务的四大特性
Javaer`s blog
02-29 5万+
1. 事务的四大特性 事务具有4个基本特征，分别是：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Duration），简称ACID ① 原子性 事务的原子性是指事务必须是一个原子的操作序列单元。事务中包含的各项操作在一次执行过程中，只允许出现两种状态之一，要么都成功，要么都失败 任何一项操作都会导致整个事务的失败，同时其它已经被执行的操作都将...
Spring事务管理Demo
05-01
Spring事务管理的目的是确保数据的一致性和完整性，尤其是在多操作、多资源的环境中。本Demo将深入探讨Spring如何实现事务的管理。 首先，Spring提供了两种主要的事务管理方式：编程式事务管理和声明式事务管理。 ...
Spring事务管理-积分功能实现
最新发布
03-23
基于tx命名空间的声明式事务管理案例
Spring事务管理开发必备jar包
03-07
本资源包提供了进行Spring事务管理开发所需的所有关键库，包括框架基础、核心组件、AOP（面向切面编程）支持、日志处理、编译工具以及与数据库交互的相关jar包。下面将对这些知识点进行详细解释： 1. **Spring框架*...
Spring事务管理
09-24
Spring事务管理是Java开发中一个至关重要的概念，特别是在企业级应用开发中，它确保了数据的一致性和完整性。Spring框架提供了强大的事务管理机制，能够帮助开发者处理事务的开始、提交、回滚以及隔离级别等事务特性...
事务(一)——什么是事务，为什么会有事务，事务是做什么的？
lanhuyuedui2012的专栏
11-24 1万+
什么是事务，为什么会有事务，事务是做什么的？ 看到这个标题工作这么久，从来没有认真的思考过这个问题，今天参考一些资料做一些总结。 1、什么是事务 (1) 事务的定义 事务就是用户定义的一系列数据库操作，这些操作可以视为一个完成的逻辑处理工作单元，要么全部执行，要么全部不执行，是不可分割的工作单元。 (2)事务的使用： begin tran...
事务的隔离级别详解
当冬夜渐暖的博客
09-23 282
文章引用出处： https://www.toutiao.com/i6733032238771864067/ 什么是事务? 事务是逻辑上的一组操作，要么都执行，要么都不执行。 事务最经典也经常被拿出来说例子就是转账了。假如小明要给小红转账1000元，这个转账会涉及到两个关键操作就是：将小明的余额减少1000元，将小红的余额增加1000元。万一在这两个操作之间突然出现错误比如银行系统崩溃，导致小明余额...
一文读懂数据库事务
Dablelv 的博客专栏。
04-19 2万+
首先说一下什么是事务。事务（Transaction）指一个操作，由多个步骤组成，要么全部成功，要么全部失败。比如我们常用的转账功能，假设A账户向B账号转账，那么涉及两个操作：（1）从A账户扣钱；（2）往B账户加入等量的钱。因为是独立的两个操作，所以可能有一个成功，一个失败的情况。但是因为在这种场景下，必须要保证事务，即要么同时成功，要么同时失败（一个失败需要回滚），不能存在从 A 账户扣钱成功，往 B 账户加入等量钱失败这种情况。
什么是事务?事务的四个特性(ACID) ?并发事务带来哪些问题?事务隔离级别都有哪些?事务的传播特性
m0_62512076的博客
06-13 341
事务（A）读取某表中的数据age=20，事务（B）也读取age=20，事务（A）修改age=age-1，事务（A）也修改age=age-1，最终结果age=19，事务（A）的修改被丢失。幻读与不可重复读类似。不同的事务并发操纵相同的数据时，每个事务都有各自完整的数据空间，即一个事务内部的操作及使用的数据对其他并发事务是隔离的，并发执行的 各个事务之间不能互相干扰。因此，在这种隔离级别下，查询是不会加锁的，也由于查询的不加锁，所以这种隔离级别的一致性是最差的，可能会产生“脏读”、“不可重复读”、“幻读”。
MySQL——事务(Transaction)详解
热门推荐
浅然的专栏
03-23 24万+
该博客详解MySQL中的事务 一、事务定义 Transaction 事务：一个最小的不可再分的工作单元；通常一个事务对应一个完整的业务(例如银行账户转账业务，该业务就是一个最小的工作单元) 一个完整的业务需要批量的DML(insert、update、delete)语句共同联合完成 事务只和DML语句有关，或者说DML语句才有事务。这个和业务逻辑有关，业务逻辑不同，DML语句的个数不同...
MySQL事务详解
qq_59180100的博客
07-17 3024
事务（Transaction）是在数据库管理系统中执行的一个逻辑操作单元，它是由一系列数据库操作组成的逻辑工作单元。事务是并发控制的单位，是用户定义的一个操作序列。事务必须满足：原子性、一致性、隔离性和持久性四个特性（ACID）。事务可以防止多个用户同时对数据库进行修改时产生的数据不一致问题，例如脏读、不可重复读和幻读。事务的隔离级别有四种，分别是读未提交、读提交、可重复读和串行化，不同的隔离级别有不同的并发效果和开销。事务可以用SQL语句或编程语言来控制，例如BEGIN、COMMIT、ROLLBACK等。
Spring事务管理配置方式演示
标题所揭示的知识点是Spring事务管理的配置方式。Spring作为Java领域一个极为重要的框架，其事务管理是企业级开发中不可或缺的一部分。事务管理是保证数据库操作的原子性、一致性、隔离性和持久性的关键技术。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值