spring的事务控制
1.事务介绍
(1)特性:ACID
Atomicity（原子性）:事务中的所有操作要么全做要么全不做
Consistency（一致性）:事务执行的结果使得数据库从一个一致性状态转移到另一个一致性状态
Isolation（隔离性）:一个事务的执行不受其他事务的干扰
Durability（永久性）:一个事务一旦提交，对数据库的影响是永久性的
(2)事务并发问题
（3） 隔离级别
关于隔离级别与存在的问题如下:
2. Spring封装了事务管理操作
1.事务操作
打开事务 回滚事务 提交事务
2.事务操作对象
因为在不同平台,操作事务的代码各不相同.spring提供了一个接口
（1）PlatformTransactionManager 接口
（2）spring管理事务的属性介绍
事务隔离级别: 1读未提交
2 读已提交
4 可重复读
8 串行化
是否只读 true 只读
False 可操作
事务的传播行为
3.Spring管理事务的三种方式
编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。
声明式事务管理建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式)，便可以将事务规则应用到业务逻辑中。
显然声明式事务管理要优于编程式事务管理，这正是spring倡导的非侵入式的开发方式。声明式事务管理使业务代码不受污染，一个普通的POJO对象，只要加上注解就可以获得完全的事务支持。和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法等等。
声明式事务管理也有两种常用的方式，一种是基于tx和aop名字空间的xml配置文件，另一种就是基于@Transactional注解。显然基于注解的方式更简单易用，更清爽。
- spring事务特性
spring所有的事务管理策略类都继承自org.springframework.transaction.PlatformTransactionManager接口
其中TransactionDefinition接口定义以下特性：
事务隔离级别
隔离级别是指若干个并发的事务之间的隔离程度。TransactionDefinition 接口中定义了五个表示隔离级别的常量：
- TransactionDefinition.ISOLATION_DEFAULT：这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是TransactionDefinition.ISOLATION_READ_COMMITTED。
- TransactionDefinition.ISOLATION_READ_UNCOMMITTED：该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读，不可重复读和幻读，因此很少使用该隔离级别。比如PostgreSQL实际上并没有此级别。
- TransactionDefinition.ISOLATION_READ_COMMITTED：该隔离级别表示一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读，这也是大多数情况下的推荐值。
- TransactionDefinition.ISOLATION_REPEATABLE_READ：该隔离级别表示一个事务在整个过程中可以多次重复执行某个查询，并且每次返回的记录都相同。该级别可以防止脏读和不可重复读。
- TransactionDefinition.ISOLATION_SERIALIZABLE：所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。
事务传播行为
所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。在TransactionDefinition定义中包括了如下几个表示传播行为的常量：
- TransactionDefinition.PROPAGATION_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认值。
- TransactionDefinition.PROPAGATION_REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。
- TransactionDefinition.PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
- TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
- TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。
- TransactionDefinition.PROPAGATION_MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
- TransactionDefinition.PROPAGATION_NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。
事务超时
所谓事务超时，就是指一个事务所允许执行的最长时间，如果超过该时间限制但事务还没有完成，则自动回滚事务。在 TransactionDefinition 中以 int 的值来表示超时时间，其单位是秒。
默认设置为底层事务系统的超时值，如果底层数据库事务系统没有设置超时值，那么就是none，没有超时限制。
事务只读属性
“只读事务”并不是一个强制选项，它只是一个“暗示”，提示数据库驱动程序和数据库系统，这个事务并不包含更改数据的操作，那么JDBC驱动程序和数据库就有可能根据这种情况对该事务进行一些特定的优化，比方说不安排相应的数据库锁，以减轻事务对数据库的压力，毕竟事务也是要消耗数据库的资源的。
但是你非要在“只读事务”里面修改数据，也并非不可以，只不过对于数据一致性的保护不像“读写事务”那样保险而已。
因此，“只读事务”仅仅是一个性能优化的推荐配置而已，并非强制你要这样做不可
-----------------------编程式事务(不推荐这种)-------------------------------
1.将核心事务管理器配置到spring容器
2.配置TransactionTemplate模板
3.将事务模板注入Service(也可以使用注解方式自动注入)
4.在Service中调用模板
AOP实现事务的两种方式:基于XML与基于注解方式实现：
--------------------基于xml配置方式的事务管理(一次性的配置推荐使用这种)---------------------
1. XML配置(aop)
1. 导包
Aop aspect aop联盟 weaver(织入包)
2.导入新的约束(tx)
beans: 最基本
context:读取properties配置
aop:配置aop
tx:配置事务通知
3.配置通知
4.配置将通知织入目标对象
注意: 可以将通知织入多个目标对象，也就是可以对多个不同路径的serviceImpl进行事务控制。配置方式是再开一个aop进行配置
5.例如:
包结构:
配置事务的代码
<!-- 事务模板对象，依赖于事务核心管理器 --> <bean name="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate"> <property name="transactionManager" ref="transactionManager"></property> </bean> <!-- ················开始使用XML管理事务························ --> <!-- 配置事务通知（无论哪种方式都要用到事务的核心管理器）--> <tx:advice transaction-manager="transactionManager" id="firstTx"> <tx:attributes> <!--以方法为单位，指定方法应用事务什么属性 isolation:隔离级别 read-only:只读属性 propagation:传播行为 --> <!-- 企业中运用通配符命名规则。两套增删改查(8种) --> <tx:method name="save*" isolation="DEFAULT" read-only="false" propagation="REQUIRED"/> <tx:method name="persist*" isolation="DEFAULT" read-only="false" propagation="REQUIRED"/> <tx:method name="delete*" isolation="DEFAULT" read-only="false" propagation="REQUIRED"/> <tx:method name="remove*" isolation="DEFAULT" read-only="false" propagation="REQUIRED"/> <tx:method name="update*" isolation="DEFAULT" read-only="false" propagation="REQUIRED"/> <tx:method name="modify*" isolation="DEFAULT" read-only="false" propagation="REQUIRED"/> <tx:method name="get*" isolation="DEFAULT" read-only="true" propagation="REQUIRED"/> <tx:method name="find*" isolation="DEFAULT" read-only="true" propagation="REQUIRED"/> </tx:attributes> </tx:advice> <!-- 配置织入 --> <aop:config> <!-- 配置切点表达式 --> <aop:pointcut expression="execution(* cn.xm.exam.service.*.*.*ServiceImpl.*(..))" id="texPc"/> <!-- 配置切面:切点+通知 advice-ref：通知名称 pointcut-ref：切点名称 --> <aop:advisor advice-ref="firstTx" pointcut-ref="texPc"/> </aop:config>
6. 测试一个事物是否配置成功的方法:
在配置好的事务包下建立一个规定名字的类。例如:(spring管理对象且方法public)
package danger.service.impl.queryView;
import javax.annotation.Resource;
import org.junit.Test;
import org.springframework.stereotype.Controller;
import danger.mapper.dangerManage.DangerMapper;
@Controller
public class TestTranServiceImpl {
@Resource
private DangerMapper dangerMapper;
public void deleteTestTrans() {
dangerMapper.deleteByPrimaryKey(76);
int i=1/0;
dangerMapper.deleteByPrimaryKey(75);
}
}
建立一个spring+junit测试类测试事务
package danger.service.impl.queryView;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring/applicationContext-*.xml")
public class TestTrans {
@Autowired
private TestTranServiceImpl testTranServiceImpl;
@Test
public void test(){
testTranServiceImpl.deleteTestTrans();
}
}
上面测试虽然报错，但是数据库id为76的也没有删除。如果将方法名字改为不带事务的会删除掉id为76的，然后报错。
--------------------基于注解方式的事务管理----------------------------------
1.导包:
aop
aspect
aop联盟
weaving织入包
2.导入新的约束(tx)
beans: 最基本
context:读取properties配置
aop:配置aop
tx:配置事务通知
3.开启注解管理事务
或者:
<!-- 5.开启注解管理aop事务 --> <tx:annotation-driven transaction-manager="transactionManager"/>
4.使用注解
用法:可以在方法或者类上加注解，加载方法上的优先级高于加在类上的优先级。
@Transactional 可以作用于接口、接口方法、类以及类方法上。当作用于类上时，该类的所有 public 方法将都具有该类型的事务属性，同时，我们也可以在方法级别使用该标注来覆盖类级别的定义。
虽然 @Transactional 注解可以作用于接口、接口方法、类以及类方法上，但是 Spring 建议不要在接口或者接口方法上使用该注解，因为这只有在使用基于接口的代理时它才会生效。另外， @Transactional 注解应该只被应用到 public 方法上，这是由 Spring AOP 的本质决定的。如果你在 protected、private 或者默认可见性的方法上使用 @Transactional 注解，这将被忽略，也不会抛出任何异常。
默认情况下，只有来自外部的方法调用才会被AOP代理捕获，也就是，类内部方法调用本类内部的其他方法并不会引起事务行为，即使被调用方法使用@Transactional注解进行修饰。
查看Transactional注解发现其有许多默认值:
package org.springframework.transaction.annotation; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Inherited; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; import org.springframework.core.annotation.AliasFor; import org.springframework.transaction.TransactionDefinition; @Target({ElementType.METHOD, ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented public @interface Transactional { @AliasFor("transactionManager") String value() default ""; @AliasFor("value") String transactionManager() default ""; Propagation propagation() default Propagation.REQUIRED; Isolation isolation() default Isolation.DEFAULT; int timeout() default TransactionDefinition.TIMEOUT_DEFAULT; boolean readOnly() default false; Class<? extends Throwable>[] rollbackFor() default {}; String[] rollbackForClassName() default {}; Class<? extends Throwable>[] noRollbackFor() default {}; String[] noRollbackForClassName() default {}; }
只读属性为false，传播行为是TransactionDefinition.PROPAGATION_REQUIRED，隔离级别是TransactionDefinition.ISOLATION_DEFAULT：这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是TransactionDefinition.ISOLATION_READ_COMMITTED。所以注解的默认值足够我们项目中使用，我们只用在类前面打上注解就可以了。
例如mysql查看事务级别:
mysql> select @@tx_isolation\G *************************** 1. row *************************** @@tx_isolation: REPEATABLE-READ 1 row in set (0.00 sec)
@Transactional属性
| 属性 | 类型 | 描述 |
|---|---|---|
| value | String | 可选的限定描述符，指定使用的事务管理器 |
| propagation | enum: Propagation | 可选的事务传播行为设置 |
| isolation | enum: Isolation | 可选的事务隔离级别设置 |
| readOnly | boolean | 读写或只读事务，默认读写 |
| timeout | int (in seconds granularity) | 事务超时时间设置 |
| rollbackFor | Class对象数组，必须继承自Throwable | 导致事务回滚的异常类数组 |
| rollbackForClassName | 类名数组，必须继承自Throwable | 导致事务回滚的异常类名字数组 |
| noRollbackFor | Class对象数组，必须继承自Throwable | 不会导致事务回滚的异常类数组 |
| noRollbackForClassName | 类名数组，必须继承自Throwable | 不会导致事务回滚的异常类名字数组 |
查看Isolation源码(枚举类型)
package org.springframework.transaction.annotation; public enum Isolation { DEFAULT(-1), READ_UNCOMMITTED(1), READ_COMMITTED(2), REPEATABLE_READ(4), SERIALIZABLE(8); private final int value; private Isolation(int value) { this.value = value; } public int value() { return this.value; } }
到此，spring事务管理的三中方式基本完成，下面是在事务测试中的问题。
注意:
最近在项目的时候碰到pring事务不起作用的情况，后来解决了，这里我汇总下：
1、首先使用如下代码 确认你的bean 是代理对象吗？
必须是Spring定义（通过XML或注解定义都可以）的Bean才接受事务。
直接new出来的对象添加事务是不起作用的。
可以通过以下方式判断是否是代理对象：
AopUtils.isAopProxy(Object object)
AopUtils.isCglibProxy(Object object) //cglib
AopUtils.isJdkDynamicProxy(Object object) //jdk动态代理
2、入口函数必须是public，否则事务不起作用。这一点由Spring的AOP特性决定的。
3、切入点配置错误。
<!-- 使用annotation注解方式配置事务 --> <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/> <!--使用切面方式配置事务--> <tx:advice id="txadvice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="*" isolation="READ_COMMITTED" propagation="REQUIRED" rollback-for="java.lang.Exception" /> </tx:attributes> </tx:advice> <aop:config> <aop:pointcut id="pointcut" expression="execution(* com.tyyd..*Service.do*(..))"/> <aop:advisor advice-ref="txadvice" pointcut-ref="pointcut"/> </aop:config>
4、如果你使用了springmvc，可能是context:component-scan重复扫描引起的：
5、如使用mysql且引擎是MyISAM造成的（因为不支持事务），改成InnoDB即可
