一、什么是事务
事务的概念
事务是访问数据库的一个操作序列，数据库应用系统通过事务集来完成对数据库的存取。事务的正确执行使得数据库从一种状态转换成另一种状态。
事务必须服从ACID原则。ACID是原子性（atomicity）、一致性（consistency）、隔离性（isolation）和持久性（durability）的缩写事务必须服从ISO/IEC所制定的ACID原则。ACID是原子性（atomicity）、一致性（consistency）、隔离性（isolation）和持久性（durability）的缩写。
事务的特性
事务的原子性：表示事务执行过程中的任何失败都将导致事务所做的任何修改失效。
事务的一致性：表示当事务执行失败时，所有被该事务影响的数据都应该恢复到事务执行前的状态。
事务的隔离性(重点)：表示在事务执行过程中对数据的修改，在事务提交之前对其他事务不可见。
事务的持久性：表示已提交的数据在事务执行失败时，数据的状态都应该正确。
Spring事务的本质其实就是数据库对事务的支持，没有数据库的事务支持，spring是无法提供事务功能的。
二、为什么要使用事务
事务是为解决数据安全操作提出的，事务控制实际上就是控制数据的安全访问。
案例说明
举例子说明：银行转账。现在A账户有100元，B账户有100元，现在A账户转账给B账户50元，正常情况下执行的步骤应该是
动作一：A账户减去50元
动作二：B账户加上50元
只有当两个动作都成功，才能保证转账的成功。那如果这两个动作中只有一个成功了，那就会造成两种情况：
情况一：动作一成功，动作二失败，直接导致A账户变成了50元，而B账户还是100元，此时总钱数变少了
情况二：动作一失败，动作二成功，导致A账户还是100，B账户变成了150元，此时总钱数变多了
不管是以上哪中情况，都会造成数据的安全性问题。
解决方式
于是事务在此时就发挥了作用。事务的原子性，保证了动作一和动作二要么全部成功，要么全部失败，避免了一半一半的问题出现，从而也保证了数据的安全性。
三、怎么使用事务
传统方式
既然spring事务本质是数据库的事务，那就是在使用JDBC连接的时候会开启事务。
- 获取连接 Connection con = DriverManager.getConnection();
- 开启事务con.setAutoCommit(true/false);
- 执行CRUD
- 提交事务/回滚事务 con.commit() / con.rollback();
- 关闭连接 conn.close();
事务模板
xml文件的配置引入JDBC数据库事务
<!--引入本地数据库配置-->
<context:property-placeholder location="classpath:jdbc.properties" />
<!--添加数据源-->
<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource"
<!-- 属性注入 -->
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql:///springjdbc" />
<property name="username" value="root" />
<property name="password" value="******" />
</bean>
<!--jdbcTemplate-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource" />
</bean>
<!--jdbc事务管理器-->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" p:dataSource-ref="dataSource">
</bean>
<!--transactionTemplate事务模板-->
<!--在此处以及设置所有方法为 只读 -->
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
<property name="transactionManager" ref="dataSourceTransactionManager" />
</bean>
代码编写
public void save() {
/**
* 说明:
* 如果你的方法需要返回值请使用这个类
* new TransactionCallback<Object>()
*
* 如果你的方法不需要返回值那么使用下面这个例子就可以了
* new TransactionCallbackWithoutResult()
*/
transactionTemplate.execute(new TransactionCallbackWithoutResult(){
@Override
protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
// 执行CRUD操作
}
});
}
声明式事务（@Transactional）
利用spring自带的@Transactional 注解来实现事务，并按照事务模板的形式配置xml文件。
<tx:annotation-driven transaction-manager="transactionManager"/>
如果是springboot项目，需要在使用前在启动类上加上@EnableTransactionManagement 注解开启事务的功能。
@SpringBootApplication
//开启事务
@EnableTransactionManagement
public class TransactionalApplication {
public static void main(String[] args) {
SpringApplication.run(TransactionalApplication.class, args);
}
代码编写
@Transactional(propagation = Propagation.REQUIRED)
public boolean transfer(Long fromId， Long toId， double amount) {
return bankDao.transfer(fromId， toId， amount);
}
四、事务的传播属性
propagation（传播属性）
Spring中的Propagation这个类定义了
七种传播属性：
保证多个操作在同一个事务中
PROPAGATION_REQUIRED: 默认值, 如果A中有事务, 使用A中的事务, 如果A没有, 创建一个新的事务, 将操作包含进来。
PROPAGATION_SUPPORTS: 支持事务, 如果A中有事务, 使用A中的事务。如果A没有事务, 不使用事务。
PROPAGATION_MANDATORY: 如果A中有事务, 使用A中的事务。如果A没有事务, 抛出异常。
保证多个操作不在同一个事务中
PROPAGATION_REQUIRES_NEW: 如果A中有事务, 将A的事务挂起(暂停), 创建新事务, 只包含自身操作。如果A中没有事务, 创建一个新事务, 包含自身操作。
PROPAGATION_NOT_SUPPORTED: 如果A中有事务, 将A的事务挂起。不使用事务管理。
PROPAGATION_NEVER: 如果A中有事务, 报异常。
嵌套式事务
PROPAGATION_NESTED: 嵌套事务, 如果A中有事务, 按照A的事务执行, 执行完成后，设置一个保存点, 执行B中的操作, 如果没有异常, 执行通过, 如果有异常, 可以选择回滚到最初始位置, 也可以回滚到保存点。
public enum Propagation {
REQUIRED(0),
SUPPORTS(1),
MANDATORY(2),
REQUIRES_NEW(3),
NOT_SUPPORTED(4),
NEVER(5),
NESTED(6);
private final int value;
private Propagation(int value) {
this.value = value;
}
public int value() {
return this.value;
}
五、声明式事务（@Transactional）失效问题
1、@Transactional 应用在非 public 修饰的方法上
之所以会失效是因为在Spring AOP 代理时，如上图所示 TransactionInterceptor （事务拦截器）在目标方法执行前后进行拦截，DynamicAdvisedInterceptor（CglibAopProxy 的内部类）的 intercept 方法或 JdkDynamicAopProxy 的 invoke 方法会间接调用 AbstractFallbackTransactionAttributeSource的 computeTransactionAttribute
方法，获取Transactional 注解的事务配置信息。
此方法会检查目标方法的修饰符是否为 public，不是 public则不会获取@Transactional 的属性配置信息。
注意：protected、private修饰的方法上使用@Transactional注解，虽然事务无效，但不会有任何报错，这是我们很容犯错的一点。
2、@Transactional 注解属性 propagation 设置错误
这种失效是由于配置错误，若是错误的配置以下三种 propagation，事务将不会发生回滚。
TransactionDefinition.PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。
3、@Transactional 注解属性 rollbackFor 设置错误
rollbackFor 可以指定能够触发事务回滚的异常类型。Spring默认抛出了未检查unchecked异常（继承自 RuntimeException 的异常）或者 Error才回滚事务；其他异常不会触发回滚事务。如果在事务中抛出其他类型的异常，但却期望 Spring 能够回滚事务，就需要指定rollbackFor属性。
4、同一个类中方法调用，导致@Transactional失效
public class Demo {
// @Autowired
// private Demo demo; ---------------重点1
/**
* 方法A
*/
public void methodA(){
this.methodB();
// demo.methodB(); ---------------重点2
}
/**
* 带事务的B方法
*/
@Transactional(rollbackFor = Exception.class )
public void methodB(){
try{
System.out.println("这里写增删改查的方法");
}catch(Exception e){
e.printStackTrace();
}
}
}
开发中避免不了会对同一个类里面的方法调用，比如有一个类Test，它的一个方法A，A再调用本类的方法B（不论方法B是用public还是private修饰），但方法A没有声明注解事务，而B方法有。则外部调用方法A之后，方法B的事务是不会起作用的。这也是经常犯错误的一个地方。
那为啥会出现这种情况？其实这还是由于使用Spring AOP代理造成的，因为只有当事务方法被当前类以外的代码调用时，才会由Spring生成的代理对象来管理。
代码中重点1和重点2这种方式就可以解决这个事务失效的问题。
5、异常被捕获导致@Transactional失效
这种情况是最常见的一种@Transactional注解失效场景，
public class DemoA {
@Autowired
private DemoB demob;
/**
* 方法A
*/
public void methodA(){
demob.methodB();
}
}
public class DemoB {
/**
* 带事务的B方法
*/
@Transactional(rollbackFor = Exception.class )
public void methodB(){
try{
System.out.println("这里写增删改查的方法");
}catch(Exception e){
e.printStackTrace();
// throw new RunTimeException(); 捕获异常后再抛出就可以了。
}
}
}
如果B方法内部抛了异常，而A方法此时try catch了B方法的异常，那这个事务还能正常回滚吗？
答案：不能！
会抛出异常：
org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only
因为当ServiceB中抛出了一个异常以后，ServiceB标识当前事务需要rollback。但是ServiceA中由于你手动的捕获这个异常并进行处理，ServiceA认为当前事务应该正常commit。此时就出现了前后不一致，也就是因为这样，抛出了前面的UnexpectedRollbackException异常。
spring的事务是在调用业务方法之前开始的，业务方法执行完毕之后才执行commit or rollback，事务是否执行取决于是否抛出runtime异常。如果抛出runtime exception 并在你的业务方法中没有catch到的话，事务会回滚。
在业务方法中一般不需要catch异常，如果非要catch一定要抛出throw new RuntimeException()，或者注解中指定抛异常类@Transactional(rollbackFor=Exception.class)，否则会导致事务失效，数据commit造成数据不一致，所以有些时候try catch反倒会画蛇添足。
6、数据库引擎不支持事务
这种情况出现的概率并不高，事务能否生效数据库引擎是否支持事务是关键。常用的MySQL数据库默认使用支持事务的innodb引擎。一旦数据库引擎切换成不支持事务的myisam，那事务就从根本上失效了。
