事务 订阅
事务(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),指一个事务一旦提交,它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。
收起全文
精华内容
下载资源
问答
  • 事务模板接入(spring的编程式事务)

    万次阅读 多人点赞 2019-07-31 18:35:32
    事务模板接入 这里接入的是spring的编程式事务,代理一下spring的TransactionTemplate就可以了。 importorg.springframework.transaction.TransactionException; importorg.springframework.transaction....

    事务模板接入

    这里接入的是spring的编程式事务,代理一下spring的TransactionTemplate就可以了。

     

    import org.springframework.transaction.TransactionException;

    import org.springframework.transaction.support.TransactionCallback;

    import org.springframework.transaction.support.TransactionTemplate;

     

    /**

     * 事务模板

     *

     * @author jiacheng.yjc

     * @version $Id: TranscationTemplate.java, v 0.1 2015年11月18日 上午11:17:58 jiacheng.yjc Exp $

     */

    public class TrancTemplateImpl implements TrancTemplate {

     

        private TransactionTemplate transactionTemplate;

        //这个是为了一个事务不够的时候也不用再new一个,直接用这个就行

        private TransactionTemplate transactionNewTemplate;

     

        /**

         *

         * @see com.mybank.bkloanapply.core.service.component.tx.TrancTemplate#execute(org.springframework.transaction.support.TransactionCallback)

         */

        @Override

        public <T> T execute(TransactionCallback<T> actionthrows TransactionException {

            return transactionTemplate.execute(action);

        }

     

        /**

         *

         * @see com.mybank.bkloanapply.core.service.component.tx.TrancTemplate#executeReqNew(org.springframework.transaction.support.TransactionCallback)

         */

        @Override

        public <T> T executeReqNew(TransactionCallback<T> actionthrows TransactionException {

            return transactionNewTemplate.execute(action);

        }

     

        /**

         * Setter method for property <tt>transactionTemplate</tt>.

         *

         * @param transactionTemplate value to be assigned to property transactionTemplate

         */

        public void setTransactionTemplate(TransactionTemplate transactionTemplate) {

            this.transactionTemplate = transactionTemplate;

        }

     

        /**

         * Setter method for property <tt>transactionNewTemplate</tt>.

         *

         * @param transactionNewTemplate value to be assigned to property transactionNewTemplate

         */

        public void setTransactionNewTemplate(TransactionTemplate transactionNewTemplate) {

            this.transactionNewTemplate = transactionNewTemplate;

        }

    }

     

    模板的接入使用

    /**

         * 测试用例,插入一条日志记录

         *

         */

        @Override

        public String logTest(LogModel logModel) {

            final LogModel logModel_ = logModel;

            trancTemplate.execute(new TransactionCallback<LogModel>() {

                @Override

                public LogModel doInTransaction(TransactionStatus status) {

                    logComponent.insert(logModel_);

                    //do otherthings…

                    return logModel_;

                }

            });

            return "执行成功";

    }

    当insert语句执行出错或者do otherthings时出错都会自动回滚,不需要手动trycatch然后status.setRollbackOnly();回滚,很方便。

    展开全文
  • 事务ACID理解

    万次阅读 多人点赞 2018-09-06 21:26:20
    事务管理(ACID) 谈到事务一般都是以下四点 原子性(Atomicity) 原子性是指事务是一个不可分割的工作单位,事务中的操作要么都发生,要么都不发生。 一致性(Consistency) 事务前后数据的完整性必须保持一致...

    事务管理(ACID)

    谈到事务一般都是以下四点

    原子性(Atomicity)
    原子性是指事务是一个不可分割的工作单位,事务中的操作要么都发生,要么都不发生。
    一致性(Consistency)
    事务前后数据的完整性必须保持一致。
    隔离性(Isolation)
    事务的隔离性是多个用户并发访问数据库时,数据库为每一个用户开启的事务,不能被其他事务的操作数据所干扰,多个并发事务之间要相互隔离。
    持久性(Durability)
    持久性是指一个事务一旦被提交,它对数据库中数据的改变就是永久性的,接下来即使数据库发生故障也不应该对其有任何影响

    举个简单的例子理解以上四点

    原子性

    针对同一个事务

    这里写图片描述

    这个过程包含两个步骤

    A: 800 - 200 = 600
    B: 200 + 200 = 400

    原子性表示,这两个步骤一起成功,或者一起失败,不能只发生其中一个动作

    一致性(Consistency)

    针对一个事务操作前与操作后的状态一致

    这里写图片描述

    操作前A:800,B:200
    操作后A:600,B:400

    一致性表示事务完成后,符合逻辑运算

    持久性(Durability)

    表示事务结束后的数据不随着外界原因导致数据丢失

    操作前A:800,B:200
    操作后A:600,B:400
    如果在操作前(事务还没有提交)服务器宕机或者断电,那么重启数据库以后,数据状态应该为
    A:800,B:200
    如果在操作后(事务已经提交)服务器宕机或者断电,那么重启数据库以后,数据状态应该为
    A:600,B:400

    隔离性(Isolation)

    针对多个用户同时操作,主要是排除其他事务对本次事务的影响

    这里写图片描述
    事务一)A向B转账200
    事务二)C向B转账100

    两个事务同时进行,其中一个事务读取到另外一个事务还没有提交的数据,执行步骤如图所示,按照数字顺序执行
    在这里插入图片描述
    隔离性用于解决以上问题


    事务的隔离级别

    脏读:

    指一个事务读取了另外一个事务未提交的数据。

    在这里插入图片描述

    不可重复读:

    在一个事务内读取表中的某一行数据,多次读取结果不同。(这个不一定是错误,只是某些场合不对)

    页面统计查询值
    这里写图片描述
    生成报表的时候,B有人转账进来300(B事务已经提交)
    这里写图片描述

    虚读(幻读)

    是指在一个事务内读取到了别的事务插入的数据,导致前后读取数量总量不一致。
    (一般是行影响,如下图所示:多了一行)

    这里写图片描述

    四种隔离级别设置

    数据库

    set transaction isolation level 设置事务隔离级别
    select @@tx_isolation 查询当前事务隔离级别

    设置描述
    Serializable可避免脏读、不可重复读、虚读情况的发生。(串行化)
    Repeatable read可避免脏读、不可重复读情况的发生。(可重复读)
    Read committed可避免脏读情况发生(读已提交)。
    Read uncommitted最低级别,以上情况均无法保证。(读未提交)

    java

    适当的 Connection 方法,比如 setAutoCommit 或 setTransactionIsolation

    设置描述
    TRANSACTION_SERIALIZABLE指示不可以发生脏读、不可重复读和虚读的常量。
    TRANSACTION_REPEATABLE_READ指示不可以发生脏读和不可重复读的常量;虚读可以发生。
    TRANSACTION_READ_UNCOMMITTED指示可以发生脏读 (dirty read)、不可重复读和虚读 (phantom read) 的常量。
    TRANSACTION_READ_COMMITTED指示不可以发生脏读的常量;不可重复读和虚读可以发生。

    事务演示

    在这里插入图片描述

    这里使用控制台演示,命令行登录方式

    mysql -h localhost -uroot -p
    

    数据测试准备

    create database db_test;
    use db_test;
    
    CREATE TABLE `AMOUNT` (
    `id`  varchar(10) NULL,
    `money`  numeric NULL
    )
    ;
    
    insert into amount(id,money) values('A', 800);
    insert into amount(id,money) values('B', 200);
    insert into amount(id,money) values('C', 1000);
    insert into amount(id,money) values('D', 1000);
    

    在这里插入图片描述
    操作成功如图所示,检查数据:select * from amount;

    mysql事务隔离性相关语句说明

    --  查询当前控制台(客户端)当前事务级别
    SELECT @@session.tx_isolation;   
    SELECT @@tx_isolation;  
    --  设置当前控制台(客户端)当前事务级别
    SET SESSION TRANSACTION ISOLATION LEVEL read uncommitted;  
    SET SESSION TRANSACTION ISOLATION LEVEL read committed;  
    SET SESSION TRANSACTION ISOLATION LEVEL repeatable read;  
    SET SESSION TRANSACTION ISOLATION LEVEL serializable;  
    
    --开启事务
    start transaction;
    --提交事务,同时事务结束
    commit;
    --回退事务,回退操作,同时事务结束
    rollback
    

    案列1:脏读演示,读到其他事务未提交的数据

    操作步骤

    1. 事务一(右):A向B转200,不提交事务
    2. 事务二(左):查看B金额
    3. 事务一(右):回滚事务
    4. 事务二(左):查看B金额

    改变事务二(左)事务级别为READ-UNCOMMITTED
    在这里插入图片描述

    gif演示
    在这里插入图片描述
    转账SQL

    update amount set money = money - 200 where id = 'A';
    update amount set money = money + 200 where id = 'B';
    

    事务二(左)在事务中,查询到其他事务还没有提交(commit/rollback)的事务

    其他事务级别请自行测试(与理论预期一致)

    • 案列2,将事务二(左)在事务设置为REPEATABLE-READ,再看看操作结果(操作步骤同案例1,步骤三改为提交事务-commit)
    • 案列3,将事务二(左)在事务设置为REPEATABLE-READ,再看看操作结果(操作步骤同案例1,步骤三改为提交事务-commit)
    • 案列4,将事务二(左)在事务设置为SERIALIZABLE,再看看操作结果(操作步骤同案例1)

    这里说明一下,SERIALIZABLE事务是串行执行,演示的时候只能由其中一个客户端操作,直到提交事务,另外一个客户端才能操作。

    展开全文
  • 事务

    千次阅读 2019-03-23 17:13:47
    Java事务的类型有三种:JDBC事务、JTA(Java Transaction API)事务、容器事务 1、JDBC事务 JDBC 事务是用 Connection 对象控制的。JDBC Connection 接口( java.sql.Connection )提供了两种事务模式:自动提交和手工...

    事务的三种类型

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

    1、JDBC事务

    JDBC 事务是用 Connection 对象控制的。JDBC Connection 接口( java.sql.Connection )提供了两种事务模式:自动提交和手工提交。 java.sql.Connection 提供了以下控制事务的方法:

    public void setAutoCommit(boolean)
    public boolean getAutoCommit()
    public void commit()
    public void rollback()
    

    使用 JDBC 事务界定时,您可以将多个 SQL 语句结合到一个事务中。JDBC 事务的一个缺点是事务的范围局限于一个数据库连接。一个 JDBC 事务不能跨越多个数据库。

    2.JTA(Java Transaction API)事务

    JTA是一种高层的,与实现无关的,与协议无关的API,应用程序和应用服务器可以使用JTA来访问事务。

    JTA允许应用程序执行分布式事务处理–在两个或多个网络计算机资源上访问并且更新数据,这些数据可以分布在多个数据库上。JDBC驱动程序的JTA支持极大地增强了数据访问能力。

    如果计划用 JTA 界定事务,那么就需要有一个实现 javax.sql.XADataSource 、 javax.sql.XAConnection 和 javax.sql.XAResource 接口的 JDBC 驱动程序。一个实现了这些接口的驱动程序将可以参与 JTA 事务。一个 XADataSource 对象就是一个 XAConnection 对象的工厂。 XAConnection s 是参与 JTA 事务的 JDBC 连接。

    您将需要用应用服务器的管理工具设置 XADataSource 。从应用服务器和 JDBC 驱动程序的文档中可以了解到相关的指导。

    J2EE 应用程序用 JNDI 查询数据源。一旦应用程序找到了数据源对象,它就调用 javax.sql.DataSource.getConnection() 以获得到数据库的连接。

    XA 连接与非 XA 连接不同。一定要记住 XA 连接参与了 JTA 事务。这意味着 XA 连接不支持 JDBC 的自动提交功能。同时,应用程序一定不要对 XA 连接调用 java.sql.Connection.commit() 或者 java.sql.Connection.rollback() 。相反,应用程序应该使用 UserTransaction.begin()、 UserTransaction.commit() 和 serTransaction.rollback() 。

    3、容器事务

    容器事务主要是J2EE应用服务器提供的,容器事务大多是基于JTA完成,这是一个基于JNDI的,相当复杂的API实现。相对编码实现JTA事务管理,我们可以通过EJB容器提供的容器事务管理机制(CMT)完成同一个功能,这项功能由J2EE应用服务器提供。这使得我们可以简单的指定将哪个方法加入事务,一旦指定,容器将负责事务管理任务。这是我们土建的解决方式,因为通过这种方式我们可以将事务代码排除在逻辑编码之外,同时将所有困难交给 J2EE容器去解决。使用EJB CMT的另外一个好处就是程序员无需关心JTA API的编码,不过,理论上我们必须使用EJB。

    三种事务差异:

    1、JDBC事务控制的局限性在一个数据库连接内,但是其使用简单。
    2、JTA事务的功能强大,事务可以跨越多个数据库或多个DAO,使用也比较复杂。
    3、容器事务,主要指的是J2EE应用服务器提供的事务管理,局限于EJB应用使用。

    总结:

    事务控制是构建J2EE应用不可缺少的一部分,合理选择应用何种事务对整个应用系统来说至关重要。一般说来,在单个JDBC 连接连接的情况下可以选择JDBC事务,在跨多个连接或者数据库情况下,需要选择使用JTA事务,如果用到了EJB,则可以考虑使用EJB容器事务。

    参考:https://www.cnblogs.com/baizhanshi/p/5159332.html

    举例: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个方面:

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

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

    参考 https://blog.csdn.net/weixin_37934748/article/details/82774230

    与事务相关的理论

    1.事务(Transaction)的四个属性(ACID)

    原子性(Atomic) 对数据的修改要么全部执行,要么全部不执行。
    一致性(Consistent) 在事务执行前后,数据状态保持一致性。
    隔离性(Isolated) 一个事务的处理不能影响另一个事务的处理。
    持续性(Durable) 事务处理结束,其效果在数据库中持久化

    2.事务并发处理可能引起的问题

    脏读(dirty read):一个事务读取了另一个事务尚未提交的数据,
    不可重复读(non-repeatable read) :一个事务的操作导致另一个事务前后两次读取到不同的数据
    幻读(phantom read) :一个事务的操作导致另一个事务前后两次查询的结果数据量不同。

    3.事务并发处理可能引起的问题

    脏读(dirty read):一个事务读取了另一个事务尚未提交的数据,
    不可重复读(non-repeatable read) :一个事务的操作导致另一个事务前后两次读取到不同的数据
    幻读(phantom read) :一个事务的操作导致另一个事务前后两次查询的结果数据量不同。

    4. 事务隔离级别(Transaction Isolation Levels)

    JDBC提供了5种不同的事务隔离级别,在Connection中进行了定义。
    JDBC定义了五种事务隔离级别

    ISOLATION_DEFAULT这是一个PlatfromTransactionManager默认的隔离级别,使用数据库默认的事务隔离级别.
    ISOLATION_READ_UNCOMMITTED允许脏读、不可重复读和幻读
    ISOLATION_READ_COMMITTED禁止脏读,但允许不可重复读和幻读
    ISOLATION_REPEATABLE_READ禁止脏读和不可重复读,但允许幻读
    ISOLATION_SERIALIZABLE禁止脏读、不可重复读和幻读

    5.事务的传播行为

    7种传播行为

    PROPAGATION_REQUIRED 如果当前没有事务,就新建一个事务,如果已经存在一个事务中,加入到这个事务中。这是最常见的选择。
    PROPAGATION_SUPPORTS 支持当前事务,如果当前没有事务,就以非事务方式执行
    PROPAGATION_MANDATORY 支持当前事务,如果当前没有事务,就抛出异常。
    PROPAGATION_REQUIRES_NEW 新建事务,如果当前存在事务,把当前事务挂起
    PROPAGATION_NOT_SUPPORTED 以非事务方式执行操作,如果当前存在事务,就把当前事务挂起
    PROPAGATION_NEVER 以非事务方式执行,如果当前存在事务,则抛出异常

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

    6.保存点(SavePoint)

    JDBC定义了SavePoint接口,提供在一个更细粒度的事务控制机制。当设置了一个保存点后,可以rollback到该保存点处的状态,而不是rollback整个事务。

    Connection接口的setSavepoint和releaseSavepoint方法可以设置和释放保存点。
    JDBC规范虽然定义了事务的以上支持行为,但是各个JDBC驱动,数据库厂商对事务的支持程度可能各不相同。如果在程序中任意设置,可能得不到想要的效果。为此,JDBC提供了DatabaseMetaData接口,提供了一系列JDBC特性支持情况的获取方法。比如,通过DatabaseMetaData.supportsTransactionIsolationLevel方法可以判断对事务隔离级别的支持情况,通过DatabaseMetaData.supportsSavepoints方法可以判断对保存点的支持情况。
    参考 https://blog.csdn.net/weixin_40263776/article/details/79521595

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

    注解方式:

    @Transactional只能被应用到public方法上(aop方式实现的),对于其它非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>
    

    注意:
    aop方式的是无法拦截私有方法的,因为aop底层是代理,

    jdk是代理接口,私有方法必然不会存在在接口里,所以就不会被拦截到;
    cglib是子类,private的方法照样不会出现在子类里,也不能被拦截

    参考 https://www.cnblogs.com/protected/p/6652188.html

    代码 https://github.com/baiyanlang2016/springboot-transaction

    展开全文
  • 在Spring AOP切面中启用新事务

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

    在工作中有一个在切面中需要记录一下操作日志的需求,而且要求这些操作日志要存入数据库,并且无论业务层有什么异常,日志照常记录,那就不能沿用业务层的事务,而是需要新启一个事务了。
    sping的声明式事务就是靠AOP来实现的,一般事务都在业务层中启用,那如果要在AOP的逻辑中启用一个新的事务要怎么做呢?比如下面的例子:

    //定义一个切点,这里指com.lidehang.remote包下所有的类的方法
    @Pointcut("execution(public * com.lidehang.remote..*.*(..))")
     public void remote(){}
    
    //切点指定的方法执行完返回后调用
    @AfterReturning(returning = "ret", pointcut = "remote()")
     public void doAfterReturning(JoinPoint joinPoint,Object ret) throws Throwable {
     	//一些切面逻辑,包含了数据库操作,为了即便业务层的原事务回滚也不会影响切面中的数据库操作,需要启用新的事务
    ...
     }
    

    经过我的测试,通过在doAfterReturning方法上加上注解@Transactional,并指定传播行为是REQUIRES_NEW依然不行。因为@Transactional也是声明式事务,本身就是AOP实现的,在AOP的代码中使用不起作用。所以就只能使用spring的编程式事务了,需要引入TransactionTemplate。如下:

    @Autowired
    private TransactionTemplate transactionTemplate;
    
    @AfterReturning(returning = "ret", pointcut = "remote()")
     public void doAfterReturning(JoinPoint joinPoint,Object ret) throws Throwable {
    //声明式事务在切面中不起作用,需使用编程式事务
    //设置传播行为:总是新启一个事务,如果存在原事务,就挂起原事务
    transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    transactionTemplate.execute(new TransactionCallback<T>() {
    @Override
    		public T doInTransaction(TransactionStatus arg0) {
     			//一些切面逻辑,包含了数据库操作
    ...
    }
    });
     }
    

    通过以上的步骤,切面里的逻辑会在新事务中执行,执行完就会提交,和业务层中的原事务无关,即便执行完切面逻辑后继续执行业务代码的过程中出现异常,业务层中的数据库操作因为有原事务而回滚,但切面中的数据库操作不会回滚,因为这是个新的事务!

    展开全文
  • MySQL——事务(Transaction)详解

    万次阅读 多人点赞 2018-03-23 13:05:50
    该博客详解MySQL中的事务 一、事务定义 Transaction 事务:一个最小的不可再分的工作单元;通常一个事务对应一个完整的业务(例如银行账户转账业务,该业务就是一个最小的工作单元) 一个完整的业务需要批量的DML...
  • Spring事务和MySQL事务详解面试

    万次阅读 多人点赞 2020-09-10 23:56:36
    文章目录数据库事务事务是什么事务的四大特性MySQL事务隔离级别查看MySQL当前事务隔离级别MySQL默认操作模式为自动提交模式JDBC处理事务Spring事务Spring的事务传播PROPAGATION_REQUIREDPROPAGATION_...
  • #region SaveChanges自带事务 ///1. Context 包含的能对数据库的操作肯定不是对一个表的操作;可以操作多个动作 ///2. SaveChanges以后,默认启动事务,会一次性提交对数据库的所有操作; 要么都成功 要么都失败 ...
  • Java微服务下的分布式事务介绍及其解决方案

    万次阅读 多人点赞 2019-03-22 15:48:46
    1.前言 ...这就很尴尬了,当然微服务下可能没有分布式事务,但是很多场景是需要分布式事务的,下面我就来介绍下什么是分布式事务,和分布式事务的解决方案 2 问题描述 在介绍分布式事务...
  • Spring事务传播机制详解

    万次阅读 多人点赞 2018-08-21 15:55:28
    Spring的事务,也就是数据库的事务操作,符合ACID标准,也具有标准的事务隔离级别。 但是Spring事务有自己的特点,也就是事务传播机制。 所谓事务传播机制,也就是在事务在多个方法的调用中是如何传递的,是...
  • MySQL 事务与锁详解 什么是数据库的事务? 什么是事务? ​ 事务是数据库最小的工作单元,也就是说我们刚才提到的这些场景,它们是作为一个逻辑单元执行 的,既然是最小的工作单元,意味着它是不可再分的。这里面...
  • 1、概述 相比大家一想到事务,就想到ACID,或者也会想到CAP。...我们如果使用了spring来管理我们的事务,将会使事务的管理变得异常的简单,比如如下方法就有事务: @Transactional @Override public bool...
  • Spring 声明式事务

    万次阅读 2019-06-22 22:04:27
    声明式事务: 环境搭建: 1、导入相关依赖 数据源、数据库驱动、Spring-jdbc模块 2、配置数据源、JdbcTemplate(Spring提供的简化数据库操作的工具)操作数据 3、给方法上标注@Transactional标识当前方法是一个...
  • InnoDB事务

    万次阅读 2019-08-05 21:10:40
    事务是数据库区别于文件系统的重要特性之一,InnoDB存储引擎中的事务符合ACID的特性,即 原子性(atomicity) 一致性(consistency) 隔离性(isolation) 持久性(durability) 本文参考了姜承尧先生的《MySQL...
  • 事务 | Spring Cloud 分布式事务管理 LCN、GTX、ByteTCC

    万次阅读 多人点赞 2018-03-18 21:03:04
    事务 | Spring Cloud 分布式事务管理 LCN、GTX、ByteTCC 在微服务如火如荼的情况下,越来越多的项目开始尝试改造成微服务架构,微服务即带来了项目开发的方便性,又提高了运维难度以及网络不可靠的概率. Spring ...
  • mysql事务

    万次阅读 2021-03-27 10:04:15
    事务的四大特性: 原子性:事务是最小的单位,不可以再分割 一致性:事务中的sql语句,执行要么全部失败,要么全部成功 隔离性:事务1和事务2之间是具有隔离性的 持久性:事务一旦commit,就不可以返回 事务开启:...
  • JAVA Spring 事务管理事务不回滚问题

    万次阅读 2019-11-15 20:30:33
    Spring事务管理事务不回滚 dao层: @Repository public class UserDaoImpl implements UserDao { @Autowired private JdbcTemplate jdbcTemplate; @Override public void inmoney(String name, Integer money) { ...
  • 什么是事务事务(`Transaction`),一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元。事务通常由高级数据库操作语言或编程语言(如 SQL,C++ 或 Java)书写...
  • Spring事务和MySQL事务详解

    万次阅读 2020-04-24 01:06:49
    文章目录数据库事务事务是什么事务的四大特性MySQL事务隔离级别查看MySQL当前事务隔离级别MySQL默认操作模式为自动提交模式JDBC处理事务Spring事务Spring的事务传播PROPAGATION_REQUIREDPROPAGATION_...
  • 详解事务的7种传播行为

    万次阅读 多人点赞 2021-04-11 16:52:36
    什么是Spring事务的传播行为?事务传播行为的七种类型有哪些?将异常try-catch捕获,事务是否还会回滚?
  • 什么是事务? 百度百科中解释:指作为单个逻辑工作单元执行的一系列操作,要么完全地执行,要么完全地不执行。 简单的说,事务就是并发控制的单位,是用户定义的一个操作序列。 而一个逻辑工作单元要成为事务,就...
  • MySQL 事务详解

    万次阅读 多人点赞 2021-07-15 20:48:05
    本文将会介绍 MySQL 的事务 `ACID` 特性和 MySQL 事务控制流程的语法,并介绍事务并发处理中可能出现的异常情况,比如脏读、幻读、不可重复读等等,最后介绍事务隔离级别。
  • 本地事务

    万次阅读 2020-04-29 17:16:36
    本地事务相关概念以及Spring事务的使用
  • Java分布式事务

    万次阅读 2020-07-16 17:00:36
    分布式事务介绍 事务拥有以下四个特性,习惯上被称为ACID特性:
  • RocketMQ事务消息实现分布式事务

    万次阅读 2020-05-12 15:11:01
    使用RocketMQ事务消息实现分布式事务
  • 事务的隔离级别

    万次阅读 多人点赞 2019-05-20 20:22:47
    事务的隔离级别 事务的四大特性分别是:原子性、一致性、隔离性、持久性 幻读和不可重复读都是在同一个事务中多次读取了其他事务已经提交的事务的数据导致每次读取的数据不一致,所不同的是不可重复读读取的是同一条...
  • Spring事务管理之开启声明式事务

    万次阅读 2021-01-31 17:23:27
    Spring 中的事务管理 官方文档:http://mybatis.org/spring/zh/transactions.html 声明式事务:AOP 编程式事务:需要在代码中进行事务管理 如果不配置事务, 可能存在数据提交不一致的情况 如果不在Spring中去配置...
  • 什么是事务? 本地事务 事务传播行为: 事务的四大特性 ACID 并发事务产生的问题可以分为4类 事务的隔离级别 什么是分布式事务 分布式涉及到的原理: CAP原理: BASE理论 柔性事务和刚性事务 柔性事务分为:...
  • 分布式事务(一)Mysql本地事务事务隔离级别

    千次阅读 多人点赞 2020-07-18 15:57:24
    文章目录数据库事务Mysql 事务操作开始事务提交事务回滚事务事务特性 ACID数据库并发访问冲突问题Mysql事务隔离级别 数据库事务 数据库事务由一组sql语句组成。 所有sql语句执行成功则事务整体成功;任一条sql语句...
  • SpringCloud分布式事务处理方案

    万次阅读 多人点赞 2018-08-11 17:04:54
    笔者在公司最近的一个项目采用springcloud框架搭建微服务架构,这势必会引发分布式事务处理的思考,目前处理分布式主流方案tcc及消息的最终一致性;今天笔者集成github上较为流行的tx-lcn分布式处理框架,它是基于...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,250,300
精华内容 500,120
关键字:

事务