精华内容
下载资源
问答
  • try restarting transaction at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:946) at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:2985) at com.mysql.jdbc.MysqlIO.sendCommand...
  • Transaction不管在WEB开发...一、 Transaction是什么 Transaction是指一系列不可分割的改动数据库的操作。这里的“一系列”操作指的是一组SQL语句;“不可分割”就意味着一致性和完整性,要么这一系列操作全部co...

    Transaction不管在WEB开发还是数据库中都是相当重要的概念。在WEB开发框架中Transaction的实现方面却有着很多的不同。下面以J2EE介绍Transaction。

    一、 Transaction是什么

    Transaction是指一系列不可分割的改动数据库的操作。这里的“一系列”操作指的是一组SQL语句;“不可分割”就意味着一致性和完整性,要么这一系列操作全部commit(提交),要么就全部rollback(回滚)。(如果一系列的操作只包含enquiry操作,那么这些操作也不是Transaction) 所以常见的代码结构

        public void save(User user) {
        Session s = sessionFactory.openSession();
        s.beginTransaction();
        s.save(user);
        //…
        s.getTransaction().commit();
        s.close();
        }
    

    二、在J2EE中,Transaction主要有几大类,具体有几种?

    在J2EE中,Transaction主要有

    • Bean-Managed Transaction
      • JDBC Transaction
      • JTA Transaction
    • Container-Managed Transaction

    三、JDBC Transaction

    1. 定义
      JDBC Transaction是指由Database本身去管理的事务。通过显示调用Connection接口的commit和rollback方法来完成事务的提交和回滚。事务结束的边界是commit或者rollback方法的调用,开始的边界于组成当前事务的所有statement中的第一个被执行的时候。
    2. 使用
      使用JDBC Transaction的顺序是获取session(tx = session.beginTransaction()),提交(tx.commit),关闭session(session.close())
    3. 代码示例

      Session session = sf.openSession(); 
      Transaction tx = session.beginTransactioin(); 
      ... 
      session.flush(); 
      tx.commit(); 
      session.close();
      

    四、JTA Transaction

    1. 定义
      JTA Transaction是指由J2EE Transaction manager去管理的事务。是调用UserTransaction接口的begin,commit和rollback方法来完成事务范围的界定,事务的提交和回滚。JTA Transaction可以实现同一事务对应不同的数据库,但是它仍然无法实现事务的嵌套。
    2. 使用
      如果需要在EJB中使用Hibernate,或者准备用JTA来管理跨Session的长事务,那么就需要使用JTA Transaction。使用JTA Transaction的顺序是先启动Transaction,然后启动Session,关闭Session,最后提交Transaction
    3. 代码示例

      public void withdrawCash(double amount) {
          UserTransaction ut = context.getUserTransaction();
          try {
             ut.begin();
             updateChecking(amount);
             machineBalance -= amount;
             insertMachine(machineBalance);
             ut.commit();
          } catch (Exception ex) {
              try {
                 ut.rollback();
              } catch (SystemException syex) {
                  throw new EJBException
                     ("Rollback failed: " + syex.getMessage());
              }
              throw new EJBException 
                 ("Transaction failed: " + ex.getMessage());
           }
      }
      

    五、Container-Managed Transaction

    Container-Managed Transaction,就是由Container(容器)负责管理的Transaction。其最大的特点是不需要显式界定事务的边界,也不需要显式的提交或者回滚事务,这一切都由Container来替我们完成。我们需要做的就是设定在一个Bean中,哪些方法是跟事务相关的,同时设定它们的Transaction Attribute既可。

    版权声明:本文为博主原创文章,未经博主允许不得转载。

    转载于:https://www.cnblogs.com/coderfish/p/4875471.html

    展开全文
  • 开启事务注解EnableTransactionManagement,该注解往容器中导入了导入...(此处不讲解为什么会被调用,重点讲解Transaction注解)protected String[] selectImports(AdviceMode adviceMode) ...

    开启事务注解EnableTransactionManagement,该注解往容器中导入了导入TransactionManagementConfigurationSelector组件。该组件有个方法,在容器刷新的时候会被调用。(此处不讲解为什么会被调用,重点讲解Transaction注解)

    protected String[] selectImports(AdviceMode adviceMode) {

    switch (adviceMode) {

    case PROXY:return new String[] {AutoProxyRegistrar.class.getName(),

    ProxyTransactionManagementConfiguration.class.getName()};

    case ASPECTJ:

    return new String[] {

    TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME};

     default:

     return null;

     }

     }

    EnableTransactionManagement默认是AdviceMode mode() default AdviceMode.PROXY;所以

    AutoProxyRegistrar和ProxyTransactionManagementConfiguration会被加载到容器中。

    AutoProxyRegistrar功能是往容器中注册了InfrastructureAdvisorAutoProxyCreator是个BeanPostProcessor后置处理器。

    ProxyTransactionManagementConfiguration利用@Bean注解往容器中添加多个bean。(BeanFactoryTransactionAttributeSourceAdvisor是个Advisor和前面Aop中@Before一样都是通知方法,但是此处的是手动导入的,Aop是自己自动生成的)。

    在bean生成完成以后会调用后置处理器初始化。会去查找bean有没有合适的通知方法。所以重点是在找通知方法,找到了合适的就会生成代理对象。

    //简单的分析一下流程

    AbstractAutowireCapableBeanFactory#initializeBean() ->

    AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization() ->

    AbstractAutoProxyCreator#postProcessAfterInitialization() ->

    AbstractAutoProxyCreator#wrapIfNecessary()->

    AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean()

    /**

     * 寻找可用的通知方法

     */

     protected List findEligibleAdvisors(Class> beanClass, String beanName) {

     //寻找所有的Advisors,会去容器遍历所有类型为Advisor的bean,

     //BeanFactoryTransactionAttributeSourceAdvisor就是我们手动导入的Advisor

     List candidateAdvisors = findCandidateAdvisors();

     //在所有的Advisors,看是否有beanClass匹配的

     List eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);

     extendAdvisors(eligibleAdvisors);

     if (!eligibleAdvisors.isEmpty()) {

     eligibleAdvisors = sortAdvisors(eligibleAdvisors);

     }

     return eligibleAdvisors;

     }

    //找到所有的Advisors,剩下就是是否有匹配的findAdvisorsThatCanApply()方法//最终走到TransactionAttributeSourcePointcut#matches//->AbstractFallbackTransactionAttributeSource#computeTransactionAttribute

    `javaprotected TransactionAttribute computeTransactionAttribute(Method method, Class> targetClass) {

     //判断方法修饰符是不是Public,allowPublicMethodsOnly()默认是true的

     if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {

     return null;

     }

     // 这里面就是判断方法上有没有Transactional注解,有进行解析操作并返回。

     TransactionAttribute txAttr = findTransactionAttribute(specificMethod);

     if (txAttr != null) {

     return txAttr;

     }

     //代码每贴全,为了少点没用的东西。。。。

    那要是找了合适的通知方法,就生成代理对象,并设置回调函数。设置回调函数是CglibAopProxy.DynamicAdvisedInterceptor的intercept方法,该方法有个getInterceptorsAndDynamicInterceptionAdvice获取合适的拦截器。(事务的拦截器是TransactionInterceptor)

    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

     //获取目标对象,不是代理对象

     target = getTarget();

     if (target != null) {

     targetClass = target.getClass();

     }

     //获取方法合适的拦截器

     List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

     Object retVal;

     //没有合适的拦截器并且方法的修饰符是Public

     if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {

     Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);

     //会调用目标方法

     retVal = methodProxy.invoke(target, argsToUse);

     }

     else {

     /*

     * 1.有合适的拦截器:跟单网www.gendan5.com会去执行拦截器TransactionInterceptor#invoke(),

     * 事务的提交,回滚等一系列操作都在里面。具体是调去了

     * TransactionAspectSupport#invokeWithinTransaction()方法

     * 2.没有合适的拦截器并且方法的修饰符不是Public:这里面也会去调目标方法

     * (这里简单可以走进去看一下)

     */

     retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();

     }

     retVal = processReturnType(proxy, target, method, retVal);

     return retVal;

     }

    展开全文
  • 什么是事务transaction

    2009-11-26 18:14:27
    什么是事务(transaction) 事务(Transaction)并发控制的基本单位。所谓事务,它一个操作序列,这些操作要么都执行,要么都不执行,它一个不可分割的工作单位。例如,银行转帐工作:从一个帐号扣款并使另一个...
    文章出处[url]http://zht1933.iteye.com/blog/479808[/url]

    什么是事务(transaction)

    事务(Transaction)是并发控制的基本单位。所谓事务,它是一个操作序列,这些操作要么都执行,要么都不执行,它是一个不可分割的工作单位。例如,银行转帐工作:从一个帐号扣款并使另一个帐号增款,这两个操作要么都执行,要么都不执行。所以,应该把他们看成一个事务。事务是数据库维护数据一致性的单位,在每个事务结束时,都能保持数据一致性。

    一个事务是有下列属性的一个工作单元:
    原子性(ATOMICITY):
    一个事务要被完全的无二义性的做完或撤消。在任何操作出现一个错误的情况下,构成事务的所有操作的效果必须被撤消,数据应被回滚到以前的状态。

    一致性(CONSISTENCY):
    一个事务应该保护所有定义在数据上的不变的属性(例如完整性约束)。在完成了一个成功的事务时,数据应处于一致的状态。换句话说,一个事务应该把系统从一个一致-状态转换到另一个一致状态。举个例子,在关系数据库的情况下,一个一致的事务将保护定义在数据上的所有完整性约束。

    隔离性(ISOLATION):
    在同一个环境中可能有多个事务并发执行,而每个事务都应表现为独立执行。串行的执行一系列事务的效果应该同于并发的执行它们。这要求两件事:
    在一个事务执行过程中,数据的中间的(可能不一致)状态不应该被暴露给所有的其他事务。
    两个并发的事务应该不能操作同一项数据。数据库管理系统通常使用锁来实现这个特征。

    持久性(DURABILITY):
    一个被完成的事务的效果应该是持久的。


    如何标识一个事务
    在SQL Server中,通常事务是指以BEGIN TRAN开始,到ROLLBACK或一个相匹配的COMMIT之间的所有语句序列。ROLLBACK表示要撤消(Undo)该事务已做的一切操作,回退到事务开始的状态。COMMIT表示提交事务中的一切操作,使得对数据库的改变生效。
    在SQL Server中,对事务的管理包含三个方面:
    • 事务控制语句:它使程序员能指明把一系列操作(Transact - SQL命令)作为一个工作单位来处理。
    • 锁机制(Locking):封锁正被一个事务修改的数据,防止其他用户访问到“不一致”的数据。
    • 事务日志(Transaction Log):使事务具有可恢复性。

    SQL Server的锁机制
    所谓封锁,就是一个事务可向系统提出请求,对被操作的数据加锁(Lock)。其他事务必须等到此事务解锁(Unlock)之后才能访问该数据。从而,在多个用户并发访问数据库时,确保不互相干扰(隔离性)。可锁定的单位是:行、页、表、盘区和数据库。
    1. 锁的类型
    SQL Server支持三种基本的封锁类型:共享(S)锁,排它(X)锁和更新(U)锁。封锁的基本粒度为行。
    1) 共享(S)锁:用于读操作。
    • 多个事务可封锁一个共享单位的数据。
    • 任何事务都不能修改加S锁的数据。
    • 通常是加S锁的数据被读取完毕,S锁立即被释放。
    2) 独占(X)锁:用于写操作。
    • 仅允许一个事务封锁此共享数据。
    • 其他任何事务必须等到X锁被释放才能对该数据进行访问。
    • X锁一直到事务结束才能被释放。
    3) 更新(U)锁。
    • 用来预定要对此页施加X锁,它允许其他事务读,但不允许再施加U锁或X锁。
    • 当被读取数据页将要被更新时,则升级为X锁。
    • U锁一直到事务结束时才能被释放。

    2. 三种锁的相容性
    如下表简单描述了三种锁的相容性:
    通常,读操作(SELECT)获得共享锁,写操作(INSERT、DELETE)获得独占锁;而更新操作可分解为一个有更新意图的读和一个写操作,故先获得更新锁,然后再升级为独占锁。
    执行的命令 获得锁 其他进程可以查询? 其他进程可以修改?
    Select title_id from titles S Yes No
    delete titles where price>25 X No No
    insert titles values( ...) X No No
    update titles set type=“general” U Yes No
    where type=“business” 然后 X No No

    使用索引降低锁并发性
    我们为什么要讨论锁机制?如果用户操作数据时尽可能锁定最少的数据,这样处理过程,就不会等待被锁住的数据解锁,从而可以潜在地提高SQL Server的性能。如果有200个用户打算修改不同顾客的数据,仅对存储单个顾客信息的单一行进行加锁要比锁住整个表好得多。那么,用户如何只锁定行而不是表呢?当然是使用索引了。正如前面所提到的,对存有要修改数据的字段使用索引可以提高性能,因为索引能直接找到数据所在的页面,而不是搜索所有的数据页面去找到所需的行。如果用户直接找到表中对应的行并进行更新操作,只需锁定该行即可,而不是锁定多个页面或者整个表。性能的提高不仅仅是因为在修改时读取的页面较少,而且锁定较少的页面潜在地避免了一个用户在修改数据完成之前其他用户一直等待解锁的情况。


    体验SQL语言的事务机制
      作为大型的企业级数据库,SQL Server2000对事务提供了很好的支持。我们可以使用SQL语句来定义、提交以及回滚一个事务。
      如下所示的SQL代码定义了一个事务,并且命名为"MyTransaction":

    DECLARE @TranName VARCHAR(20)

    SELECT @TranName = ’MyTransaction’
    BEGIN TRANSACTION @TranName
    GO
    USE pubs
    GO
    UPDATE roysched
    SET royalty = royalty * 1.10
    WHERE title_id LIKE ’PC%’
    GO
    COMMIT TRANSACTION MyTransaction
    GO

      这里用到了SQL Server2000自带的示例数据库pubs,提交事务后,将为所有畅销计算机书籍支付的版税增加 10%。

      打开SQL Server2000的查询分析器,选择pubs数据库,然后运行这段程序,结果显而易见。

    可是如何在C#程序中运行呢?我们记得在普通的SQL查询中,一般需要把查询语句赋值给SalCommand.CommandText属性,这里也就像普通的SQL查询语句一样,将这些语句赋给SqlCommand.CommandText属性即可。要注意的一点是,其中的"GO"语句标志着SQL批处理的结束,编写SQL脚本是需要的,但是在这里是不必要的。我们可以编写如下的程序来验证这个想法:  

    //TranSql.csusing System;
    using System.Data;
    using System.Data.SqlClient;
    namespace Aspcn
    {
     public class DbTranSql
     {
      file://将事务放到SQL Server中执行
      public void DoTran()
      {
       file://建立连接并打开
       SqlConnection myConn=GetConn();myConn.Open();
       SqlCommand myComm=new SqlCommand();
       try
       {
        myComm.Connection=myConn;
        myComm.CommandText="DECLARE @TranName VARCHAR(20) ";
        myComm.CommandText+="SELECT @TranName = ’MyTransaction’ ";
        myComm.CommandText+="BEGIN TRANSACTION @TranName ";
        myComm.CommandText+="USE pubs ";
        myComm.CommandText+="UPDATE roysched SET royalty = royalty * 1.10 WHERE title_id LIKE ’Pc%’ ";
        myComm.CommandText+="COMMIT TRANSACTION MyTransaction ";
        myComm.ExecuteNonQuery();
       }
       catch(Exception err)
       {
        throw new ApplicationException("事务操作出错,系统信息:"+err.Message);
       }
       finally
       {
        myConn.Close();
       }
      }
      file://获取数据连接
      private SqlConnection GetConn()
      {
       string strSql="Data Source=localhost;Integrated Security=SSPI;user id=sa;password=";
       SqlConnection myConn=new SqlConnection(strSql);
       return myConn;
      }
     }

     public class Test
     {
      public static void Main()
      {
       DbTranSql tranTest=new DbTranSql();
       tranTest.DoTran();
       Console.WriteLine("事务处理已经成功完成。");
       Console.ReadLine();
      }
     }
    }

      注意到其中的SqlCommand对象myComm,它的CommandText属性仅仅是前面SQL代码字符串连接起来即可,当然,其中的"GO"语句已经全部去掉了。这个语句就像普通的查询一样,程序将SQL文本事实上提交给DBMS去处理了,然后接收返回的结果(如果有结果返回的话)。

      很自然,我们最后看到了输出"事务处理已经成功完成",再用企业管理器查看pubs数据库的roysched表,所有title_id字段以"PC"开头的书籍的royalty字段的值都增加了0.1倍。

      这里,我们并没有使用ADO.net的事务处理机制,而是简单地将执行事务的SQL语句当作普通的查询来执行,因此,事实上该事务完全没有用到.net的相关特性。
    展开全文
  • 本文介绍了什么是MySQL中的事务,并且对事务这一知识点进行详细说明,最后通过案例的方式说明了事务操作语法的使用。

    事务是个啥?

    事务(Transaction)一般是指要做的或所做的事情。数据库事务(Database Transaction)是由SQL语句组成的逻辑处理单元。一个事务是一条SQL语句或一组SQL语句组成的。事务中的SQL语句就是一个整体,事务中语句全部正确,执行事务,若有一条出错,则事务中的语句全部不执行。

    MySQL事务常用于操作量大,复杂性高的数据,避免因误操作而出现数据信息异常,确保了数据的一致性和完整性。

    事务的四大特性(ACID)

    1.原子性[不可分割性](Atomicity):一个事务中的所有操作,要么全部执行,要么全部不执行,不存在只执行部分语句情况。若事务在执行过程中出现错误,则会被回滚(Rollback)到事务开始前的状态,并不会对数据进行实际更改。

    2.一致性(Consistency):事务开始前,数据库处于一个一致性状态,事务结束后,数据库必须也处于一致性状态。例如:银行转账后,两个账户金额之和与转账前相同。

    3.隔离性[独立性](Isolation):避免一个事务执行时被其他事务所干扰。即一个事务中的操作对其他事务是隔离的,各个事务之间不能互相干扰。

    4.持久性(Durability):一个事务提交之后,对数据库的修改就是永久的,即使服务宕掉也可以进行数据恢复。

    提交方式

    1)自动提交,这是MySQL数据库的默认提交事务的方式,即输入完SQL语句后,回车自动提交事务。

    2)手动提交,通过修改将默认提交方式改为手动提交,把SQL语句输入完之后,执行commit;才将其提交,否则一直不提交。

    注意事项

    1)MySQL 中只有使用了 Innodb 和bdb存储引擎的数据库或表才支持事务。

    2)对于少量的数据更新,建议不使用事务,直接输入SQL语句更加快捷。

    3)事务中的SQL语句要么全部执行,要么全部不执行,写入时尽量避免语句错误。

    事务控制语句

    事务控制语句是使用事务的基础,务必牢记。

    BEGIN或START TRANSACTION:开启一个事务。

    ROLLBACK或ROLLBACK WORK:手动回滚,结束用户的事务,还原到创建事务之前的状态。

    SAVEPOINT EnglishNUM:在事务中创建保存点,可以通过回滚恢复到保存点的位置。

    COMMIT或COMMIT WORK:提交事务,并将数据库进行的所有操作永久修改。

    RELEASE SAVEPOINT EnglishNUM:删除一个事务的保存点。

    ROLLBACK TO EnglishNUM:把事务回滚到指定保存点位置。

    事务实际应用

    创建一个表,并在其中插入一些数据,用于测试。

    mysql> create table test(id int auto_increment primary key,name varchar(6) not null,age tinyint unsigned not null);
    mysql> insert into test values(1,'张三',23),(2,'李四',24),(3,'王五',25);
    

    查看表中记录

    mysql> select * from test;
    +----+--------+-----+
    | id | name   | age |
    +----+--------+-----+
    |  1 | 张三   |  23 |
    |  2 | 李四   |  24 |
    |  3 | 王五   |  25 |
    +----+--------+-----+
    

    事务操作案例

    接下来就开始测试了

    创建事务:begin或start transaction

    提交事务:commit

    mysql> begin;
    

    开启事务后,在其中进行的操作在没有提交之前,是不会对数据库的实际数据进行修改的,在事务中的查看是将你操作后的效果显示出来罢了。对于谨慎操作时,还是比较有效果的。

    mysql> delete from test where id=1;	 删除id为1的记录
    mysql> select * from test;	在事务中查看test表记录
    +----+--------+-----+
    | id | name   | age |
    +----+--------+-----+
    |  2 | 李四   |  24 |
    |  3 | 王五   |  25 |
    +----+--------+-----+
    

    在事务中查看,id为1的记录是已经消失了,但新建一个终端,登录到数据库中查看,发现id为1的记录依然存在。

    mysql> select * from test;
    +----+--------+-----+
    | id | name   | age |
    +----+--------+-----+
    |  1 | 张三   |  23 |
    |  2 | 李四   |  24 |
    |  3 | 王五   |  25 |
    +----+--------+-----+
    

    回到创建了事务的终端,将事务提交后,发现操作才会实际执行,也就是删除id为1的记录。

    mysql> commit;
    mysql> select * from test;
    +----+--------+-----+
    | id | name   | age |
    +----+--------+-----+
    |  2 | 李四   |  24 |
    |  3 | 王五   |  25 |
    +----+--------+-----+
    

    回滚操作案例

    在使用回滚(rollback)的时候需要注意,回滚只在事务中才会生效,若事务已经提交,则对数据的修改是永久的,无法通过回滚还原。

    回滚:rollback

    查看test表记录

    mysql> select * from test;
    +----+--------+-----+
    | id | name   | age |
    +----+--------+-----+
    |  2 | 李四   |  24 |
    |  3 | 王五   |  25 |
    +----+--------+-----+
    

    创建一个事务,并对数据进行修改

    mysql> begin;
    mysql> update test set name='张三' where id=2;
    mysql> update test set name='赵六' where id=3;
    

    将姓名修改后,查看test表记录

    mysql> select * from test;
    +----+--------+-----+
    | id | name   | age |
    +----+--------+-----+
    |  2 | 张三   |  24 |
    |  3 | 赵六   |  25 |
    +----+--------+-----+
    

    想要将一切都还原,只需要将回滚一下就可以了。

    mysql> rollback;
    mysql> select * from test;
    +----+--------+-----+
    | id | name   | age |
    +----+--------+-----+
    |  2 | 李四   |  24 |
    |  3 | 王五   |  25 |
    +----+--------+-----+
    

    这样一切都还原到创建事务之前的状态了,没有对数据进行任何操作,也可以将事务提交,并且不会出现报错。

    mysql> commit;
    

    回滚点操作案例

    对于回滚操作,还是有些死板的,毕竟直接回滚会将事务中所有的SQL语句删除,而创建回滚点(Rollback point)就不一样了,将任务输入一半时,可以创建一个回滚点,那么后续的SQL语句出错,回滚到保存的回滚点,就可以少输入一半的SQL语句,但要注意,虽说回滚点可以存在多个,但只能回滚1次。

    创建回滚点:savepoint 英文字母数字

    转到回滚点:rollback to 英文字母数字

    还是先查看test表记录

    mysql> select * from test;
    +----+--------+-----+
    | id | name   | age |
    +----+--------+-----+
    |  2 | 李四   |  24 |
    |  3 | 王五   |  25 |
    +----+--------+-----+
    

    先创建一个回滚点

    mysql> savepoint a1;
    

    接着对记录进行修改操作

    mysql> update test set name='哈哈哈' where id=2;
    mysql> update test set name='嘿嘿嘿' where id=3;
    

    创建第二个回滚点

    mysql> savepoint a2;
    

    删除一条记录

    mysql> delete from test where id=3;
    

    查看修改后的test表记录

    mysql> select * from test;
    +----+-----------+-----+
    | id | name      | age |
    +----+-----------+-----+
    |  2 | 哈哈哈    |  24 |
    +----+-----------+-----+
    

    接下来就可以通过回滚点进行回滚。

    在回滚的时候需要注意,可以按照倒序的方式进行回滚,也就是有1,2两个回滚点,先回滚2,再回滚1。

    而另一种方式是按照顺序进行回滚,先回滚1,但是2就无法进行回滚了,回滚到1后,其中保存的只是回滚点1中的之前的数据,并没有回滚点2中的数据。简单点来说,就是游戏的存档,你打完第一关存档,打完第二关也存档,当你回到第一关存档中后,你还需要从新过第二关是一个道理。

    转到回滚点2中

    mysql> rollback to a2;
    mysql> select * from test;
    +----+-----------+-----+
    | id | name      | age |
    +----+-----------+-----+
    |  2 | 哈哈哈    |  24 |
    |  3 | 嘿嘿嘿    |  25 |
    +----+-----------+-----+
    

    转到会滚点1中

    mysql> rollback to a1;     
    mysql> select * from test;
    +----+--------+-----+
    | id | name   | age |
    +----+--------+-----+
    |  2 | 李四   |  24 |
    |  3 | 王五   |  25 |
    +----+--------+-----+
    

    删除回滚点

    最后将创建的回滚点删除

    mysql> release savepoint a1;
    
    展开全文
  • 由于在dao用的:session 而不是 hibernateTemplate先说一下HibernateTemplate与session的区别使用方法没有多大的区别我们使用HibernateTemplate,有一个很重要的原因就在于我们不想直接控制事务,不想直接去获取,...
  • mybatis事务是什么 JdbcTransaction 和 ManagedTransaction的区别又是什么啊 望 大神解惑 谢谢
  • 什么是事务(transaction)?它有什么好处 为了完成对数据的操作,企业应用经常要求并发访问在多个构件之间共享的数据。这些应用在下列条件下应该维护数据的完整性(由应用的商务规则来定义):  分布式访问一个单独的...
  • 查了一下日志文件,发现一些奇怪的现象,比如有些锁在Insert时产生的,有些死锁对同一个对象产生的。于是在解决这些问题的同时,仔细研究了一下TX锁,总结了产生TX锁的各种情况。数据记录被锁我们知道,Oracle中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,568
精华内容 1,427
关键字:

transaction是什么