spring-事务

事务

原子性 :强调事务的不可分割.
一致性 :事务的执行的前后数据的完整性保持一致(转账).
隔离性 :一个事务执行的过程中,不应该受到其他事务的干扰
持久性 :事务一旦结束,数据就持久到数据库

回顾知识

1、什么是事务
事务逻辑上的一组操作,组成这组操作的各个逻辑单元,要么一起成功,要么一起失败.
2、事务特性:ACID
3、如果不考虑隔离性将会引发下面的安全性问题
脏读 :一个事务读到了另一个事务的未提交的数据
不可重复读 :一个事务读到了另一个事务已经提交的update的数据导致多次查询结果不一致.
虚读（幻读） :一个事务读到了另一个事务已经提交的insert的数据导致多次查询结果不一致.

4、解决读问题:设置事务隔离级别（每种数据库的隔离级别不一样）
未提交读 :脏读，不可重复读，虚读都有可能发生
已提交读 :避免脏读。但是不可重复读和虚读有可能发生(sqlserver,orcale)
可重复读 :避免脏读和不可重复读.但是虚读有可能发生.（mysql）
串行化的 :避免以上所有读问题.

1、使用Aspectj注解方式解决事务问题

1、添加约束文档
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
2、xml配置事务管理器

<bean id="transactionManager"  
  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource" />
</bean>
  <!-- 开启事务：通过aop的方式，对方法进行事务的增强 -->
  <tx:annotation-driven transaction-manager="transactionManager"/>

1、在任意希望进行事务增强的方法上面添加@Transactional注解

 @Transactional public int getMoney(int uid,float money,int typeid){
  moneyDao.getMoney(uid, money); int a=1/0;//这里报错，会进行事务回滚
   return moneyDao.insertReocrd(new Record(uid, money, typeid)); }

2、通过XML配置AOP方式解决事务问题

 <!-- 配置AOP -->
 <aop:config>
 <!-- 配置切入点：指定哪些方法要执行事务增强 -->
 <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.hemi.service.*.*(..))"/> </aop:config>
 <!-- 配置增强 -->
 <tx:advice id="txAdvice" transaction-manager="transactionManager"> 
 <!-- 细粒度控制某个方法上事务的属性：例如事务是否传递，事务是否回滚等等 -->
 <!-- REQUIRED:有事务就用，没有就创建 SUPPORTS:有就用，没有就非事务执行 --> 
 <tx:attributes>
       <!-- no-rollback-for:当出现了ArithmeticException异常时，也不回滚已提交的事务 --> 
       <tx:method name="*Money" propagation="REQUIRED" no-rollbackfor="ArithmeticException"/> 
       <tx:method name="delect*" propagation="REQUIRED"/>
       <tx:method name="update*" propagation="REQUIRED"/>
       <tx:method name="insert*" propagation="REQUIRED"/>
       <tx:method name="select*" propagation="SUPPORTS"/>
       <!-- isolation="DEFAULT" 隔离级别 propagation="REQUIRED" 传播行为 read-only="false" 只读 timeout="-1" 过期时间 rollback-for="" -Exception no-rollback-for="" +Exception -->
       </tx:attributes> </tx:advice>

注意
推荐使用第二种方式，可以控制所有的方法是否使用事务！

事务补充知识点

1、事务回滚控制
控制遇到哪些异常才要回滚事务

Some_Text

例如：

 // 在需要增强的方法上面，添加该注解，就可以使用事务
 //noRollbackFor:如果出现了ArithmeticException，忽略
 @Transactional(noRollbackFor={ArithmeticException.class}) 
 public int getMoney(int uid, float money, int typeid) {
      moneyDao.getMoney(uid, money); 
      int a = 1 / 0;
      //虽然这里抛出异常，但是上面的操作依然生效，事务不会回滚 
      return moneyDao.insertReocrd(new Record(uid, money, typeid)); 
    }

其他事务属性一览表

Some_Text

2、事务隔离级别 isolation
事务隔离概念：解决并发问题
不同的数据库支持不同的隔离级别，一般不用修改

3、事务传递 propagation
事务传递概念:两个方法相互嵌套，事务是否公用，例如：方法A的事务是否可以传递给方法B所使用
事务传递有多种情况，如下：

Some_Text

例如：

    事务：火车票售票点买票 非事务（正常执行）：
    打电话买票
    public class A{
         假设 ma()为方法A mb()为方法B 
        1、required:ma有事务,mb就用,ma没事务,mb自己创建 
        @Transactional ma(){ 
                mb();//使用了方法ma的事务，如果ma回滚，那么mb也回滚 
                int a=1/0; }
        2、supports:ma有事务,mb就用,ma没事务,mb非事务执行
        @Transactional ma(){
                mb();//打电话 
                int a=1/0; } 
        3、mandatory:ma有事务,mb就用,ma没事务,mb就报错
        @Transactional ma(){
                mb();//如果没有事务，那么这句就抛出异常
                int a=1/0; } 
        4、required_new:ma有事务,mb就暂停别人的事务,然后mb自己开启事务,mb执行完后,ma在恢复事务并继续执行 
        @Transactional ma(){ 
                update();
                mb();
                update(); }
        上面的代码运行,实际相当于下面的代码
        @Transactional ma(){
                Connection con =connection.startTranscation();
                try{ 
                     try{
                          update()
                     }catch (Exception e){
                          con.rollback(); }

                     try{
                          Connection con1 =connection.startTranscation();
                           mb();
                     }catch (Exception e) {
                           con1.rollback(); }

                     try{ 
                           insert(); int a=10/0; 
                     }catch (Exception e) {
                            con.rollback(); }
                }catch (Exception e) {
                     con.rollback(); } }
         5、not_supported:ma有事务,mb就暂停别人的事务,然后mb非事务执行,mb执行完后,ma在恢复事务并继续执行 
        @Transactional ma(){
               update(); 
               mb();
               int a=10/0;
               insert(); }
         6、never:ma有事务,mb就抛异常,ma没事务,mb就非事务执行 
         @Transactional ma(){
               update();
               mb();
               int a=10/0;
               insert(); }
         7、nested:事务嵌套,ma有事务,mb就嵌套在别人的事务中,ma没事务,mb自己创建事务 
         ma(){ 
               update();
               mb();
               update(); } 
        上面的代码运行,实际相当于下面的代码 
         @Transactional ma(){
               Connection con =connection.startTranscation();
               try{ 
                   try{ 
                       update()
                   }catch (Exception e) {
                       con.rollback(); } 
                  //插队 
                  try{ 
                      mb(); }
                  catch (Exception e) {
                      con.rollback(); }
                  try{
                      insert();
                      int a=10/0; }
                  catch (Exception e) {
                      con.rollback(); } 
              }catch (Exception e) {
                  con.rollback(); } }}