spring事务传播机制实例讲解
spring事务传播行为详解
spring事务传播⾏为详解地址：⼀、什么是事务的传播？简单的理解就是多个事务⽅法相互调⽤时,事务如何在这些⽅法间传播。
举个栗⼦，⽅法A是⼀个事务的⽅法，⽅法A执⾏过程中调⽤了⽅法B，那么⽅法B有⽆事务以及⽅法B对事务的要求不同都会对⽅法A的事务具体执⾏造成影响，同时⽅法A的事务对⽅法B的事务执⾏也有影响，这种影响具体是什么就由两个⽅法所定义的事务传播类型所决定。
⼆、Spring事务传播类型枚举Propagation介绍在Spring中对于事务的传播⾏为定义了七种类型分别是：REQUIRED、SUPPORTS、MANDATORY、REQUIRES_NEW、NOT_SUPPORTED、NEVER、NESTED。
在Spring源码中这七种类型被定义为了枚举。
源码在org.springframework.transaction.annotation包下的Propagation，源码中注释很多，对传播⾏为的七种类型的不同含义都有解释，后⽂中锤⼦我也会给⼤家分析，我在这⾥就不贴所有的源码，只把这个类上的注解贴⼀下，翻译⼀下就是：表⽰与TransactionDefinition接⼝相对应的⽤于@Transactional注解的事务传播⾏为的枚举。
也就是说枚举类Propagation是为了结合@Transactional注解使⽤⽽设计的，这个枚举⾥⾯定义的事务传播⾏为类型与TransactionDefinition 中定义的事务传播⾏为类型是对应的，所以在使⽤@Transactional注解时我们就要使⽤Propagation枚举类来指定传播⾏为类型，⽽不直接使⽤TransactionDefinition接⼝⾥定义的属性。
在TransactionDefinition接⼝中定义了Spring事务的⼀些属性，不仅包括事务传播特性类型，还包括了事务的隔离级别类型（事务的隔离级别后⾯⽂章会详细讲解），更多详细信息，⼤家可以打开源码⾃⼰翻译⼀下⾥⾯的注释package org.springframework.transaction.annotation;import org.springframework.transaction.TransactionDefinition;/*** Enumeration that represents transaction propagation behaviors for use* with the {@link Transactional} annotation, corresponding to the* {@link TransactionDefinition} interface.** @author Colin Sampaleanu* @author Juergen Hoeller* @since 1.2*/public enum Propagation {...}三、七种事务传播⾏为详解与⽰例在介绍七种事务传播⾏为前，我们先设计⼀个场景，帮助⼤家理解，场景描述如下现有两个⽅法A和B，⽅法A执⾏会在数据库ATable插⼊⼀条数据，⽅法B执⾏会在数据库BTable插⼊⼀条数据，伪代码如下://将传⼊参数a存⼊ATablepubilc void A(a){insertIntoATable(a);}//将传⼊参数b存⼊BTablepublic void B(b){insertIntoBTable(b);}接下来，我们看看在如下场景下，没有事务，情况会怎样public void testMain(){A(a1); //调⽤A⼊参a1testB(); //调⽤testB}public void testB(){B(b1); //调⽤B⼊参b1throw Exception; //发⽣异常抛出B(b2); //调⽤B⼊参b2}在这⾥要做⼀个重要提⽰：Spring中事务的默认实现使⽤的是AOP，也就是代理的⽅式，如果⼤家在使⽤代码测试时，同⼀个Service类中的⽅法相互调⽤需要使⽤注⼊的对象来调⽤，不要直接使⽤this.⽅法名来调⽤，this.⽅法名调⽤是对象内部⽅法调⽤，不会通过Spring代理，也就是事务不会起作⽤以上伪代码描述的⼀个场景，⽅法testMain和testB都没有事务，执⾏testMain⽅法，那么结果会怎么样呢？相信⼤家都知道了，就是a1数据成功存⼊ATable表，b1数据成功存⼊BTable表，⽽在抛出异常后b2数据存储就不会执⾏，也就是b2数据不会存⼊数据库，这就是没有事务的场景。
Spring事务隔离级别与传播机制详解，spring+mybatis+atomikos实现。。。
Spring事务隔离级别与传播机制详解，spring+mybatis+atomikos实现。
原创说明：本⽂为本⼈原创作品，绝⾮他处转载，转账请注明出处1.事务的定义：事务是指多个操作单元组成的合集，多个单元操作是整体不可分割的，要么都操作不成功，要么都成功。
其必须遵循四个原则（ACID）。
1. 原⼦性（Atomicity）：即事务是不可分割的最⼩⼯作单元，事务内的操作要么全做，要么全不做；2. ⼀致性（Consistency）：在事务执⾏前数据库的数据处于正确的状态，⽽事务执⾏完成后数据库的数据还是应该处于正确的状态，即数据完整性约束没有被破坏；如银⾏转帐，A转帐给B，必须保证A的钱⼀定转给B，⼀定不会出现A的钱转了但B没收到，否则数据库的数据就处于不⼀致（不正确）的状态。
3. 隔离性（Isolation）：并发事务执⾏之间互不影响，在⼀个事务内部的操作对其他事务是不产⽣影响，这需要事务隔离级别来指定隔离性；4. 持久性（Durability）：事务⼀旦执⾏成功，它对数据库的数据的改变必须是永久的，不会因⽐如遇到系统故障或断电造成数据不⼀致或丢失。
2.事务的类型1. 数据库分为本地事务跟全局事务本地事务：普通事务，独⽴⼀个数据库，能保证在该数据库上操作的ACID。
分布式事务：涉及两个或多个数据库源的事务，即跨越多台同类或异类数据库的事务（由每台数据库的本地事务组成的），分布式事务旨在保证这些本地事务的所有操作的ACID，使事务可以跨越多台数据库；2. Java事务类型分为JDBC事务跟JTA事务JDBC事务：即为上⾯说的数据库事务中的本地事务，通过connection对象控制管理。
JTA事务：JTA指Java事务API(Java Transaction API)，是Java EE数据库事务规范， JTA只提供了事务管理接⼝，由应⽤程序服务器⼚商（如WebSphereApplication Server）提供实现，JTA事务⽐JDBC更强⼤，⽀持分布式事务。
Spring事物的传播特性详解
Spring事物的传播特性详解⽬录⼀、事务的传播性⼆、测试前准备2.1、准备好数据库表2.2、初始化spring项⽬2.3、数据库连接信息配置2.4、Service、Dao2.5、测试类2.6、说明三、使⽤其他传播性3.1、REQUIRES_NEW3.2、MANDATORY3.3、SUPPORTS3.4、NOT_SUPPORTED3.5、NEVER3.6、NESTED⼀、事务的传播性研究的是多个事务存在时的处理策略1）REQUIRED：如果存在⼀个事务，则⽀持当前事务，如果当前没有事务，就新建⼀个事务。
这是最常见的选择。
2）SUPPORTS：如果存在⼀个事务，⽀持当前事务，如果当前没有事务，就以⾮事务⽅式执⾏。
3）MANDATORY：如果存在⼀个事务，⽀持当前事务，如果当前没有事务，就抛出异常。
4）REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。
5）NOT_SUPPORTED：以⾮事务⽅式执⾏操作，如果当前存在事务，就把当前事务挂起。
6）NEVER：以⾮事务⽅式执⾏，如果当前存在事务，则抛出异常。
7）NESTED：⽀持当前事务，新增Savepoint点，与当前事务同步提交或回滚。
⼆、测试前准备2.1、准备好数据库表数据库transaction_propagation账号表account、书本表book、库存表book_stockSET NAMES utf8mb4;SET FOREIGN_KEY_CHECKS = 0;-- ------------------------------ Table structure for account-- ----------------------------DROP TABLE IF EXISTS `account`;CREATE TABLE `account` (`user_id` int(11) NOT NULL AUTO_INCREMENT,`user_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,`balance` double(11, 2) UNSIGNED NULL DEFAULT NULL,PRIMARY KEY (`user_id`) USING BTREE) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic STORAGE MEMORY; -- ------------------------------ Records of account-- ----------------------------INSERT INTO `account` VALUES (1, 'Albert', 100.00);-- ------------------------------ Table structure for book-- ----------------------------DROP TABLE IF EXISTS `book`;CREATE TABLE `book` (`book_id` int(11) NOT NULL AUTO_INCREMENT,`name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,`price` double(11, 2) UNSIGNED NULL DEFAULT NULL,PRIMARY KEY (`book_id`) USING BTREE) ENGINE = InnoDB AUTO_INCREMENT = 1003 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic; -- ------------------------------ Records of book-- ----------------------------INSERT INTO `book` VALUES (1001, '基础数据结构', 60.00);INSERT INTO `book` VALUES (1002, '数据库设计', 50.00);-- ------------------------------ Table structure for book_stock-- ----------------------------DROP TABLE IF EXISTS `book_stock`;CREATE TABLE `book_stock` (`book_id` int(11) NOT NULL AUTO_INCREMENT,`stock` int(11) UNSIGNED NULL DEFAULT NULL,PRIMARY KEY (`book_id`) USING BTREE) ENGINE = InnoDB AUTO_INCREMENT = 1003 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic; -- ------------------------------ Records of book_stock-- ----------------------------INSERT INTO `book_stock` VALUES (1001, 100);INSERT INTO `book_stock` VALUES (1002, 100);SET FOREIGN_KEY_CHECKS = 1;2.2、初始化spring项⽬导⼊⼀些基本依赖包：jdbc、mysql驱动包、测试模块;<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency>2.3、数据库连接信息配置#jdbcspring:datasource:driver-class-name: com.mysql.cj.jdbc.Driverurl: jdbc:mysql://localhost/transaction_propagation?useUnicode=true&characterEncoding=utf-8username: rootpassword: 1234562.4、Service、Dao这⾥只使⽤测试调⽤，省略controller以及entity等层构；1、⾸先Dao类，编写⼀个购买的简单操作：查询单价、更新库存、更新账户余额；@Repositorypublic class BookShopDao {@Autowiredprivate JdbcTemplate jdbcTemplate = new JdbcTemplate();public double getPriceById(Integer bookId) {String sql = "SELECT price FROM BOOK WHERE book_id = ?";double price = jdbcTemplate.query(sql, new PreparedStatementSetter() {@Overridepublic void setValues(PreparedStatement preparedStatement) throws SQLException {preparedStatement.setInt(1, bookId);}}, new ResultSetExtractor<Double>() {@Overridepublic Double extractData(ResultSet resultSet) throws SQLException, DataAccessException {double p = 0.0;while (resultSet.next()) {p = resultSet.getDouble("price");}return p;}});return price;}public void updateBookStock(Integer bookId, int num) {String sql = "UPDATE book_stock SET stock = stock - ? WHERE book_id = ?";jdbcTemplate.update(sql, new PreparedStatementSetter() {@Overridepublic void setValues(PreparedStatement preparedStatement) throws SQLException {preparedStatement.setInt(1, num);preparedStatement.setInt(2, bookId);}});}public void updateBalance(Integer userId, double balance) {//修改⾦额String sql = "UPDATE account SET balance = balance - ? WHERE user_id = ?";jdbcTemplate.update(sql, new PreparedStatementSetter() {@Overridepublic void setValues(PreparedStatement preparedStatement) throws SQLException {preparedStatement.setDouble(1, balance);preparedStatement.setInt(2, userId);}});}}2、研究事务传播学性其实就是研究两个以上的事务在嵌套时的应⽤⽅式，所以这⾥需要写两个Service进⾏嵌套调⽤；接⼝类此处省略BookShopServiceImpl 中的purchase⽤@Transactional是指⼀个购买单进来必须保证（1、2、3）的原⼦性；@Servicepublic class BookShopServiceImpl implements BookShopService {@Autowiredprivate BookShopDao bookShopDao;@Transactional@Overridepublic void purchase(Integer userId,Integer bookId,int num){//1、获取要购买的图书价格double price = bookShopDao.getPriceById(bookId);//2、更新图书库存bookShopDao.updateBookStock(bookId,num);//3、更新⽤户余额bookShopDao.updateBalance(userId,price*num);}}CashierServiceImpl 中buy⽅法中的@Transactional是指⼀个订单中出现多个购买单进来必须保证的原⼦性；因为⼀个订单可能包含⼏种商品的购买。
Spring中的事务管理实例详解
Spring中的事务管理实例详解本文实例讲述了Spring中的事务管理。
分享给大家供大家参考。
具体分析如下：事务简介：事务管理是企业级应用程序开发中必不可少的技术，用来确保数据的完整性和一致性事务就是一系列的动作，它们被当作一个单独的工作单元。
这些动作要么全部完成，要么全部不起作用事务的四个关键属性(ACID)①原子性(atomicity):事务室一个原子操作，有一系列动作组成。
事务的原子性确保动作要么全部完成，要么完全不起作用②一致性(consistency):一旦所有事务动作完成，事务就被提交。
数据和资源就处于一种满足业务规则的一致性状态中③隔离性(isolation):可能有许多事务会同时处理相同的数据，因此每个事物都应该与其他事务隔离开来，防止数据损坏④持久性(durability):一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响。
通常情况下，事务的结果被写到持久化存储器中Spring中的事务管理作为企业级应用程序框架，Spring在不同的事务管理API之上定义了一个抽象层。
而应用程序开发人员不必了解底层的事务管理API，就可以使用Spring的事务管理机制。
Spring既支持编程式事务管理，也支持声明式的事务管理编程式事务管理：将事务管理代码嵌入到业务方法中来控制事务的提交和回滚，在编程式事务中，必须在每个业务操作中包含额外的事务管理代码声明式事务管理：大多数情况下比编程式事务管理更好用。
它将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
事务管理作为一种横切关注点，可以通过AOP方法模块化。
Spring通过Spring AOP框架支持声明式事务管理。
Spring事务的传播属性：当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。
例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。
事务的传播行为可以由传播属性指定。
Spring定义了7种传播行为：Spring支持的事务传播行为传播行为含义PROPAGATION_MANDATORY 表示该方法必须在事务中运行，如果当前事务不存在，则会抛出一个异常PROPAGATION_NESTED 表示如果当前已经存在一个事务，那么该方法将会在嵌套事务中运行。
事务的传播机制
事务的传播机制1.什么是事务： 事务是程序中⼀系列严密的操作，所有操作执⾏必须成功完成，否则在每个操作所做的更改将会被撤销，这也是事务的原⼦性（要么成功，要么失败）。
数据库向⽤户提供保存当前程序状态的⽅法，叫事务提交（commit）；当事务执⾏过程中，使数据库忽略当前的状态并回到前⾯保存的状态的⽅法叫事务回滚（rollback）2.事务的传播机制 以spring的事务传播机制为例⼦： Spring事务机制主要包括声明式事务和编程式事务，此处侧重讲解声明式事务，编程式事务在实际开发中得不到⼴泛使⽤，仅供学习参考。
Spring声明式事务让我们从复杂的事务处理中得到解脱。
使得我们再也⽆需要去处理获得连接、关闭连接、事务提交和回滚等这些操作。
再也⽆需要我们在与事务相关的⽅法中处理⼤量的try…catch…finally代码。
我们在使⽤Spring声明式事务时，有⼀个⾮常重要的概念就是事务属性。
事务属性通常由事务的传播⾏为，事务的隔离级别，事务的超时值和事务只读标志组成。
我们在进⾏事务划分时，需要进⾏事务定义，也就是配置事务的属性。
spring在TransactionDefinition接⼝中定义了七个事务传播⾏为：propagation_requierd：如果当前没有事务，就新建⼀个事务，如果已存在⼀个事务中，加⼊到这个事务中，这是最常见的选择。
propagation_supports：⽀持当前事务，如果没有当前事务，就以⾮事务⽅法执⾏。
propagation_mandatory：使⽤当前事务，如果没有当前事务，就抛出异常。
propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。
propagation_not_supported：以⾮事务⽅式执⾏操作，如果当前存在事务，就把当前事务挂起。
propagation_never：以⾮事务⽅式执⾏操作，如果当前事务存在则抛出异常。
Spring事务管理中的七种传播机制及示例讲解
Spring事务管理中的七种传播机制及⽰例讲解课程分组的时候分到了Spring传播机制的内容，研究整理了⼀下。
⼀、事务传播⾏为和事务传播机制事务传播⾏为：⼀般发⽣在事务嵌套的场景中，⽐如⼀个有事务的⽅法⾥⾯调⽤了另外⼀个有事务的⽅法这个时候就会产⽣事务边界控制的问题，即两个⽅法是各⾃作为独⽴的事务提交还是内层的事务合并到外层的事务⼀起提交Spring规定了七⼤传播机制来解决边界控制的问题。
⼆、七⼤传播机制传播机制说明PROPAGATION_REQUIRED如果当前没有事务，就新建⼀个事务，如果已经存在⼀个事务中，加⼊到这个事务中。
这是最常见的选择。
PROPAGATION_SUPPORTS⽀持当前事务，如果当前没有事务，就以⾮事务⽅式执⾏。
PROPAGATION_MANDATORY使⽤当前的事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED以⾮事务⽅式执⾏操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER以⾮事务⽅式执⾏，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED如果当前存在事务，则在嵌套事务内执⾏。
如果当前没有事务，则执⾏与PROPAGATION_REQUIRED类似的操作。
三、对⽐理解及举例第⼀组传播机制通俗解释PROPAGATION_NEVER强制以⾮事务的⽅式运⾏，外层有事务，将会产⽣异常PROPAGATION_MANDATORY强制加⼊外层事务，外层没有事务，则会产⽣异常举例：在充值处理这个业务中，调⽤了扣款和订单⽣成两个⽅法，充值处理业务需要扣款操作和订单⽣成操作同成功或者失败，所以需要把这两个⽅法放到同⼀个事务中运⾏；所以可以指定这两个⽅法的传播机制为MANDATORY，这样它们就会都加⼊到外层事务，处于⼀个事务中，可以保证同成功或失败。
「聊一聊Spring」Spring的事务传播行为
「聊⼀聊Spring 」Spring 的事务传播⾏为Spring中的事务传播⾏为事务管理并⾮ Spring ⾸创，Spring 也借鉴了很多其他的框架，然后加以统⼀。
在 Spring 中，我们经常使⽤声明式事务，在⽅法或类上添加 Spring 的 @Transtional 注解，在这个注解中我们可以指定事务传播⾏为，这个注解也参考了 EJB 的javax.ejb.TransactionAttribute 以及 JTA 的 javax.transaction.Transactional，这⾥先通过对⽐认识⼀下这三者的异同。
从上⾯的表格中可以看到，在 Spring 的 @Transactional 中都可以找到 EJB、JTA 注解中相应的参数。
事实上，Spring 也对 EJB 的 @TransactionAttribute 注解及 JTA 的@Transactional 加以了⽀持，在 Spring 中这三个注解都可以使⽤。
现在将重点转向事务传播⾏为，上⾯的三个注解都有事务传播⾏为，那么这三者的事务传播⾏为⼜有何异同呢？有没有发现⼀些问题？Spring 中的事务定义与 EJB、JTA 基本⼀致，它们名称不仅相同，事实上语义和实现也相似，⽽且 Spring 还增加了⼀个 NESTED 类型的事务传播⾏为。
事务传播⾏为主要是控制新⽅法执⾏时是否使⽤事务，如何处理线程中以存在的事务。
下⾯是对 Spring 中的这7中事务传播⾏为的描述：REQUIRED ：默认的事务传播⾏为；需要事务：存在事务则使⽤已存在事务，否则创建新的事务；SUPPORTS ：⽀持已存在事务：存在事务则使⽤已存在事务，否则以⾮事务⽅式运⾏；MANDATORY ：强制使⽤事务：存在事务则使⽤已存在事务，否则抛出异常；REQUIRES_NEW ：需要新事务：存在事务则挂起已存在事务，否则创建新事务；NOT_SUPPORTED ：不⽀持事务：存在事务则挂起已存在事务，否则以⾮事务⽅式运⾏；NEVER ：从不使⽤事务：存在事务则抛出异常，否则以⾮事务⽅式运⾏；NESTED ：嵌套事务：存在事务则使创建保存点使⽤嵌套的事务，否则创建新的事务。
spring事务配置方式以及事务的传播性、隔离级别
spring事务配置⽅式以及事务的传播性、隔离级别在前⾯的⽂章中总结了事务的5中配置⽅式，但是很多⽅式都不⽤⽽且当时的配置使⽤的所有参数都是默认的参数，这篇⽂章就看常⽤的两种事务配置⽅式并信息配置事务的传播性、隔离级别、以及超时等问题，废话不说下⾯就来看看！⼀、注解式事务1、注解式事务在平时的开发中使⽤的挺多，⼯作的两个公司中看到很多项⽬使⽤了这种⽅式，下⾯看看具体的配置demo。
2、事务配置实例（1）、spring+mybatis 事务配置[html]1. <!-- 定义事务管理器 -->2. <bean id="transactionManager"3. class="org.springframework.jdbc.datasource.DataSourceTransactionManager">4. <property name="dataSource" ref="dataSource" />5. </bean>6. <!--使⽤注释事务 -->7. <tx:annotation-driven transaction-manager="transactionManager" />（2）、spring+ 事务配置[html]1. <!-- 事务管理器配置,单数据源事务 -->2. <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">3. <property name="sessionFactory" ref="sessionFactory" />4. </bean>5.6. <!-- 使⽤annotation定义事务 -->7. <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />看到上⾯的这两段配置⽂件是不是很熟悉，对的这就是我们平时看到的事务的配置，在spring的配置中配置数据源即dataSource、事务管理器，事务管理器使⽤不同的orm框架事务管理器类就不同，⽐如这⾥使⽤的是mybatis 所以是[html]1. org.springframework.jdbc.datasource.DataSourceTransactionManager如果使⽤hibernate 则事务管理器类为[html]1. org.springframework.orm.hibernate3.HibernateTransactionManager这是使⽤注解⽅式时要配置的，代码中的具体的注解以及事务的传播性、隔离级别⼀般在service 层中配置下⾯看看3、@Transactional（1）、这⾥说明⼀下，有的把这个注解放在类名称上⾯了，这样你配置的这个@Transactional 对这个类中的所有public⽅法都起作⽤（2）、@Transactional ⽅法⽅法名上，只对这个⽅法有作⽤，同样必须是public的⽅法⽐如这⾥就对这个⽅法定义了⼀个事务同时设置了很多属性：[java]1. @Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class,timeout=1,isolation=Isolation.DEFAULT)2. public void saveUser(Map<String, String> map) throws Exception {3. System.out.println("⽅法开始");4. for (int i = 0; i < 500000; i++) {5. System.out.println("*");6. }7. System.out.println("进⼊保存");8. userDao.saveUser(map);9. System.out.println("退出保存");10. }4、事物配置中有哪些属性可以配置（1）、事务的传播性：@Transactional(propagation=Propagation.REQUIRED)如果有事务, 那么加⼊事务, 没有的话新建⼀个(默认情况下)（2）、事务的超时性：@Transactional(timeout=30) //默认是30秒注意这⾥说的是事务的超时性⽽不是Connection的超时性，这两个是有区别的（3）、事务的隔离级别：@Transactional(isolation = Isolation.READ_UNCOMMITTED)读取未提交数据(会出现脏读, 不可重复读) 基本不使⽤（4）、回滚：指定单⼀异常类：@Transactional(rollbackFor=RuntimeException.class)指定多个异常类：@Transactional(rollbackFor={RuntimeException.class, Exception.class})该属性⽤于设置需要进⾏回滚的异常类数组，当⽅法中抛出指定异常数组中的异常时，则进⾏事务回滚。