18 事务

最新推荐文章于 2023-07-08 12:27:26 发布
最新推荐文章于 2023-07-08 12:27:26 发布
阅读量91 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41673498/article/details/104480929
版权

目录

编程事务（手动事务）--代码冗余

事务底层原理

声明式事务（xml+注解）

xml方式

注解

事务传播行为 七种

事务特性：

  原子性：要不全部成功，要不全部失败，不可再分

  一致性：A 500 B 0  转账B  B=500 A=0  A+B=500

  隔离性：多个事务之间互不影响

  持久性：保存到数据库的数据后不能做其他操作

Spring事务传播机制

Spring隔离级别

Spring事务 （面）：

编程事务（手动事务）--代码冗余

 <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>


 

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

@Component
public class TransactionUtils {
    // 事物管理器
    @Autowired
    private DataSourceTransactionManager dataSourceTransactionManager;
    //开启事务
    public TransactionStatus begin() {
        TransactionStatus transaction = dataSourceTransactionManager.getTransaction(new DefaultTransactionDefinition());
        return transaction;
    }
    public void commit(TransactionStatus transaction) {
        dataSourceTransactionManager.commit(transaction);
    }
    public void rollback(TransactionStatus transaction) {
        dataSourceTransactionManager.rollback(transaction);
    }
}

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
    	 http://www.springframework.org/schema/beans/spring-beans.xsd
     	 http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
     	 http://www.springframework.org/schema/tx/spring-tx.xsd">
	<!-- 开启注解 -->
	<context:component-scan base-package="com.itmayiedu"></context:component-scan>
	<!-- 1. 数据源对象: C3P0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"></property>
		<property name="user" value="root"></property>
		<property name="password" value="root"></property>
	</bean>

	<!-- 2. JdbcTemplate工具类实例 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

   <!-- 配置事物 -->
   <bean  id="DataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
   </bean>
</beans>

使用事务

 @Autowired
   private TransactionUtils transactionUtils;
	public void add() {
        TransactionStatus begin =null;
	    try{
             begin = transactionUtils.begin();
            System.out.println("UserService2 ..add");
             int i =1/0;
            userDao.add();
            transactionUtils.commit(begin);
        }catch (Exception e){
            transactionUtils.rollback(begin);
        }
	}

事务底层原理

事务原理：aop编程+环绕通知+异常通知（重点）

aop管理事务：业务逻辑层不要加try，将异常抛给上一层，否则事务不起作用；在控制层进行捕获

环绕通知 begin和commit 异常通知：rollback

@Component
public class TransactionUtils {
	// 事物管理器
	@Autowired
	private DataSourceTransactionManager dataSourceTransactionManager;
	public TransactionStatus begin() {
		TransactionStatus transaction = dataSourceTransactionManager.getTransaction(new DefaultTransactionDefinition());
		return transaction;
	}
	public void commit(TransactionStatus transaction) {
		dataSourceTransactionManager.commit(transaction);
	}
	public void rollback(TransactionStatus transaction) {
		dataSourceTransactionManager.rollback(transaction);
	}
}


import com.util.TransactionUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.TransactionStatus;

	public class Aop02 {
		@Autowired
		private TransactionUtils transactionUtils;
		private   TransactionStatus begin;


		public void begin() {
			System.out.println("前置通知....");
		}

		public void commit() {
			System.out.println("后置通知....");
		}

		public void afterRun() {
			System.out.println("运行通知....");
		}

		public void afterThrowing() {
			System.out.println("异常通知");
			transactionUtils.rollback(begin);
		}

		public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
			begin = transactionUtils.begin();
			System.out.println("我是环绕通知-前");
			proceedingJoinPoint.proceed();
			System.out.println("我是环绕通知-后");
			transactionUtils.commit(begin);

		}
}

声明式事务（xml+注解）

xml方式

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
    	 http://www.springframework.org/schema/beans/spring-beans.xsd
     	 http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
     	 http://www.springframework.org/schema/tx/spring-tx.xsd">
	<!-- 1. 数据源对象: C3P0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"></property>
		<property name="user" value="root"></property>
		<property name="password" value="root"></property>
	</bean>

	<!-- 2. JdbcTemplate工具类实例 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

	<!-- 3.配置事物 -->
	<bean id="dataSourceTransactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

	<tx:advice id="txAdvice" transaction-manager="dataSourceTransactionManager">
		<tx:attributes>
     <!-- get和find不需要事务 -->
			<tx:method name="get*" read-only="true" />
			<tx:method name="find*" read-only="true" />
			<tx:method name="*" read-only="false" />
		</tx:attributes>
	</tx:advice>
	<!-- Aop配置： 拦截哪些方法(切入点表表达式) + 应用上面的事务增强配置 -->
	<aop:config>
		<aop:pointcut expression="execution(* com.itmayiedu02.service.UserService.add(..))"
			id="pt" />
		<aop:advisor advice-ref="txAdvice" pointcut-ref="pt" />
	</aop:config>

</beans>

注解

步骤：

         1） 必须引入Aop相关的jar文件

         2） bean.xml中指定注解方式实现声明式事务管理以及应用的事务管理器类

         3）在需要添加事务控制的地方，写上: @Transactional

@Transactional注解：

         1）应用事务的注解

         2）定义到方法上： 当前方法应用spring的声明式事务

         3）定义到类上：   当前类的所有的方法都应用Spring声明式事务管理;

         4）定义到父类上： 当执行父类的方法时候应用事务。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
    	 http://www.springframework.org/schema/beans/spring-beans.xsd
     	 http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
     	 http://www.springframework.org/schema/tx/spring-tx.xsd">
	<!-- 开启注解 -->
	<context:component-scan base-package="com.itmayiedu"></context:component-scan>
	<!-- 1. 数据源对象: C3P0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"></property>
		<property name="user" value="root"></property>
		<property name="password" value="root"></property>
	</bean>

	<!-- 2. JdbcTemplate工具类实例 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

	<!-- 配置事物 -->
	<bean id="dataSourceTransactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 开启注解事物 -->
    <tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>
</beans>

 

@Transactional
	public void add() {
		try {
			userDao.add("lisi", 18);
			int i = 1 / 0;
			userDao.add("yushengjun", 19);
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();//事物手动回滚代码
		}
		
	}

使用事物注意事项

 事物是程序运行如果没有错误,会自动提交事物,如果程序运行发生异常,则会自动回滚。

 如果使用了try捕获异常时.一定要在catch里面手动回滚。

 事物手动回滚代码

TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

事务传播行为 七种

Spring中事务的定义：

Propagation（key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。）有以下选项可供使用：

  • PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
  • PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。(如果当前有事物，我就用当前事物,如果当前没有事物，就以非事物进行执行)
  • PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。 
  • PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。 
  • PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 
  • PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。
 @Transactional(propagation = Propagation.REQUIRED)

事务传播行为:

         Propagation.REQUIRED

                   指定当前的方法必须在事务的环境下执行；

                   如果当前运行的方法，已经存在事务， 就会加入当前的事务；

         Propagation.REQUIRED_NEW

                   指定当前的方法必须在事务的环境下执行；

                   如果当前运行的方法，已经存在事务：  事务会挂起； 会始终开启一个新的事务，执行完后；  刚才挂起的事务才继续运行。

 

流星天道酬勤
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
事务的传播机制
blackball1998的博客
06-25 2931
事务的传播机制 事务的传播行为就是在两个都启用了事务的方法进行嵌套调用时，外层事务和内层事务的执行动作，Spring支持七种传播方式，他们的效果如下： REQUIRED：如果有外层事务，则加入这个事务，否则开启一个新的事务 SUPPORTS：如果有外层事务，则加入这个事务，否则就以非事务方式执行 MANDATORY：如果有外层事务，则加入这个事务，否则抛出异常 REQUIRES_NEW：开启一个独立的新事务执行 NOT_SUPPORTED：方法不应该以事务方法执行，如果有外层事务，就以非事务方式执行 NE
分布式事务实践 解决数据一致性
11-23
8-18 实现Ticket服务 8-19 实现Order服务 8-20 实现读写分离 8-21 测试与并发 8-22 事件溯源模式与Axon框架总结 第9章 TCC模式和微服务架构的设计模式 本章介绍TCC模式，也对微服务系统的几种设计模式，以及这些...
Mysql事务超时
I want to know a little more.
07-16 7418
本文概览：介绍了超时有关的概念：@Transaction的timeout、mybatis的timeout、mysql的innodb_lock_wait_timeout。 1 问题 1.1 背景 在一个事务中完成解析一个大文件，分批存入到数据库。遇到问题，执行时间比较长，就讨论了事务超时的问题，担心执行时间太长，事务超时自动回滚了。 为了考虑这个问题，需要考虑如下超时相关的设置： 一个事务的超时时间。spring的@Transactional 一个stametn的执行时间。包括mybais的tim
事务的四种隔离级别详解
qq_36792191的博客
01-19 2万+
1.事务的隔离级别 数据库事务的隔离级别有4种，由低到高分别为Read Uncommited、Read Commited、Repeatable Read、Serializable。并发数据访问时可能会出现以下问题，3类数据读取问题（脏读、不可重复读、幻读）和2类数据更新问题（第1类丢失更新和第2类丢失更新）。 Read Uncommited，读未提交，即一个事务可以读取另一个未提...
18、事务的创建
zhen_hong的博客
08-04 1326
    上一节，我们围着spring事务绕了一圈，大致看了下事务的外貌，挺漂亮的，但是咱是有内涵的人，做人不能只看外表，俗话说好看的皮囊千千万，有趣的灵魂万里挑一，所以光有一张好看的皮囊是不够的，关键还得看内存，虽然现实好像不是这样。 好了，在进行目标方法调用前，spring肯定要通过数据库连接设置事务属性，这样才能启动事务。 protected Tra...
SqlServer事务回滚
你要明白，任何问题都不是孤立存在的，一定有人曾经遇到过，并且已经有更好的解决办法了，只是我还不知道。我不应该在黑暗中独自前行，去重新发明轮子，也许我的顿悟，只是别人的基本功！我应该要站在巨人的肩膀上，学习更成熟的经验和方法，然后再来解决这个问题
06-02 6573
SQL事务 一、事务概念 事务是一种机制、是一种操作序列，它包含了一组数据库操作命令，这组命令要么全部执行，要么全部不执行。因此事务是一个不可分割的工作逻辑单元。在数据库系统上执行并发操作时事务是作为最小的控制单元来使用的。这特别适用于多用户同时操作的数据通信系统。例如：订票、银行、保险公司以及证券交易系统等。 二、事务属性 事务4大属性： 1 原子性(Atomicity):事务是一个完整的操作。 2 一致性（Consistency）：当事务完成时，数据必须处于一致状态。 3 隔...
mongoDB 事务
weixin_43931625的博客
10-06 2460
mongoDB事务 mongoDB 4.0以上开始支持副本集事务，4.2以上版本开始支持分片集群事务 *************************** 使用示例 ********************** application.yml spring: data: mongodb: uri: mongodb://172.18....
Spring事务
chenchenchencl的博客
06-01 2003
spring事务
MySQL事务和锁
m0_54355172的博客
05-04 5775
MySQL的事务和锁：事务四大特性、事务并发的三个问题，InnoDB锁
hibernate事务处理
BillyLu的博客
04-28 1708
hibernate事务处理 hibernate是对JDBC的轻量级对象封装，Hibernate本身是不具备Transaction处理功能的，Hibernate的Transaction实际上是底层的JDBC Transaction的封装，或者是JTA Transaction的封装，下面我们详细的分析： 　　Hibernate可以配置为JDBCTransaction或者是JTATransa
【进阶篇】2.6 Redis 事务详解
热门推荐
日拱一卒无有尽，功不唐捐终入海
07-08 6万+
Redis 事务是一种将多个命令打包在一起执行的机制，可以保证这些命令的原子性，即要么全部执行成功，要么全部执行失败。开启事务在客户端执行 MULTI 命令时，Redis 会将该客户端标记为事务状态。此时，客户端发送的所有命令都会被暂存到一个事务队列中，而不是立即执行。执行事务在客户端执行 EXEC 命令时，Redis 会将客户端状态从事务状态中移除，并依次执行事务队列中的所有命令。在执行期间，Redis 会将事务队列中的命令全部执行完毕，而不会中途中断。
DmJdbcDriver18_DmJdbcDriver18_
09-30
DmJdbcDriver18支持JDBC的多种特性，如批处理、预编译的SQL语句、事务管理等，提升了数据库操作的效率和安全性。此外，它还具备良好的性能优化，如支持大数据量的读写，以及并发处理能力。 在实际应用中，开发者...
微服务架构的分布式事务解决方案,完整31讲-龙果学院
08-29
第18节--TCC型事务方案介绍 第19节--TCC型事务架构设计分析 第20节--TCC型事务框架的源码实现讲解 第21节--TCC型事务方案的项目实战应用介绍 第22节--TCC型事务方案的项目实战应用部署 第23节--TCC型事务方案的...
mysql事务管理操作详解
12-14
首发日期：2018-04-18 什么是事务管理： 可以把一系列要执行的操作称为事务，而事务管理就是管理这些操作要么完全执行，要么完全不执行（很经典的一个例子是：A要给B转钱，首先A的钱减少了，但是突然的数据库断电...
SAP系统管理事务码
04-22
### SAP系统管理事务码详解 在企业资源规划（ERP）领域，SAP系统因其强大的功能和灵活性被广泛采用。为了确保系统的高效运行和维护，SAP提供了大量的事务码供管理员和咨询顾问使用。本文将详细介绍一系列重要的SAP...
【202309】毕马威-中国第六届领先汽车科技50_109页.pdf
07-28
【202309】毕马威-中国第六届领先汽车科技50_109页.pdf
毕业设计—流媒体视频直播服务器-可执行内含文档代码-可执行内含文档代码.zip
07-28
毕业设计—流媒体视频直播服务器-可执行内含文档代码-可执行内含文档代码.zip
【202206】中国汽车潮流观察报告-汽车之家研究院_54页.pdf
07-28
【202206】中国汽车潮流观察报告-汽车之家研究院_54页.pdf
tour-project【程序员VIP专用】.zip
最新发布
07-28
【项目简介】 HTML5+CSS实现雪花旅行社
springboot事务
09-22
Spring Boot 提供了很好的事务管理支持，可以使用 @Transactional 注解来标记我们需要事务处理的方法或类。 使用 @Transactional 注解时，需要注意以下几点： 1. 该注解只能用于 public 方法上。 2. 默认情况下，只有 RuntimeException 以及其子类抛出时才会回滚事务。如果需要对其他异常进行回滚，可以在注解中使用 rollbackFor 属性。 3. 在同一个类中调用被 @Transactional 注解标记的方法，事务不会生效。需要使用 AOP 切面技术来实现事务的传播行为。 示例代码： ``` @Service public class UserService { @Autowired private UserRepository userRepository; @Transactional public void createUser(User user) { userRepository.save(user); } @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) public void updateUser(User user) { userRepository.save(user); if (user.getAge() < 18) { throw new RuntimeException("Age is too young"); } } } ``` 在上面的例子中，createUser 方法和 updateUser 方法都使用了 @Transactional 注解来标记需要进行事务处理的方法。其中 updateUser 方法还使用了 propagation 属性来指定事务的传播行为，rollbackFor 属性来指定需要回滚的异常类型。 需要注意的是，当 updateUser 方法抛出 RuntimeException 异常时，整个事务会回滚，包括 createUser 方法中的操作也会被回滚。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值