首页betway必威体育app官网 › Spring事务管理(转)

Spring事务管理(转)

2.2.1 传播行为

工作的首先个方面是传播行为(propagation
behavior)。当事情方法被另四个作业方法调用时,必须钦点工作应该怎样传播。例如:方法或者继承在现有工作中运转,也恐怕打开1个新业务,并在团结的业务中运作。Spring定义了八种传播行为:

传播行为 含义
PROPAGATION_REQUIRED 表示当前方法必须运行在事务中。如果当前事务存在,方法将会在该事务中运行。否则,会启动一个新的事务
PROPAGATION_SUPPORTS 表示当前方法不需要事务上下文,但是如果存在当前事务的话,那么该方法会在这个事务中运行
PROPAGATION_MANDATORY 表示该方法必须在事务中运行,如果当前事务不存在,则会抛出一个异常
PROPAGATION_REQUIRED_NEW 表示当前方法必须运行在它自己的事务中。一个新的事务将被启动。如果存在当前事务,在该方法执行期间,当前事务会被挂起。如果使用JTATransactionManager的话,则需要访问TransactionManager
PROPAGATION_NOT_SUPPORTED 表示该方法不应该运行在事务中。如果存在当前事务,在该方法运行期间,当前事务将被挂起。如果使用JTATransactionManager的话,则需要访问TransactionManager
PROPAGATION_NEVER 表示当前方法不应该运行在事务上下文中。如果当前正有一个事务在运行,则会抛出异常
PROPAGATION_NESTED 表示如果当前已经存在一个事务,那么该方法将会在嵌套事务中运行。嵌套的事务可以独立于当前事务进行单独地提交或回滚。如果当前事务不存在,那么其行为与PROPAGATION_REQUIRED一样。注意各厂商对这种传播行为的支持是有所差异的。可以参考资源管理器的文档来确认它们是否支持嵌套事务

注:以下具体讲解传播行为的内容参考自Spring事务机制详解 
(1)PROPAGATION_REQUIRED
借使存在二个业务,则援救当前业务。即使没有事情则开启3个新的事体。

//事务属性 PROPAGATION_REQUIRED
methodA{
    ……
    methodB();
    ……
}

//事务属性 PROPAGATION_REQUIRED
methodB{
   ……
}

选取spring评释式事务,spring使用AOP来支撑阐明式事务,会基于业务属性,自动在点子调用在此以前决定是不是开启1个事务,并在措施执行之后决定工作提交或回滚事务。

单独调用methodB方法:

main{ 
    metodB(); 
}

相当于

Main{ 
    Connection con=null; 
    try{ 
        con = getConnection(); 
        con.setAutoCommit(false); 

        //方法调用
        methodB(); 

        //提交事务
        con.commit(); 
    } Catch(RuntimeException ex) { 
        //回滚事务
        con.rollback();   
    } finally { 
        //释放资源
        closeCon(); 
    } 
}

Spring保险在methodB方法中负有的调用都得到到叁个均等的连年。在调用methodB时,没有一个存在的政工,所以博得三个新的接连,开启了四个新的作业。 
独立调用MethodA时,在MethodA内又会调用MethodB.

实施效率一定于:

main{ 
    Connection con = null; 
    try{ 
        con = getConnection(); 
        methodA(); 
        con.commit(); 
    } catch(RuntimeException ex) { 
        con.rollback(); 
    } finally {    
        closeCon(); 
    }  
}

调用MethodA时,环境中从未工作,所以开启1个新的事务.当在MethodA中调用MethodB时,环境中早已有了3个工作,所以methodB就进入当前作业。

(2)PROPAGATION_SUPPOSportageTS
假若存在三个事情,扶助当前政工。如若没有事情,则非事务的执行。可是对于工作同步的事务管理器,PROPAGATION_SUPPOSportageTS与不选择工作某些例外。

//事务属性 PROPAGATION_REQUIRED
methodA(){
  methodB();
}

//事务属性 PROPAGATION_SUPPORTS
methodB(){
  ……
}

一味的调用methodB时,methodB方法是非事务的执行的。当调用methdA时,methodB则投入了methodA的事情中,事务地执行。

(3)PROPAGATION_MANDATO凯雷德Y
如果已经存在二个工作,协理当前工作。如若没有二个运动的业务,则抛出特别。

//事务属性 PROPAGATION_REQUIRED
methodA(){
    methodB();
}

//事务属性 PROPAGATION_MANDATORY
    methodB(){
    ……
}

当单独调用methodB时,因为最近并未1个移动的业务,则会抛出相当throw new
IllegalTransactionStateException(“Transaction propagation ‘mandatory’
but no existing transaction
found”);当调用methodA时,methodB则进入到methodA的事情中,事务地实施。

(4)PROPAGATION_REQUIRES_NEW
总是敞开贰个新的作业。如若2个事务已经存在,则将以此存在的业务挂起。

//事务属性 PROPAGATION_REQUIRED
methodA(){
    doSomeThingA();
    methodB();
    doSomeThingB();
}

//事务属性 PROPAGATION_REQUIRES_NEW
methodB(){
    ……
}

调用A方法:

main(){
    methodA();
}

相当于

main(){
    TransactionManager tm = null;
    try{
        //获得一个JTA事务管理器
        tm = getTransactionManager();
        tm.begin();//开启一个新的事务
        Transaction ts1 = tm.getTransaction();
        doSomeThing();
        tm.suspend();//挂起当前事务
        try{
            tm.begin();//重新开启第二个事务
            Transaction ts2 = tm.getTransaction();
            methodB();
            ts2.commit();//提交第二个事务
        } Catch(RunTimeException ex) {
            ts2.rollback();//回滚第二个事务
        } finally {
            //释放资源
        }
        //methodB执行完后,恢复第一个事务
        tm.resume(ts1);
        doSomeThingB();
        ts1.commit();//提交第一个事务
    } catch(RunTimeException ex) {
        ts1.rollback();//回滚第一个事务
    } finally {
        //释放资源
    }
}

在那边,作者把ts1誉为外层事务,ts2称为内层事务。从下面的代码能够看到,ts2与ts1是五个单身的事情,互不相干。Ts2是或不是成功并不依靠于
ts1。即便methodA方法在调用methodB方法后的doSomeThingB方法战败了,而methodB方法所做的结果照旧被提交。而除了
methodB之外的别样代码导致的结果却被回滚了。使用PROPAGATION_REQUIRES_NEW,要求利用
JtaTransactionManager作为工作管理器。

(5)PROPAGATION_NOT_SUPPOPRADOTED
总是非事务地实施,并挂起别的存在的作业。使用PROPAGATION_NOT_SUPPO路虎极光TED,也亟需选择JtaTransactionManager作为工作管理器。(代码示例同上,可同理推出)

(6)PROPAGATION_NEVE卡宴总是非事务地实践,如若存在3个活动工作,则抛出十二分。

(7)PROPAGATION_NESTED假诺三个运动的事体存在,则运维在八个嵌套的事体中.
若是没有挪动工作, 则按TransactionDefinition.PROPAGATION_REQUIRED
属性执行。那是1个嵌套事务,使用JDBC
3.0使得时,仅仅帮助DataSourceTransactionManager作为工作管理器。要求JDBC
驱动的java.sql.Savepoint类。有一对JTA的政工管理器完成也许也提供了一致的作用。使用PROPAGATION_NESTED,还索要把PlatformTransactionManager的nestedTransactionAllowed属性设为true;而
nestedTransactionAllowed属性值暗中认可为false。

//事务属性 PROPAGATION_REQUIRED
methodA(){
    doSomeThingA();
    methodB();
    doSomeThingB();
}

//事务属性 PROPAGATION_NESTED
methodB(){
    ……
}

假如单独调用methodB方法,则按REQUIRED属性执行。假如调用methodA方法,也就是上边包车型大巴效应:

main(){
    Connection con = null;
    Savepoint savepoint = null;
    try{
        con = getConnection();
        con.setAutoCommit(false);
        doSomeThingA();
        savepoint = con2.setSavepoint();
        try{
            methodB();
        } catch(RuntimeException ex) {
            con.rollback(savepoint);
        } finally {
            //释放资源
        }
        doSomeThingB();
        con.commit();
    } catch(RuntimeException ex) {
        con.rollback();
    } finally {
        //释放资源
    }
}

当methodB方法调用在此以前,调用setSavepoint方法,保存当前的情状到savepoint。假如methodB方法调用败北,则回复到事先封存的情景。可是要求小心的是,那时的业务并从未展开付出,如若继续的代码(doSomeThingB()方法)调用败北,则回滚包蕴methodB方法的保有操作。

嵌套事务贰个12分重庆大学的定义就是内层事务正视于外层事务。外层事务战败时,会回滚内层事务所做的动作。而内层事务操作退步并不会唤起外层事务的回滚。

PROPAGATION_NESTED
与PROPAGATION_REQUIRES_NEW的区分:它们非凡接近,都像三个嵌套事务,假若不存在多个活动的事务,都会敞开二个新的事情。使用
PROPAGATION_REQUIRES_NEW时,内层事务与外层事务就好像三个独立的业务一样,一旦内层事务进行了提交后,外层事务无法对其开始展览回滚。八个业务互不影响。四个事情不是贰个真正的嵌套事务。同时它需求JTA事务管理器的扶助。

使用PROPAGATION_NESTED时,外层事务的回滚能够唤起内层事务的回滚。而内层事务的不行并不会促成外层事务的回滚,它是三个真正的嵌套事务。DataSourceTransactionManager使用savepoint协理PROPAGATION_NESTED时,需求JDBC
3.0上述驱动及1.4上述的JDK版本帮衬。其余的JTA
TrasactionManager完结大概有分裂的匡助办法。

PROPAGATION_REQUIRES_NEW 运维多少个新的, 不借助于环境的 “内部” 事务.
那个业务将被全然 commited 或 rolled back 而不借助于于表面事务,
它拥有和谐的割裂范围, 本身的锁, 等等. 当内部事务初步举行时,
外部事务将被挂起, 内务事务停止时, 外部事务将继续执行。

一只, PROPAGATION_NESTED 开首二个 “嵌套的” 事务,
它是曾经存在业务的2个确实的子事务. 潜套事务起头执行时, 它将得到三个savepoint. 倘若那么些嵌套事务退步, 大家将回滚到此 savepoint.
潜套事务是外表事务的一部分, 唯有外部事务甘休后它才会被提交。

由此可知, PROPAGATION_REQUIRES_NEW 和 PROPAGATION_NESTED
的最大区别在于, PROPAGATION_REQUIRES_NEW 完全是3个新的工作, 而
PROPAGATION_NESTED 则是外表事务的子事务, 借使外部事务 commit,
嵌套事务也会被 commit, 那些规则平等适用于 roll back.

PROPAGATION_REQUIRED应该是大家第二的工作传播行为。它亦可满足大家大多数的业务必要。

2.1.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()方法。

2.1.1 JDBC事务

若是应用程序中央直机关接使用JDBC来展开持久化,DataSourceTransactionManager会为您处监护人务边界。为了选拔DataSourceTransactionManager,你供给采纳如下的XML将其装配到应用程序的上下文定义中:

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

实际,DataSourceTransactionManager是由此调用java.sql.Connection来治本工作,而后人是通过DataSource获取到的。通过调用连接的commit()方法来交付业务,同样,事务退步则经过调用rollback()方法开始展览回滚。

2 主旨接口

Spring事务管理的完结有很多细节,若是对整个接口框架有个差不离明白会这个便于我们明白事情,上边通过讲课Spring的政工接口来打听Spring达成工作的切实政策。 
Spring事务管理关系的接口的关系如下:

图片 1

4 申明式事务

2.2.4 事务超时

为了使应用程序很好地运维,事务不能够运营太长的时日。因为工作恐怕涉及对后端数据库的锁定,所以长日子的工作会不需求的挤占数据库能源。事务超时就是事情的二个定时器,在一定时刻内作业假设没有进行完结,那么就会活动回滚,而不是从来守候其得了。

2.1.4 Java原生API事务

一旦您没有动用上述所述的事务管理,恐怕是跨越了几个业务管理源(比如四个或许是八个例外的数据源),你就需求采取JtaTransactionManager:

    <bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">
        <property name="transactionManagerName" value="java:/TransactionManager" />
    </bean>

JtaTransactionManager将事务管理的义务委托给javax.transaction.UserTransaction和javax.transaction.TransactionManager对象,其青海中华工程集团作成功做到经过UserTransaction.commit()方法提交,事务失利通过UserTransaction.rollback()方法回滚。

3.1 编制程序式和证明式事务的差距

Spring提供了对编制程序式事务和注明式事务的支撑,编制程序式事务允许用户在代码中标准定义事务的疆界,而申明式事务(基于AOP)有助于用户将操作与工作规则进行解耦。 
简易地说,编制程序式事务侵入到了业务代码里面,可是提供了进一步详实的事务管理;而注脚式事务由于基于AOP,所以既能起到事务管理的功力,又足以不影响工作代码的有血有肉得以实现。

2.2 基本工作属性的定义

地方讲到的事情管理器接口PlatformTransactionManager通过getTransaction(TransactionDefinition
definition)方法来博取工作,这么些方式里面包车型大巴参数是TransactionDefinition类,那么些类就定义了一些中坚的工作属性。 
那么怎么样是事情属性呢?事务属性能够驾驭成事务的一对主导配置,描述了工作策略怎样利用到格局上。事务属性包涵了五个方面,如图所示:

图片 2

而TransactionDefinition接口内容如下:

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

大家得以窥见TransactionDefinition正好用来定义事务属性,上边详细介绍一下依次业务属性。

2.2.3 只读

事情的第④个特色是它是还是不是为只读事务。固然工作只对后端的数据库实行该操作,数据库能够行使工作的只读天性来进行一些特定的优化。通过将事情设置为只读,你就足以给数据库二个机遇,让它选取它认为特出的优化措施。

3 编制程序式事务

2.3 事务状态

地点讲到的调用PlatformTransactionManager接口的getTransaction()的方法赢得的是TransactionStatus接口的一个完成,那一个接口的内容如下:

public interface TransactionStatus{
    boolean isNewTransaction(); // 是否是新的事物
    boolean hasSavepoint(); // 是否有恢复点
    void setRollbackOnly();  // 设置为只回滚
    boolean isRollbackOnly(); // 是否为只回滚
    boolean isCompleted; // 是否已完成
}

能够发现那一个接口描述的是一些处监护人务提供简单的决定工作执行和查询工作状态的措施,在回滚或提交的时候要求利用对应的事体状态。

3.2 怎么样兑现编制程序式事务?

Spring提供三种方法的编程式事务管理,分别是:使用TransactionTemplate和平昔利用PlatformTransactionManager。

2.2.5 回滚规则

作业五边形的最终3个地点是一组规则,那么些规则定义了怎么着格外会招致工作回滚而怎么样不会。暗许情况下,事务唯有境遇运营期卓殊时才会回滚,而在遇见检查型分外时不会回滚(这一行为与EJB的回滚行为是同样的)
然则你能够表明事务在遇见一定的检查型格外时像碰到运维期格外那样回滚。同样,你还足以注明事务碰到一定的充足不回滚,即便这一个尤其是运转期非常。

4.1 配置方式

注:以下配置代码参考自Spring事务配置的种种艺术

遵照代理体制的比不上,总括了各类Spring事务的计划格局,配置文件如下:

(1)各个Bean都有1个代理

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

    <bean id="sessionFactory" 
            class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
        <property name="configLocation" value="classpath:hibernate.cfg.xml" /> 
        <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
    </bean> 

    <!-- 定义事务管理器(声明式的事务) --> 
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <!-- 配置DAO -->
    <bean id="userDaoTarget" class="com.bluesky.spring.dao.UserDaoImpl">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <bean id="userDao" 
        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> 
           <!-- 配置事务管理器 --> 
           <property name="transactionManager" ref="transactionManager" />    
        <property name=

2.1 事务管理器

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;  
    }

从此间能够具体的求实的事务管理机制对Spring来说是晶莹的,它并不关怀那个,那个是对应各类平台供给关爱的,所以Spring事务管理的八个优点正是为不相同的事务API提供相同的编制程序模型,如JTA、JDBC、Hibernate、JPA。上边分别介绍各类平台框架达成事务管理的体制。

3.2.2 使用PlatformTransactionManager

演示代码如下:

    DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager(); //定义一个某个框架平台的TransactionManager,如JDBC、Hibernate
    dataSourceTransactionManager.setDataSource(this.getJdbcTemplate().getDataSource()); // 设置数据源
    DefaultTransactionDefinition transDef = new DefaultTransactionDefinition(); // 定义事务属性
    transDef.setPropagationBehavior(DefaultTransactionDefinition.PROPAGATION_REQUIRED); // 设置传播行为属性
    TransactionStatus status = dataSourceTransactionManager.getTransaction(transDef); // 获得事务状态
    try {
        // 数据库操作
        dataSourceTransactionManager.commit(status);// 提交
    } catch (Exception e) {
        dataSourceTransactionManager.rollback(status);// 回滚
    }

1 起来精通

明亮事情此前,先讲八个您经常生活中最常干的事:取钱。 
譬如你去ATM机取一千块钱,大体有八个步骤:首先输入密码金额,银行卡扣掉1000元钱;然后ATM出一千元钱。那多个步骤必须是要么都进行大概都不执行。假若银行卡扣除了1000块不过ATM出钱败北以来,你将会损失一千元;借使银行卡扣钱战败但是ATM却出了1000块,那么银行将损失一千元。所以,假诺二个步骤成功另贰个步骤失利对两者都不是好事,假如不管哪3个步骤战败了现在,整个取钱进程都能回滚,也等于一点一滴裁撤全部操作的话,那对互相都以极好的。 
业务就是用来缓解类似难题的。事务是一比比皆是的动作,它们综合在一道才是3个完好的干活单元,那个动作必须全方位做到,假若有2个全盘皆输以来,那么事务就会回滚到最开头的情况,就像是什么都没爆发过一样。 
在集团级应用程序开发中,事务管理必不可少的技巧,用来确定保证数量的完整性和一致性。 
事务有八个特色:ACID

  • 原子性(Atomicity):事务是三个原子操作,由一层层动作结合。事务的原子性确定保障动作要么全体成就,要么完全不起功用。
  • 一致性(Consistency):一旦事情实现(不管成功依然败诉),系统必须保证它所建立模型的政工处于相同的境况,而不会是局地形成都部队分失利。在切切实实中的数据不该被弄坏。
  • 隔开分离性(Isolation):或许有成都百货上千事务会同时处理相同的数据,由此每种业务都应当与其他工作隔断开来,幸免数据损坏。
  • 持久性(Durability):一旦事情完结,无论发生哪些系统错误,它的结果都不该遭到震慑,那样就能从任何系统崩溃中恢复生机过来。平时情形下,事务的结果被写到持久化存款和储蓄器中。

3.2.1 使用TransactionTemplate

行使TransactionTemplate和行使别的Spring模板,如JdbcTempalte和HibernateTemplate是同等的艺术。它应用回调方法,把应用程序从拍卖取得和自由能源中解脱出来。仿佛别的模板,TransactionTemplate是线程安全的。代码片段:

    TransactionTemplate tt = new TransactionTemplate(); // 新建一个TransactionTemplate
    Object result = tt.execute(
        new TransactionCallback(){  
            public Object doTransaction(TransactionStatus status){  
                updateOperation();  
                return resultOfUpdateOperation();  
            }  
    }); // 执行execute方法进行事务管理

运用TransactionCallback()能够重返二个值。假诺应用TransactionCallbackWithoutResult则从未重返值。

2.2.2 隔开分离级别

政工的第四个维度就是割裂级别(isolation
level)。隔绝级别定义了二个作业恐怕受任何并发事务影响的水平。 
(1)并发事务引起的难题 
在典型的应用程序中,四个事情并发运转,平时会操作相同的数量来实现各自的天职。并发即使是必须的,但只怕会招致一下的难点。

  • 脏读(Dirty
    reads)——脏读爆发在2个事情读取了另1个事情改写但从未提交的数目时。假若改写在稍后被回滚了,那么首先个工作获取的数码正是没用的。
  • 不得重复读(Nonrepeatable
    read)——不可重复读产生在1个工作执行同样的查询一次或三次以上,可是每回都获得差别的数额时。这一般是因为另贰个产出事务在三次询问时期开展了翻新。
  • 幻读(Phantom
    read)——幻读与不足重复读类似。它发生在贰个事务(T1)读取了几行数据,接着另一个产出事务(T2)插入了一部分数据时。在随之的查询中,第1个工作(T1)就会发现多了部分原先不设有的记录。

不行重复读与幻读的分别

不可重复读的主要性是修改: 
一点差异也没有于的原则, 你读取过的数码, 再度读取出来发现实价值不雷同了 
比如:在事情第11中学,玛丽 读取了祥和的薪资为一千,操作并没有完结

    con1 = getConnection();  
    select salary from employee empId ="Mary";

在事务第22中学,那时财务职员修改了玛丽的工资为两千,并提交了事务.

    con2 = getConnection();  
    update employee set salary = 2000;  
    con2.commit();

在事情第11中学,玛丽 再一次读取本人的报酬时,薪俸变为了三千

    //con1  
    select salary from employee empId ="Mary";

在1个作业中左右五次读取的结果并不一致,导致了不可重复读。

幻读的主要在于新增或许去除: 
无差别于的准绳, 第一次和第二回读出来的记录数不平等 
譬如说:如今工钱为一千的职员和工人有十一位。事务1,读取全部工资为一千的职员和工人。

    con1 = getConnection();  
    Select * from employee where salary =1000;

共读取10条记录

此刻另1个事务向employee表插入了一条职员和工人记录,薪酬也为壹仟

    con2 = getConnection();  
    Insert into employee(empId,salary) values("Lili",1000);  
    con2.commit();

事务1再一次读取全部工资为一千的员工

    //con1  
    select * from employee where salary =1000;

共读取到了11条记下,那就发生了幻像读。

从总的结果来看,
如同不可重复读和幻读都突显为一次读取的结果不雷同。但万一您从决定的角度来看,
两者的分别就相比大。 
对在此之前者, 只须要锁住满足条件的记录。 
对于后人, 要锁住满意条件及其相近的笔录。

(2)隔绝级别

隔离级别 含义
ISOLATION_DEFAULT 使用后端数据库默认的隔离级别
ISOLATION_READ_UNCOMMITTED 最低的隔离级别,允许读取尚未提交的数据变更,可能会导致脏读、幻读或不可重复读
ISOLATION_READ_COMMITTED 允许读取并发事务已经提交的数据,可以阻止脏读,但是幻读或不可重复读仍有可能发生
ISOLATION_REPEATABLE_READ 对同一字段的多次读取结果都是一致的,除非数据是被本身事务自己所修改,可以阻止脏读和不可重复读,但幻读仍有可能发生
ISOLATION_SERIALIZABLE 最高的隔离级别,完全服从ACID的隔离级别,确保阻止脏读、不可重复读以及幻读,也是最慢的事务隔离级别,因为它通常是通过完全锁定事务相关的数据库表来实现的

2.1.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只须求装配1个JPA实体管理工科厂(javax.persistence.EntityManagerFactory接口的妄动完成)。JpaTransactionManager将与由工厂所发出的JPA
EntityManager合营来创设事务。

转载本站文章请注明出处:bway883.com https://www.piworx.com/?p=7003

上一篇:

下一篇:

相关文章

网站地图xml地图