事务_事务隔离级别 - CSDN
事务 订阅
事务(Transaction),一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。事务通常由高级数据库操纵语言或编程语言(如SQL,C++或Java)书写的用户程序的执行所引起,并用形如begin transaction和end transaction语句(或函数调用)来界定。事务由事务开始(begin transaction)和事务结束(end transaction)之间执行的全体操作组成。 展开全文
事务(Transaction),一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。事务通常由高级数据库操纵语言或编程语言(如SQL,C++或Java)书写的用户程序的执行所引起,并用形如begin transaction和end transaction语句(或函数调用)来界定。事务由事务开始(begin transaction)和事务结束(end transaction)之间执行的全体操作组成。
信息
特    性
事务是恢复和并发控制的基本单位
外文名
Transaction
中文名
事务
解    释
指要做的或所做的事情
事务计算机中的事务
例如:在关系数据库中,一个事务可以是一条SQL语句,一组SQL语句或整个程序。事务是恢复和并发控制的基本单位。事务应该具有4个属性:原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。原子性(atomicity)。一个事务是一个不可分割的工作单位,事务中包括的操作要么都做,要么都不做。一致性(consistency)。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。隔离性(isolation)。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的,并发执行的各个事务之间不能互相干扰。持久性(durability)。持久性也称永久性(permanence),指一个事务一旦提交,它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。
收起全文
精华内容
参与话题
  • 事务

    千次阅读 2019-01-29 21:33:11
    事务事务指的是逻辑上的一组操作,组成这组操作的各个单元要么全都成功,要么全都失败。 作用:保证在一个事务中多次操作数据库表中数据时,要么全部成功,要么全部失败。 事务在解决生活中的问题时,逻辑是...

    事务:
    事务指的是逻辑上的一组操作,组成这组操作的各个单元要么全都成功,要么全都失败。
    作用:保证在一个事务中多次操作数据库表中数据时,要么全部成功,要么全部失败。
    事务的特性(ACID)
    数据库的事务必须具备ACID特性,ACID是指 Atomic(原子性)、Consistensy(一致性)、Isolation(隔离型)和Durability(持久性)的英文缩写。
    1、原子性(Atomicity)
    事务包装的一组sql,要么都执行成功,要么都失败。这些操作是不可分割的。
    2、一致性(Consistency)
    数据库的数据状态是一致的。
    事务的成功与失败,最终数据库的数据都是符合实际生活的业务逻辑。一致性绝大多数依赖业务逻辑和原子性。
    3、持久性:(Durability)
    事务成功提交之后,对于数据库的改变是永久的。哪怕数据库发生异常,重启之后数据亦然存在。
    4、隔离性(Isolation)
    一个事务的成功或者失败对于其他的事务是没有影响。2个事务应该相互独立。

    事务问题:
    脏读:读正在编辑中的数据(不能容忍)
    脏数据(正在编辑中的数据) dirty data
    Clean data : 编辑完成的数据(保存,撤销)

    幻读(虚读):事务A首先根据条件索引得到N条数据,然后事务B改变了这N条数据之外的M条或者增添了M条符合事务A搜索条件的数据,导致事务A再次搜索发现有N+M条数据了,就产生了幻读。
    也就是说,当前事务读第一次取到的数据比后来读取到数据条目少。

    不可重复读:同一事务中,前后多次读到的数据不一样
    在金融/银行类机构,这个问题一定要解决

    • 幻读与不可重复读的区别:
      两者有些相似,但是前者针对的是insert,后者针对的update或delete。

    spring(数据库)事务隔离级别分为四种(级别递减):
    1、Serializable (串行化):最严格的级别,事务串行执行,资源消耗最大;

    2、REPEATABLE READ(重复读) :保证了一个事务不会修改已经由另一个事务读取但未提交(回滚)的数据。避免了“脏读取”和“不可重复读取”的情况,但不能避免“幻读”,但是带来了更多的性能损失。

    3、READ COMMITTED (提交读):大多数主流数据库的默认事务等级,保证了一个事务不会读到另一个并行事务已修改但未提交的数据,避免了“脏读取”,但不能避免“幻读”和“不可重复读取”。该级别适用于大多数系统。

    4、Read Uncommitted(未提交读) :事务中的修改,即使没有提交,其他事务也可以看得到,会导致“脏读”、“幻读”和“不可重复读取”。

    隔离级别与解决问题
    数据库规范规定了4种隔离级别,分别用于描述两个事务并发的所有情况。

    1. read uncommitted 读未提交,一个事务读到另一个事务没有提交的数据。
      a) 存在:3个问题(脏读、不可重复读、虚读)。
      b) 解决:0个问题
    2. read committed 读已提交,一个事务读到另一个事务已经提交的数据。
      a) 存在:2个问题(不可重复读、虚读)。
      b) 解决:1个问题(脏读)
    3. repeatable read(): 可重复读,在一个事务中读到的数据始终保持一致,无论另一个事务是否提交。
      a) 存在:1个问题(虚读)。
      b) 解决:2个问题(脏读、不可重复读)
    4. serializable 串行化,同时只能执行一个事务,相当于事务中的单线程。
      a) 存在:0个问题。
      b) 解决:3个问题(脏读、不可重复读、虚读)
      安全和性能对比
      安全性:serializable > repeatable read > read committed > read uncommitted
      性能 : serializable < repeatable read < read committed < read uncommitted
      常见数据库的默认隔离级别:
      MySql:repeatable read
      Oracle:read committed

    事务在解决生活中的问题时,逻辑是这样的:
    在这里插入图片描述
    MySQL事务操作
    sql语句 ——描述
    start transaction; ——开启事务 (禁止了自动提交)
    commit; ——提交事务 (手动)
    rollback; ——回滚事务

    准备数据:

    create table account(
    	id int primary key auto_increment,
    	name varchar(20),
    	money double
    );
    # 初始化数据
    insert into account values (null,'a',1000);
    insert into account values (null,'b',1000);
    
    

    操作:MySQL中可以有两种方式进行事务管理

    • 手动提交:先开启,再提交
    • 自动提交:MySQL默认自动提交。即执行一条sql语句提交一次事务。

    方式一、手动
    在这里插入图片描述在这里插入图片描述提交事务(commit;) (事务提交之后,sql语句对数据库产生的操作才会被永久的保存)

    事务是如何处理异常的?
    a=1000 b=1000
    开启事务(start transaction;)
    update t_account set money = money -100 where name=‘a’; a=900
    出现异常
    update t_account set money = money +100 where name=‘b’;
    事务的回滚(rollback;)(撤销已经成功执行的sql语句,回到开启事务之前的状态)
    a=1000 b=1000;
    注意:只要提交事务,那么数据就会长久保存了,就不能回滚事务了。即提交或者回滚事务都是代表结束当前事务的操作。

    方式二、自动提交,通过修改mysql全局变量“autocommit”进行控制。
    通过以下命令可以查看当前autocommit模式:
    show variables like ‘%commit%’;
    在这里插入图片描述设置自动提交的参数为OFF
    set autocommit = 0; – 0:OFF 1:ON

    说明:
    1)MySql默认自动提交。即执行一条sql语句提交一次事务。
    2)设置autocommit为off状态,只是临时性的,下次重新启动mysql,autocommit依然变为on状态。
    3)如果设置autocommit为off状态,那么当我们执行一条sql语句,就不会自动提交事务,重新启动可视化工具,数据并没有改变。
    4)如果设置autocommit为on状态,如果我们先执行 start transaction; 然后在执行修改数据库的语句:
    update account set money = money-100 where name=‘a’;
    update account set money = money+100 where name=‘b’;
    那么此时就表示上述修改数据库的sql语句都在同一个事务中,此时必须手动提交事务,即commit;
    换句话说,如果我们手动开启事务 start transaction; 那么此时mysql就不会自动提交事务,必须手动提交事务。
    5)如果设置autocommit为on状态,如果我们不执行 start transaction; 直接执行修改数据库的语句:
    update account set money = money-100 where name=‘a’;
    update account set money = money+100 where name=‘b’;
    那么此时mysql就会自动提交事务。即上述每条sql语句就是一个事务。

    JDBC事务操作
    在这里插入图片描述Connection对象的方法名 ——描述
    conn.setAutoCommit(false) ——开启事务(禁止自动提交)
    conn.commit() ——提交事务
    conn.rollback() ——回滚事务

    注意:在jdbc事务操作中,事务的控制都是通过Connection对象完成的,当一个完整的业务操作前,我们首先使用conn.setAutoCommit(false)来开启事务。默认情况下是true的,表示关闭事务,那么一条sql语句就是一个事务,默认提交事务。如果设置为false,那么表示开启事务,所有的sql语句就会都在一个事务中。
    当业务操作完成之后,如果整个操作没有问题,我们需要使用conn.commit()来提交事务。当然了,如果出现了异常,我们需要使用conn.rollback()撤销所有的操作,所以出现异常,需要进行事务的回滚。

    常见事务问题之详解

    • 脏读:只一个事务读取了另外一个事务未提交的数据
      set session transaction isolation level read uncommitted;
      在这里插入图片描述
    • 不可重复读:在一个事务内多次读取表中数据,多次读取的结果不同。(和脏读的区别:不可重复读是读取已提交的数据)
      set session transaction isolation level read committed;
      在这里插入图片描述
      幻读(虚读):
      set session transaction isolation level repeatable read;
      在这里插入图片描述

    指在一个事务中 读取 另一个事务 插入或删除 数据记录,导致当前事务 读取数据前后不一致。
    存款100元但未提交,这时银行做报表 统计总额为500元,丙将事务提交,银行再统计就变成了 600元,两次统计结果不一致,银行便会不知所措。
    一个事务 读取 另一个事务 已经提交的数据,强调的是 记录数 的变化,常有sql类型为 insert和 delete。

    注意: 在mysql数据库中,底层对于幻读做了优化,演示不了。

    serializable串行化
    可以避免所有的问题。数据库执行这个事务,其他事务必须等待当前事务执行完毕,才能被执行。
    串行为什么可以解决所有问题?因为上述问题都是由并行执行引起的,所以改成所有事务一次执行(串行),就可以解决所有问题。

    展开全文
  • 什么是事务? 百度百科中解释:指作为单个逻辑工作单元执行的一系列操作,要么完全地执行,要么完全地不执行。 简单的说,事务就是并发控制的单位,是用户定义的一个操作序列。 而一个逻辑工作单元要成为事务,就...

    目录

     

     什么是事务?

     事务的隔离级别:

    事务运行的模式:

    spring 事务实现方式:

    分布式事务实现方式:


     什么是事务?

    百度百科中解释:指作为单个逻辑工作单元执行的一系列操作,要么完全地执行,要么完全地不执行。
    简单的说,事务就是并发控制的单位,是用户定义的一个操作序列。
    而一个逻辑工作单元要成为事务,就必须满足ACID属性。
    A:原子性(Atomicity)
        事务中的操作要么都不做,要么就全做。
    C:一致性(Consistency)
        事务执行的结果必须是从数据库从一个一致性状态转换到另一个一致性状态。
    I:隔离性(Isolation)
        一个事务的执行不能被其他事务干扰
    D:持久性(Durability)
        一个事务一旦提交,它对数据库中数据的改变就应该是永久性的

     事务的隔离级别:

    1.DEFAULT :这是一个PlatfromTransactionManager默认的隔离级别,使用数据库默认的事务隔离级别。

    2.读未提交(Read Uncommitted)
                 引发脏读(读取了未提交的数据)
    3.读已提交(Read Committed)
                这是大多数数据库系统默认的隔离级别,但不是MySQL默认的,只能看见已经提交事务所做的改变,
                引发不可重复读,不可重读读意味着我们同一事务执行完全相同的select语句时可能看到不一样的结果。
                ——>导致这种情况的原因可能有:(1)有一个交叉的事务有新的commit,导致了数据的改变;(2)一个数据库被多个实例操作时,同一事务的其他实例在该实例处理其间可能会有新的commit,多个commit提交时,只读一次出现结果不一致。

     4.可重复读(Repeatable Read)
                这是MySQL的默认事务隔离级别,
                它确保同一事务的多个实例在并发读取数据时,看到同样的数据行,此级别可能出现的问题--幻读(Phantom Read),当用户读取某一范围的数据行时,另一个事务又在该范围内插入了新行,当用户再读取该范围的数据行时,会发现有新的“幻影” 行,InnoDB和Falcon存储引擎通过多版本并发控制(MVCC,Multiversion Concurrency Control)机制解决了该问题。
      5.可串行化(Serializable)
                这是最高的隔离级别,
                它通过强制事务排序,使之不可能相互冲突,从而解决幻读问题。简言之,它在每个读的数据行上加上共享锁。
                可能导致大量的超时现象和锁竞争。

     äºå¡

    事务运行的模式:

    事务运行的三种模式:
    1.自动提交事务
        每条单独的语句都是一个事务,每个语句都隐含一个commit。
    2.显式事务
        以begin transaction 开始,以commit 或 rollback 结束。
    3.隐性事务
        在前一个事务完成时,新事务隐式启动,但每个事务仍以commit或rollback显示结束。

    注意:隔离级别的设置只对当前链接有效。对于使用MySQL命令窗口而言,一个窗口就相当于一个链接,当前窗口设置的隔离级别只对当前窗口中的事务有效;对于JDBC操作数据库来说,一个Connection对象相当于一个链接,而对于Connection对象设置的隔离级别只对该Connection对象有效,与其他链接Connection对象无关。

    spring 事务实现方式:

    1. 编程式事务管理对基于 POJO 的应用来说是唯一选择。我们需要在代码中调用beginTransaction()、commit()、rollback()等事务管理相关的方法,这就是编程式事务管理。事务通常以begin(start) transaction 开始,以commit 或 rollback 结束。 
      commit 表示提交,将事务中所有对数据库的更新写会到磁盘的物理数据库中,事务正常结束。 
      rollback表示回滚,即在事务运行的过程中发生了某种故障,事务不能继续进行,系统将事务中对数据库的所有以完成的操作全部撤消,滚回到事务开始的状态。
    2. 基于 TransactionProxyFactoryBean 的声明式事务管理。
    3. 基于 @Transactional 的声明式事务管理。
    4. 基于 Aspectj AOP 配置事务。
       

    分布式事务实现方式:

    分布式事务解决方案,基于CAP理论 、BASE理论、幂等性理论: 

    1. MQ做消息处理,MQ消息一致性。      

    2.两阶段提交TCC框架、蚂蚁金服Seata、阿里GTS框架、LCN框架。     

    3. 将业务代码分得更细。     

    4. 数据事务补偿, 补偿机制  ,针对读和写操作。    

     

    参考: 
    http://xm-king.iteye.com/blog/770721 
    https://www.cnblogs.com/snsdzjlz320/p/5761387.html

     

     

    展开全文
  • 事务事务的四大特征是什么?

    万次阅读 2018-07-23 13:45:30
    1、事务是什么  事务是应用程序中一系列严密的操作,所有操作必须成功完成,否则在每个操作中所作的所有更改都会被撤消。也就是事务具有原子性,一个事务中的一系列的操作要么全部成功,要么一个都不做。 2、...

    1、事务是什么      

           事务是应用程序中一系列严密的操作,所有操作必须成功完成,否则在每个操作中所作的所有更改都会被撤消。也就是事务具有原子性,一个事务中的一系列的操作要么全部成功,要么一个都不做。

    2、事务的四大特性 

          数据库事务 transanction 正确执行的四个基本要素。ACID,原子性(Atomicity)、一致性(Correspondence)、隔离
    性(Isolation)、持久性(Durability)。

          (1)原子性:整个事务中的所有操作,要么全部完成,要么全部不完成,不可能停滞在中间某个环节。事务在执行过程中发生错误,会被回滚(Rollback)到事务开始前的状态,就像这个事务从来没有执行过一样。
          (2)一致性:在事务开始之前和事务结束以后,数据库的完整性约束没有被破坏。
          (3)隔离性:隔离状态执行事务,使它们好像是系统在给定时间内执行的唯一操作。如果有两个事务,运行在相同的时间内,执行 相同的功能,事务的隔离性将确保每一事务在系统中认为只有该事务在使用系统。这种属性有时称为串行化,为了防止事务操作间的混淆,  必须串行化或序列化请 求,使得在同一时间仅有一个请求用于同一数据。
          (4)持久性:在事务完成以后,该事务所对数据库所作的更改便持久的保存在数据库之中,并不会被回滚。

    展开全文
  • Java中的事务及使用

    万次阅读 多人点赞 2018-12-05 09:49:25
    什么是事务事务(Transaction),一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。事务通常由高级数据库操纵语言或编程语言(如SQL,C++或Java)...

    什么是事务?

    事务(Transaction),一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。事务通常由高级数据库操纵语言或编程语言(如SQL,C++或Java)书写的用户程序的执行所引起,并用形如begin transactionend transaction语句(或函数调用)来界定。事务由事务开始(begin transaction)和事务结束(end transaction)之间执行的全体操作组成。

    为什么要事务?

    事务是为解决数据安全操作提出的,事务控制实际上就是控制数据的安全访问。

    用一个简单例子说明:银行转帐业务,账户A要将自己账户上的1000元转到B账户下面,A账户余额首先要减去1000元,然后B账户要增加1000元。假如在中间网络出现了问题,A账户减去1000元已经结束,B因为网络中断而操作失败,那么整个业务失败,必须做出控制,要求A账户转帐业务撤销。这才能保证业务的正确性,完成这个操走就需要事务,将A账户资金减少和B账户资金增加放到同一个事务里,要么全部执行成功,要么全部撤销,这样就保证了数据的安全性。

    事务的4个特性(ACID):

    1) 原子性(atomicity):事务是数据库的逻辑工作单位,而且是必须是原子工作单位,对于其数据修改,要么全部执行,要么全部不执行。

    2) 一致性(consistency):事务在完成时,必须是所有的数据都保持一致状态。在相关数据库中,所有规则都必须应用于事务的修改,以保持所有数据的完整性。(实例:转账,两个账户余额相加,值不变。)

    3) 隔离性(isolation):一个事务的执行不能被其他事务所影响。

    4) 持久性(durability):一个事务一旦提交,事物的操作便永久性的保存在DB中。即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。

    Java有几种类型的事务?

    Java事务的类型有三种:JDBC事务、JTA(Java Transaction API)事务、容器事务。

    1.JDBC事务

    在JDBC中处理事务,都是通过Connection完成的。同一事务中所有的操作,都在使用同一个Connection对象。JDBC事务默认是开启的,并且是默认提交

    JDBC Connection 接口提供了两种事务模式:自动提交和手工提交

    JDBC中的事务java.sql.Connection 的三个方法与事务有关:

    setAutoCommit(boolean):设置是否为自动提交事务,如果true(默认值为true)表示自动提交,也就是每条执行的SQL语句都是一个单独的事务,如果设置为false,需要手动提交事务。

    commit():提交结束事务。

    rollback():回滚结束事务。

    传统JDBC操作流程:

      1).获取JDBC连接   2).声明SQL   3).预编译SQL   4).执行SQL   5).处理结果集   

      6).释放结果集  7).释放Statement  8).提交事务  9).处理异常并回滚事务 10).释放JDBC连接

    JDBC优缺点:1.冗长、重复     2.显示事务控制     3.每个步骤不可获取    4.显示处理受检查异常

    JDBC为使用Java进行数据库的事务操作提供了最基本的支持。通过JDBC事务,我们可以将多个SQL语句放到同一个事务中,保证其ACID特性。JDBC事务的主要优点就是API比较简单,可以实现最基本的事务操作,性能也相对较好。但是,JDBC事务有一个局限:一个 JDBC 事务不能跨越多个数据库!所以,如果涉及到多数据库的操作或者分布式场景,JDBC事务就无能为力了。

     2.JTA事务

    JTA(Java Transaction API)提供了跨数据库连接(或其他JTA资源)的事务管理能力。JTA事务管理则由JTA容器实现,J2ee框架中事务管理器与应用程序,资源管理器,以及应用服务器之间的事务通讯。

    1)JTA的构成

    a、高层应用事务界定接口,供事务客户界定事务边界的

    b、X/Open XA协议(资源之间的一种标准化的接口)的标准Java映射,它可以使事务性的资源管理器参与由外部事务管理器控制的事务中

    c、高层事务管理器接口,允许应用程序服务器为其管理的应用程序界定事务的边界

    2)JTA的主要接口位于javax.transaction包中

    a、UserTransaction接口:让应用程序得以控制事务的开始、挂起、提交、回滚等。由Java客户端程序或EJB调用。

    b、TransactionManager 接口:用于应用服务器管理事务状态

    c、Transaction接口:用于执行相关事务操作

    d、XAResource接口:用于在分布式事务环境下,协调事务管理器和资源管理器的工作

    e、Xid接口:为事务标识符的Java映射

    :前3个接口位于Java EE版的类库 javaee.jar 中,Java SE中没有提供!UserTransaction是编程常用的接口,JTA只提供了接口,没有具体的实现。

    JTS(Java Transaction Service)是服务OTS的JTA的实现。简单的说JTS实现了JTA接口,并且符合OTS的规范。

    JTA的事务周期可横跨多个JDBC Connection生命周期,对众多Connection进行调度,实现其事务性要求。

    JTA可以处理任何提供符合XA接口的资源。包括:JDBC连接,数据库,JMS,商业对象等等。

    3)JTA编程的基本步骤

    a、首先配置JTA ,建立相应的数据源

    b、建立事务:通过创建UserTransaction类的实例来开始一个事务。代码如下:

        Context ctx = new InitialContext(p) ;

        UserTransaction trans = (UserTransaction) ctx.lookup("javax. Transaction.UserTransaction")

    c、开始事务:代码为 trans.begin() ;

    d、找出数据源:从Weblogic Server上找到数据源,代码如下:

    DataSource ds = (DataSource) ctx.lookup(“mysqldb") ;

    e、建立数据库连接:Connection mycon = ds.getConnection() ;

    f、执行SQL操作:stmt.executeUpdate(sqlS);

    g、完成事务:trans.commit(); / trans.rollback();

    h、关闭连接:mycon.close() ;

    JTA的优缺点:

    JTA的优点很明显,就是提供了分布式事务的解决方案,严格的ACID。但是,标准的JTA方式的事务管理在日常开发中并不常用。

    JTA的缺点是实现复杂,通常情况下,JTA UserTransaction需要从JNDI获取。这意味着,如果我们使用JTA,就需要同时使用JTA和JNDI。

    JTA本身就是个笨重的API,通常JTA只能在应用服务器环境下使用,因此使用JTA会限制代码的复用性。

    3、Spring容器事务

    Spring事务管理的实现有许多细节,如果对整个接口框架有个大体了解会非常有利于我们理解事务,下面通过讲解Spring的事务接口来了解Spring实现事务的具体策略。

    Spring事务管理涉及的接口及其联系:

    Spring并不直接管理事务,而是提供了多种事务管理器,他们将事务管理的职责委托给Hibernate或者JTA等持久化机制所提供的相关平台框架的事务来实现。 Spring事务管理器的接口是org.springframework.transaction.PlatformTransactionManager,通过这个接口,Spring为各个平台如JDBC、Hibernate等都提供了对应的事务管理器,但是具体的实现就是各个平台自己的事情了。

    Public interface PlatformTransactionManager{  
           // 由TransactionDefinition得到TransactionStatus对象
           TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
        // 提交
           Void commit(TransactionStatus status) throws TransactionException;  
           // 回滚
           Void rollback(TransactionStatus status) throws TransactionException;  
    }
    
    

    1)、Spring JDBC事务
    如果应用程序中直接使用JDBC来进行持久化,DataSourceTransactionManager会为你处理事务边界。为了使用     DataSourceTransactionManager,你需要使用如下的XML将其装配到应用程序的上下文定义中:

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
         <property name="dataSource" ref="dataSource" />
    </bean>
    

      实际上,DataSourceTransactionManager是通过调用java.sql.Connection来管理事务。通过调用连接的commit()方法来提交事务,同样,事务失败则通过调用rollback()方法进行回滚。

    2)、Hibernate事务

    如果应用程序的持久化是通过Hibernate实现的,那么你需要使用HibernateTransactionManager。对于Hibernate3,需要在Spring上下文定义中添加如下的<bean>声明:

    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
         <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    
    sessionFactory属性需要装配一个Hibernate的session工厂,HibernateTransactionManager的实现细节是它将事务管理的职责委托给org.hibernate.Transaction对象,而后者是从Hibernate Session中获取到的。当事务成功完成时,HibernateTransactionManager将会调用Transaction对象的commit()方法,反之,将会调用rollback()方法。

    3)、Java持久化API事务(JPA)

    Hibernate多年来一直是事实上的Java持久化标准,但是现在Java持久化API作为真正的Java持久化标准进入大家的视野。如果你计划使用JPA的话,那你需要使用Spring的JpaTransactionManager来处理事务。你需要在Spring中这样配置JpaTransactionManager:

    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
         <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    JpaTransactionManager只需要装配一个JPA实体管理工厂(javax.persistence.EntityManagerFactory接口的任意实现)。JpaTransactionManager将与由工厂所产生的JPA EntityManager合作来构建事务。

    基本的事务属性的定义:

    事务管理器接口PlatformTransactionManager通过getTransaction(TransactionDefinition definition)方法来得到事务,这个方法里面的参数是TransactionDefinition类,这个类就定义了一些基本的事务属性。

    事务属性可以理解成事务的一些基本配置,描述了事务策略如何应用到方法上。

    事务属性包含了5个方面:

    传播行为、隔离规则、回滚规则、事务超时、是否只读

    TransactionDefinition:

    public interface TransactionDefinition {
        int getPropagationBehavior(); // 返回事务的传播行为
        int getIsolationLevel(); // 返回事务的隔离级别,事务管理器根据它来控制另外一个事务可以看到本事务内的哪些数据
        int getTimeout();  // 返回事务必须在多少秒内完成
        boolean isReadOnly(); // 事务是否只读,事务管理器能够根据这个返回值进行优化,确保事务是只读的
    }

    7种传播行为:

    PROPAGATION_REQUIRED:如果当前没有事务,就新建一个事务,如果已经存在一个事务中,加入到这个事务中。这是最常见的选择。

    PROPAGATION_SUPPORTS:支持当前事务,如果当前没有事务,就以非事务方式执行。

    PROPAGATION_MANDATORY:支持当前事务,如果当前没有事务,就抛出异常。

    PROPAGATION_REQUIRES_NEW:新建事务,如果当前存在事务,把当前事务挂起。

    PROPAGATION_NOT_SUPPORTED:以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。

    PROPAGATION_NEVER:以非事务方式执行,如果当前存在事务,则抛出异常。 

    虽然有7种,但是常用的就第一种REQUIRED和第四种REQUIRES_NEW

    五个隔离级别:

    ISOLATION_DEFAULT:这是一个PlatfromTransactionManager默认的隔离级别,使用数据库默认的事务隔离级别.

    另外四个与JDBC的隔离级别相对应;

    ISOLATION_READ_UNCOMMITTED:这是事务最低的隔离级别,它充许别外一个事务可以看到这个事务未提交的数据。

    这种隔离级别会产生脏读,不可重复读和幻像读。

    ISOLATION_READ_COMMITTED:保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。

    这种事务隔离级别可以避免脏读出现,但是可能会出现不可重复读和幻像读。

    ISOLATION_REPEATABLE_READ:这种事务隔离级别可以防止脏读,不可重复读。但是可能出现幻像读。

    它除了保证一个事务不能读取另一个事务未提交的数据外,还保证了避免下面的情况产生(不可重复读)。

    ISOLATION_SERIALIZABLE:这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。

    除了防止脏读,不可重复读外,还避免了幻像读。

    事务的属性可同通过注解方式或配置文件配置:

    注解方式:

    @Transactional只能被应用到public方法上,对于其它非public的方法,如果标记了@Transactional也不会报错,但方法没有事务功能.
    默认情况下,一个有事务方法, 遇到RuntimeException 时会回滚 . 遇到 受检查的异常 是不会回滚 的. 要想所有异常都回滚,要加上 @Transactional( rollbackFor={Exception.class,其它异常}) 

    @Transactional(
        readOnly = false, //读写事务
        timeout = -1 ,     //事务的超时时间,-1为无限制
        noRollbackFor = ArithmeticException.class, //遇到指定的异常不回滚
        isolation = Isolation.DEFAULT, //事务的隔离级别,此处使用后端数据库的默认隔离级别
        propagation = Propagation.REQUIRED //事务的传播行为
    )
    

    配置文件( aop拦截器方式):

    <tx:advice id="advice" transaction-manager="txManager">
              <tx:attributes>
                <!-- tx:method的属性:
                    * name 是必须的,表示与事务属性关联的方法名(业务方法名),对切入点进行细化。通配符 
                         (*)可以用来指定一批关联到相同的事务属性的方法。
                          如:'get*'、'handle*'、'on*Event'等等.
                    * propagation:不是必须的,默认值是REQUIRED表示事务传播行为,
                      包括REQUIRED,SUPPORTS,MANDATORY,REQUIRES_NEW,NOT_SUPPORTED,NEVER,NESTED
                    * isolation:不是必须的 默认值DEFAULT ,表示事务隔离级别(数据库的隔离级别)
                    * timeout:不是必须的 默认值-1(永不超时),表示事务超时的时间(以秒为单位)
                    * read-only:不是必须的 默认值false不是只读的表示事务是否只读?
                    * rollback-for: 不是必须的表示将被触发进行回滚的 Exception(s);以逗号分开。
                       如:'com.foo.MyBusinessException,ServletException'
                    * no-rollback-for:不是必须的表示不被触发进行回滚的 Exception(s),以逗号分开。                                        
                       如:'com.foo.MyBusinessException,ServletException'   
                    任何 RuntimeException 将触发事务回滚,但是任何 checked Exception 将不触发事务回滚                     
                -->
                 <tx:method name="save*" propagation="REQUIRED" isolation="DEFAULT" read-only="false"/>
                 <tx:method name="update*" propagation="REQUIRED" isolation="DEFAULT" read-only="false"/>
                 <tx:method name="delete*" propagation="REQUIRED" isolation="DEFAULT" read-only="false"  rollback-for="Exception"/>
                 <!-- 其他的方法之只读的 -->
                 <tx:method name="*" read-only="true"/>
              </tx:attributes>
    </tx:advice>
    展开全文
  • 什么是事务事务(`Transaction`),一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元。事务通常由高级数据库操作语言或编程语言(如 SQL,C++ 或 Java)书写...
  • 1.事务(Transaction) 指的一组操作,里面包含许多个单一的逻辑。只要有一个逻辑没有执行成功,那么都算失败。 所有的数据都回归到最初的状态(回滚) 为什么要有事务? 为了确保逻辑的成功。 例子: 银行的转账。 ...
  • 事务&amp;数据库连接池&amp;DBUtils》 事务 Transaction 其实指的一组操作,里面包含许多个单一的逻辑。只要有一个逻辑没有执行成功,那么都算失败。 所有的数据都回归到最初的状态(回滚) 为什么要有...
  • 事务的概念

    千次阅读 2018-07-14 08:21:26
    一、事务的概念 事务指逻辑上的一组操作,组成这组操作的各个单元,要不全部成功,要不全部不成功。 例如:A——B转帐,对应于如下两条sql语句 update from account set money=money+100 where name='B'; update...
  • 事务是什么,以及事务四个特性

    万次阅读 多人点赞 2012-11-22 10:57:55
    事务的结束有两种,当事务中的所以步骤全部成功执行时,事务提交。如果其中一个步骤失败,将发生回滚操作,撤消撤消之前到事务开始时的所以操作。 二.事务的 ACID 事务具有四个特征:原子性( A
  • MySQL——事务(Transaction)详解

    万次阅读 多人点赞 2018-03-23 13:05:50
    该博客详解MySQL中的事务 一、事务定义 Transaction 事务:一个最小的不可再分的工作单元;通常一个事务对应一个完整的业务(例如银行账户转账业务,该业务就是一个最小的工作单元) 一个完整的业务需要批量的DML...
  • spring的4种事务特性,5种隔离级别,7种传播行为

    万次阅读 多人点赞 2020-07-30 16:48:06
    spring事务: 什么是事务: 事务逻辑上的一组操作,组成这组操作的各个逻辑单元,要么一起成功,要么一起失败.事务特性(4种): 原子性 (atomicity):强调事务的不可分割. 一致性 (consistency):事务的执行的前后...
  • 看完就明白_spring事务的7种传播行为

    万次阅读 多人点赞 2018-06-15 17:10:43
    原文:https://blog.csdn.net/soonfly/article/details/70305683事务传播行为...事务传播行为(propagation behavior)指的就是当一个事务方法被另一个事务方法调用时,这个事务方法应该如何进行。 例如:methodA事...
  • 事务管理可以帮助我们保证数据的一致性,对应企业的实际应用很重要。 Spring的事务机制包括声明式事务和编程式事务。 编程式事务管理:Spring推荐使用TransactionTemplate,实际开发中使用声明式事务较多。 声明...
  • Java - JDBC中如何进行事务处理?

    万次阅读 2019-03-16 15:15:50
    Connection提供了事务处理的方法,通过调用setAutoCommit(false)可以设置手动提交事务;当事务完成后用commit()显式提交事务;如果在事务处理过程中发生异常则通过rollback()进行事务回滚。除此之外,从JDBC 3...
  • spring事务(Transaction)的七种事务传播行为及五种隔离级别
  • Spring中propagation的7种事务配置

    万次阅读 2018-01-25 17:48:22
    一、在声明式的事务处理中,要配置一个切面,其中就用到了propagation,表示打算对这些方法怎么使用事务,是用还是不用,其中propagation有七种配置,REQUIRED、SUPPORTS、MANDATORY、REQUIRES_NEW、NOT_SUPPORTED、...
  • 在Spring AOP切面中启用新事务

    万次阅读 多人点赞 2019-07-31 19:16:01
    在工作中有一个在切面中需要记录一下操作日志的需求,而且要求这些操作日志要存入数据库,并且无论业务层有什么异常,日志照常记录,那就不能沿用业务层的事务,而是需要新启一个事务了。 sping的声明式事务就是靠...
  • spring事务的传播特性

    万次阅读 2014-01-03 21:28:22
    Spring 事务一个被讹传很广说法是:一个事务方法不应该调用另一个事务方法,否则将产生两个事务。结果造成开发人员在设计事务方法时束手束脚,生怕一不小心就踩到地雷。 其实这种是不认识 Spring 事务传播机制而...
  • springboot 开启事务以及手动提交事务

    万次阅读 热门讨论 2019-03-26 14:55:19
    springboot 开启事务以及手动提交事务 需要在服务类上加上两个注解 @Autowired DataSourceTransactionManager dataSourceTransactionManager; @Autowired TransactionDefinition transactionDefinition; 手动开启...
  • Lock wait timeout exceeded; try restarting transaction解决方案
1 2 3 4 5 ... 20
收藏数 980,309
精华内容 392,123
关键字:

事务