精华内容
下载资源
问答
  • 事务管理

    千次阅读 2020-10-14 00:18:56
    (1)什么是事务事务的作用:保证一组操作在进行过程中要么同时成功,要么同时失败. 1.目的:保持多并发情况下数据一致. 2.目的:如果出现错误的操作可以进行改正 1000 update-100 断电 1000 update +100 123 (2...
    • (1)什么是事务?
      事务的作用:保证一组操作在进行过程中要么同时成功,要么同时失败.
      1.目的:保持多并发情况下数据一致.
      2.目的:如果出现错误的操作可以进行改正
    1000    update-100
    断电
    1000   update +100
    123
    
    • (2)什么是事务的特性?
      事务的特性(ACID)
      原子性: 一个事务是最小的执行单元,不可以分割
      一致性: 事务指定的前后,数据要保持一致.
      持久性: 事务一旦提交或回滚,在数据库中持久的改变.
    1000  小明
    
    12
    

    隔离性: 隔离性用来保证多个用户来操作数据库的同一份数据,不会受到相关干扰的特性.

    事务的术语

    • (1)什么是事务的隔离级别?
      在这里插入图片描述补充 : 基于元数据的 Spring 声明性事务 :

    Isolation 属性一共支持五种事务设置,具体介绍如下:

    l DEFAULT 使用数据库设置的隔离级别 ( 默认 ) ,由 DBA 默认的设置来决定隔离级别 .

    l READ_UNCOMMITTED 会出现脏读、不可重复读、幻读 ( 隔离级别最低,并发性能高 )

    l READ_COMMITTED 会出现不可重复读、幻读问题(锁定正在读取的行)

    l REPEATABLE_READ 会出幻读(锁定所读取的所有行)

    l SERIALIZABLE 保证所有的情况不会发生(锁表)

    • (2)并发问题
      》(1)脏读: 一个事务读到了另一个事务的还没有提交数据.
      在这里插入图片描述

    》(2)不可重复读 一个事务中多次读到的数据不一致.一个事务读到了另一个事务修改后的数据.
    在这里插入图片描述

    》(3)幻读(虚读): 一个事务读到了insert的数据.

    在这里插入图片描述不可重复读的重点是修改
    同一事务,两次读取到的数据不一样。

    幻读的重点在于新增或者删除
    同样的条件 , 第 1 次和第 2 次读出来的记录数不一样

    脏读:强调的是第二个事务读到的不够新。

    展开全文
  • 事务 | Spring Cloud 分布式事务管理 LCN、GTX、ByteTCC

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

    Spring Cloud 分布式事务管理

    在微服务如火如荼的情况下,越来越多的项目开始尝试改造成微服务架构,微服务即带来了项目开发的方便性,又提高了运维难度以及网络不可靠的概率.


    在说微服务的优缺点时,有对比才会更加明显,首先说一下单体式结构

    单体式架构

    在单体式架构中,系统通常采用分层架构模式(MVC),持久化层、表示层,业务逻辑层。架构主要存在以下问题:

    1. 系统内部互相访问,耦合紧密导致难以维护;
    2. 各业务领域需要采用相同的技术栈,难以快速应用新技术(例如使用SSH很难向SSM改造);
    3. 对系统的任何修改都必须整个系统一起重新部署/升级;
    4. 在系统负载增加时,难以进行水平扩展;
    5. 当系统中一处出现问题,会影响整个系统;

    为了克服以上缺点,微服务架构应运而生。微服务,又叫微服务架构。微服务就是一些协同工作的小而自治的服务.

    微服务架构

    优点

    1. 技术异构性

    在不同的服务中,可以使用不同的技术来各自开发,只要保证服务间能相互协作即可

    2. 弹性

    当微服务中的某一个服务不可用时,不会影响整个系统,只会影响相关功能不可用

    3. 扩展

    易于扩展,使用小的多个服务,更加易于扩展新的功能

    4. 简化部署

    某个服务的更新部署,不需要重新部署整个应用

    5. 可组合

    通过组合多个服务,可以提供一些新的功能

    6. 可替代

    因为每个微服务都比较小,重新实现某一个服务或者直接删除该服务都是可操作的

    缺点

    1. 复杂度高

    微服务间通过REST、RPC等形式交互,相对于单体模式,需要考虑被调用方故障、过载、消息丢失等各种异常情况,代码逻辑更加复杂。

    对于微服务间的事务性操作,因为不同的微服务采用了不同的数据库,将无法利用数据库本身的事务机制保证一致性,需要引入二阶段提交等技术。

    同时,在微服务间存在少部分共用功能但又无法提取成微服务时,各个微服务对于这部分功能通常需要重复开发,或至少要做代码复制,以避免微服务间的耦合,增加了开发成本。

    2. 运维复杂

    在采用微服务架构时,系统由多个独立运行的微服务构成,需要一个设计良好的监控系统对各个微服务的运行状态进行监控。运维人员需要对系统有细致的了解才对够更好的运维系统。

    3. 影响性能

    相对于单体架构,微服务的间通过REST、RPC等形式进行交互,通信的时延会受到较大的影响。

    分布式事务的引入

    正如上面所说

    对于微服务间的事务性操作,因为不同的微服务采用了不同的数据库,将无法利用数据库本身的事务机制保证一致性,需要引入二阶段提交等技术。

    在单体项目中,很容易做到事务控制,而在多个服务之间很难实现

    假设服务调用如下:

    这里写图片描述

    A B C D 的事务均在各个服务控制,如何做到,统一协调,保证数据的一致性?

    分布式事务解决方案

    基于XA协议的两阶段提交

    XA是一个分布式事务协议,由提出。XA中大致分为两部分:事务管理器和本地资源管理器。其中本地资源管理器往往由数据库实现,比如Oracle、DB2这些商业数据库都实现了XA接口,而事务管理器作为全局的调度者,负责各个本地资源的提交和回滚。XA实现分布式事务的原理如下:
    第一阶段:

    Tuxedo

    第二阶段:
    这里写图片描述

    总的来说,XA协议比较简单,而且一旦商业数据库实现了XA协议,使用分布式事务的成本也比较低。但是,XA也有致命的缺点,那就是性能不理想,特别是在交易下单链路,往往并发量很高,XA无法满足高并发场景。XA目前在商业数据库支持的比较理想,在mysql数据库中支持的不太理想,mysql的XA实现,没有记录prepare阶段日志,主备切换回导致主库与备库数据不一致。许多nosql也没有支持XA,这让XA的应用场景变得非常狭隘。

    消息事务+最终一致性

    所谓的消息事务就是基于消息中间件的两阶段提交,本质上是对消息中间件的一种特殊利用,它是将本地事务和发消息放在了一个分布式事务里,保证要么本地操作成功成功并且对外发消息成功,要么两者都失败,开源的RocketMQ就支持这一特性.

    该方案采用最终一致的,牺牲了一致性,换来了性能的大幅度提升。存在造成数据不一致的风险

    TCC编程模式

    所谓的TCC编程模式,也是两阶段提交的一个变种。TCC提供了一个编程框架,将整个业务逻辑分为三块:Try、Confirm和Cancel三个操作。以在线下单为例,Try阶段会去扣库存,Confirm阶段则是去更新订单状态,如果更新订单失败,则进入Cancel阶段,会去恢复库存。总之,TCC就是通过代码人为实现了两阶段提交,不同的业务场景所写的代码都不一样,复杂度也不一样,因此,这种模式并不能很好地被复用。

    具体实现

    LCN

    https://github.com/codingapi/tx-lcn

    LCN分布式事务框架的核心功能是对本地事务的协调控制,框架本身并不创建事务,只是对本地事务做协调控制。因此该框架与其他第三方的框架兼容性强,支持所有的关系型数据库事务,支持多数据源,支持与第三方数据库框架一块使用(例如 sharding-jdbc),在使用框架的时候只需要添加分布式事务的注解即可,对业务的侵入性低。LCN框架主要是为微服务框架提供分布式事务的支持,在微服务框架上做了进一步的事务机制优化,在一些负载场景上LCN事务机制要比本地事务机制的性能更好,4.0以后框架开方了插件机制可以让更多的第三方框架支持进来
    

    目前 LCN为 4.1 版本

    主要特点:

    • 支持各种基于spring的db框架
    • 兼容SpringCloud、Dubbo、motan
    • 使用简单,低依赖,代码完全开源
    • 基于切面的强一致性事务框架
    • 高可用,模块可以依赖RPC模块做集群化,TxManager也可以做集群化
    • 支持本地事务和分布式事务共存
    • 支持事务补偿机制,增加事务补偿决策提醒

    采用强一致性方案,事务要不全部成功,要不全部失败,保证了事务的一致性,代码简单,原有项目只需引入相关 jar 包,并在需要参与的事务的方法添加注解即可,节省了代码改造成本.

    Spring Cloud示例:

    添加依赖

    <properties>
       <lcn.last.version>4.1.0</lcn.last.version>
    </properties>
    
    <dependency>
        <groupId>com.codingapi</groupId>
        <artifactId>transaction-springcloud</artifactId>
        <version>${lcn.last.version}</version>
    </dependency>
    
    <dependency>
       <groupId>com.codingapi</groupId>
       <artifactId>tx-plugins-db</artifactId>
       <version>${lcn.last.version}</version>
    </dependency>
    
    

    在需要执行的事务上添加注解

    @Override
    @TxTransaction(isStart = true)
    @Transactional
    public int save() {
    }
    

    其中 @TxTransaction(isStart = true)lcn 事务控制注解,其中isStart = true 表示该方法是事务的发起方例如,服务A 需要调用服务B,服务B 需要调用服务C,此时 服务A为服务发起方,其余为参与方,参与方只需@TxTransaction 即可

    在测试时需要将 事务管理服务启动 txManager, 具体示例参看:https://www.txlcn.org

    ByteTCC

    https://github.com/liuyangming/ByteTCC

    ByteTCC是一个基于TCC(Try/Confirm/Cancel)机制的分布式事务管理器。兼容JTA,可以很好的与EJB、Spring等容器(本文档下文说明中将以Spring容器为例)进行集成。

    ByteTCC特性
    1、支持Spring容器的声明式事务管理;
    2、支持普通事务、TCC事务、业务补偿型事务等事务机制;
    3、支持多数据源、跨应用、跨服务器等分布式事务场景;
    4、支持长事务;
    5、支持dubbo服务框架;
    6、支持spring cloud;

    该实现方式,需要在业务层编写对应的 tcc(Try/Confirm/Cancel) 方法,开发需要一定的成本,同时某些业务可能无法保证数据可回滚

    查看示例:https://github.com/liuyangming/ByteTCC

    参考:

    1. https://github.com/codingapi/tx-lcn
    2. https://github.com/liuyangming/ByteTCC
    3. 微服务设计(Sam Newman)

    如果你喜欢就关注一下吧. 以后会写一下我们公司在使用Spring Cloud 中遇到的问题和一些经验

    这里写图片描述

    下一篇 Spring Cloud 分布式事务管理(二)2pc/3pc
    系列文章
    事务Transaction
    Spring Cloud 分布式事务管理
    Spring Cloud 分布式事务管理(二)2pc/3pc
    谢谢大家阅读和不吝赐教,以后会专门写几篇文章讲述一下数据库事务相关的操作,包括但不限于:事务概念、MySQL事务管理、JDBC事务管理、Spring 事务管理、Hibernate事务管理、多数据源事务管理、分布式事务管理等方面的文章

    展开全文
  • Spring事务管理之开启声明式事务

    万次阅读 2021-01-31 17:23:27
    Spring 中的事务管理 官方文档:http://mybatis.org/spring/zh/transactions.html 声明式事务:AOP 编程式事务:需要在代码中进行事务管理 如果不配置事务, 可能存在数据提交不一致的情况 如果不在Spring中去配置...

    Spring 中的事务管理

    官方文档:http://mybatis.org/spring/zh/transactions.html

    • 声明式事务:AOP
    • 编程式事务:需要在代码中进行事务管理

    如果不配置事务, 可能存在数据提交不一致的情况

    如果不在Spring中去配置声明式事务, 我们就需要在代码中手动配置事务

    事务在项目开发中十分重要, 涉及到数据的一致性和完整性问题, 不容马虎

    <?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:aop="http://www.springframework.org/schema/aop"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/aop
            https://www.springframework.org/schema/aop/spring-aop.xsd
            http://www.springframework.org/schema/tx
            https://www.springframework.org/schema/tx/spring-tx.xsd">
    
        <!--dataSource: 使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid
            我们这里使用Spring提供的JDBC: org.springframework.jdbc.datasource.DriverManagerDataSource
        -->
        <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8"/>
            <property name="username" value="root"/>
            <property name="password" value="123456"/>
        </bean>
    
        <!--sqlSessionFactory-->
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource"/>
            <!--关联/绑定 mybatis 配置文件-->
            <property name="configLocation" value="classpath:mybatis-config.xml"/>
            <!--绑定 Mapper.xml-->
            <property name="mapperLocations" value="classpath:com/pro/mapper/*.xml"/>
        </bean>
    
        <!--SqlSessionTemplate: 就是我们使用的 sqlSession-->
        <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
            <!--只能使用构造器注入, 因为它没有set方法-->
            <constructor-arg index="0" ref="sqlSessionFactory"/>
        </bean>
    
        
        <!--################# 开启事务管理 #################-->
        <!--开启 Spring 声明式事务-->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <constructor-arg ref="dataSource" />
        </bean>
    
        <!--结合AOP实现事务织入-->
        <!--配置事务通知-->
        <tx:advice id="txAdvice" transaction-manager="transactionManager">
            <!--1. 给那些方法配置事务-->
            <!--2. 配置事务的传播特性: propagation-->
            <tx:attributes>
                <tx:method name="add" propagation="REQUIRED"/>
                <tx:method name="delete" propagation="REQUIRED"/>
                <tx:method name="update" propagation="REQUIRED"/>
                <tx:method name="query" read-only="true"/>
                <tx:method name="*" propagation="REQUIRED"/>
            </tx:attributes>
        </tx:advice>
    
        <!--配置事务切入-->
        <aop:config>
            <!--mapper包下的所有类的所有方法-->
            <aop:pointcut id="txPointCut" expression="execution(* com.pro.mapper.*.*(..))"/>
            <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
        </aop:config>
    </beans>
    
    展开全文
  • Spring Boot 中使用 @Transactional 注解配置事务管理

    万次阅读 多人点赞 2017-11-29 21:15:06
    事务管理是应用系统开发中必不可少的一部分。Spring 为事务管理提供了丰富的功能支持。Spring 事务管理分为编程式和声明式的两种方式。编程式事务指的是通过编码方式实现事务;声明式事务基于 AOP,将具体业务逻辑与...

    事务管理是应用系统开发中必不可少的一部分。Spring 为事务管理提供了丰富的功能支持。Spring 事务管理分为编程式和声明式的两种方式。编程式事务指的是通过编码方式实现事务;声明式事务基于 AOP,将具体业务逻辑与事务处理解耦。声明式事务管理使业务代码逻辑不受污染, 因此在实际使用中声明式事务用的比较多。声明式事务有两种方式,一种是在配置文件(xml)中做相关的事务规则声明,另一种是基于 @Transactional 注解的方式。本文将着重介绍基于 @Transactional 注解的事务管理。

    需要明确几点:

    1. 默认配置下 Spring 只会回滚运行时、未检查异常(继承自 RuntimeException 的异常)或者 Error。参考这里
    2. @Transactional 注解只能应用到 public 方法才有效。参考这里 Method visibility and @Transactional

    以下的示例使用的是 mybatis,所以 spring boot 会自动配置一个 DataSourceTransactionManager,我们只需在方法(或者类)加上 @Transactional 注解,就自动纳入 Spring 的事务管理了。

    简单的使用方法

    只需在方法加上 @Transactional 注解就可以了。

    如下有一个保存用户的方法,加入 @Transactional 注解,使用默认配置,抛出异常之后,事务会自动回滚,数据不会插入到数据库。

    @Transactional
    @Override
    public void save() {
        User user = new User("服部半藏");
        userMapper.insertSelective(user);
    
        if (true) {
            throw new RuntimeException("save 抛异常了");
        }
    }

    我们可以从日志里面看出这些信息

    TIM截图20171129135813

    @Transactional 注解的属性介绍

    下面分别介绍一下 @Transactional 的几个属性。

    value 和 transactionManager 属性

    它们两个是一样的意思。当配置了多个事务管理器时,可以使用该属性指定选择哪个事务管理器。

    propagation 属性

    事务的传播行为,默认值为 Propagation.REQUIRED。

    可选的值有:

    • Propagation.REQUIRED

      如果当前存在事务,则加入该事务,如果当前不存在事务,则创建一个新的事务。

    • Propagation.SUPPORTS

      如果当前存在事务,则加入该事务;如果当前不存在事务,则以非事务的方式继续运行。

    • Propagation.MANDATORY

      如果当前存在事务,则加入该事务;如果当前不存在事务,则抛出异常。

    • Propagation.REQUIRES_NEW

      重新创建一个新的事务,如果当前存在事务,暂停当前的事务。

    • Propagation.NOT_SUPPORTED

      以非事务的方式运行,如果当前存在事务,暂停当前的事务。

    • Propagation.NEVER

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

    • Propagation.NESTED

      和 Propagation.REQUIRED 效果一样。

    这些概念理解起来实在是有点儿抽象,后文会用代码示例解释说明。

    isolation 属性

    事务的隔离级别,默认值为 Isolation.DEFAULT。

    可选的值有:

    • Isolation.DEFAULT

      使用底层数据库默认的隔离级别。

    • Isolation.READ_UNCOMMITTED

    • Isolation.READ_COMMITTED
    • Isolation.REPEATABLE_READ
    • Isolation.SERIALIZABLE

    timeout 属性

    事务的超时时间,默认值为-1。如果超过该时间限制但事务还没有完成,则自动回滚事务。

    readOnly 属性

    指定事务是否为只读事务,默认值为 false;为了忽略那些不需要事务的方法,比如读取数据,可以设置 read-only 为 true。

    rollbackFor 属性

    用于指定能够触发事务回滚的异常类型,可以指定多个异常类型。

    noRollbackFor 属性

    抛出指定的异常类型,不回滚事务,也可以指定多个异常类型。

    @Transactional 的 propagation 属性代码示例

    比如如下代码,save 方法首先调用了 method1 方法,然后抛出了异常,就会导致事务回滚,如下两条数据都不会插入数据库。

    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void save() {
    
        method1();
    
        User user = new User("服部半藏");
        userMapper.insertSelective(user);
    
        if (true) {
            throw new RuntimeException("save 抛异常了");
        }
    }
    
    public void method1() {
        User user = new User("宫本武藏");
        userMapper.insertSelective(user);
    }

    现在有需求如下,就算 save 方法的后面抛异常了,也不能影响 method1 方法的数据插入。或许很多人的想法如下,给 method1 页加入一个新的事务,这样 method1 就会在这个新的事务中执行,原来的事务不会影响到新的事务。比如 method1 方法上面再加入注解 @Transactional,设置 propagation 属性为 Propagation.REQUIRES_NEW,代码如下。

    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void save() {
    
        method1();
    
        User user = new User("服部半藏");
        userMapper.insertSelective(user);
    
        if (true) {
            throw new RuntimeException("save 抛异常了");
        }
    }
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void method1() {
        User user = new User("宫本武藏");
        userMapper.insertSelective(user);
    }

    运行之后,发现然并卵,数据也是没有插入数据库。怎么肥四,看起来很不科学。我们先来看看日志内容。

    TIM截图20171129150737

    从日志内容可以看出,其实两个方法都是处于同一个事务中,method1 方法并没有创建一个新的事务。

    这就得看看 Spring 官方文档了。

    In proxy mode (which is the default), only external method calls coming in through the proxy are intercepted. This means that self-invocation, in effect, a method within the target object calling another method of the target object, will not lead to an actual transaction at runtime even if the invoked method is marked with @Transactional.

    大概意思:在默认的代理模式下,只有目标方法由外部调用,才能被 Spring 的事务拦截器拦截。在同一个类中的两个方法直接调用,是不会被 Spring 的事务拦截器拦截,就像上面的 save 方法直接调用了同一个类中的 method1方法,method1 方法不会被 Spring 的事务拦截器拦截。可以使用 AspectJ 取代 Spring AOP 代理来解决这个问题,但是这里暂不讨论。

    为了解决这个问题,我们可以新建一个类。

    @Service
    public class OtherServiceImpl implements OtherService {
    
        @Autowired
        private UserMapper userMapper;
    
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        @Override
        public void method1() {
            User user = new User("风魔小太郎");
            userMapper.insertSelective(user);
        }
    }

    然后在 save 方法中调用 otherService.method1 方法

    @Autowired
    private OtherService otherService;
    
    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void save() {
    
        otherService.method1();
    
        User user = new User("服部半藏");
        userMapper.insertSelective(user);
    
        if (true) {
            throw new RuntimeException("save 抛异常了");
        }
    }

    这下,otherService.method1 方法的数据插入成功,save 方法的数据未插入,事务回滚。

    继续看一下日志内容

    TIM截图20171129153731

    从日志可以看出,首先创建了 save 方法的事务,由于 otherService.method1 方法的 @Transactional 的 propagation 属性为 Propagation.REQUIRES_NEW ,所以接着暂停了 save 方法的事务,重新创建了 otherService.method1 方法的事务,接着 otherService.method1 方法的事务提交,接着 save 方法的事务回滚。这就印证了只有目标方法由外部调用,才能被 Spring 的事务拦截器拦截。

    还有几个示例如下。

    接着把 save 方法的 @Transactional 注解去掉,otherService.method1 的 @Transactional 注解保持不变,从日志就可以看出,只会创建一个 otherService.method1 方法的事务,两条数据都会插入。

    @Autowired
    private OtherService otherService;
    
    //    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void save() {
    
        otherService.method1();
    
        User user = new User("服部半藏");
        userMapper.insertSelective(user);
    
        if (true) {
            throw new RuntimeException("save 抛异常了");
        }
    }

    接着把 save 方法的 @Transactional 注解去掉,save 方法改为调用内部的 method1 方法,从日志就可以看出,完全没有创建任何事务,两条数据都会插入。

    //    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void save() {
    
        method1();
    
        User user = new User("服部半藏");
        userMapper.insertSelective(user);
    
        if (true) {
            throw new RuntimeException("save 抛异常了");
        }
    }
    
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void method1() {
        User user = new User("宫本武藏");
        userMapper.insertSelective(user);
    }

    这样,其他的几个 propagation 属性值也就比较好理解了。

    @Transactional 事务实现机制

    在应用系统调用声明了 @Transactional 的目标方法时,Spring Framework 默认使用 AOP 代理,在代码运行时生成一个代理对象,根据 @Transactional 的属性配置信息,这个代理对象决定该声明 @Transactional 的目标方法是否由拦截器 TransactionInterceptor 来使用拦截,在 TransactionInterceptor 拦截时,会在目标方法开始执行之前创建并加入事务,并执行目标方法的逻辑, 最后根据执行情况是否出现异常,利用抽象事务管理器 AbstractPlatformTransactionManager 操作数据源 DataSource 提交或回滚事务。

    Spring AOP 代理有 CglibAopProxyJdkDynamicAopProxy 两种,以 CglibAopProxy 为例,对于 CglibAopProxy,需要调用其内部类的 DynamicAdvisedInterceptor 的 intercept 方法。对于 JdkDynamicAopProxy,需要调用其 invoke 方法。

    Spring-transaction-mechanis

    正如上文提到的,事务管理的框架是由抽象事务管理器 AbstractPlatformTransactionManager 来提供的,而具体的底层事务处理实现,由 PlatformTransactionManager 的具体实现类来实现,如事务管理器 DataSourceTransactionManager。不同的事务管理器管理不同的数据资源 DataSource,比如 DataSourceTransactionManager 管理 JDBC 的 Connection

    Spring-TransactionManager-hierarchy-subtypes

    源码地址

    参考资料

    结语

    由于本人知识和能力有限,文中如有没说清楚的地方,希望大家能在评论区指出,以帮助我将博文写得更好。

    展开全文
  • 目录事务的概念搭建事务操作的环境创建数据库表,添加记录代码演示事务场景引入事务管理介绍注解声明式事务管理声明式事务管理参数配置propagation:事务传播行为ioslation:事务隔离级别timeout:超时时间readOnly...
  • 数据库事务管理

    万次阅读 2019-11-16 19:03:12
    java数据库事务管理原理 --------------------------------------------------------------------------------------------------------------------------------------------------------------- 1、事务概念...
  • Spring事务管理之几种方式实现事务

    万次阅读 多人点赞 2017-12-15 22:53:53
    其实Spring事务管理基于底层数据库本身的事务处理机制。数据库事务的基础,是掌握Spring事务管理的基础。这篇总结下Spring事务。 事务具备ACID四种特性,ACID是Atomic(原子性)、Consistency(一致性)、...
  • 基于注解的事务管理: 第一步:事务管理器: &lt;!-- 事务管理器 --&gt; &lt;bean id="transactionManager" class="org.springframework.jdbc.datasource....
  • JDBC事务管理

    千次阅读 多人点赞 2019-08-16 22:51:35
    如果还不清楚什么是事务,可以先看一下MySQL事务管理(初步了解)这篇文章 JDBC是Java数据库连接相关的API,所以Java的事务管理也是在通过改API进行的。JDBC的核心是Connection接口,JDBC的事务管理是基于...
  • 事务管理之XA分布式事务管理

    千次阅读 2017-08-05 14:39:51
    Java Transaction API 允许您操作应用程序中的分布式事务...在异构环境中,您通常会发现一个事务管理器(Transaction Manager),负责处理分布式事务。(实际上,事务管理器可以完成大量的工作负载平衡。)因
  • Spring事务管理详解

    万次阅读 多人点赞 2017-04-09 22:43:16
    Spring事务管理详解
  • 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) { ...
  • ibatis事务管理

    千次阅读 2018-10-15 21:19:54
    ibatis事务管理
  • spring事务管理

    千次阅读 2019-01-26 09:47:11
    spring事务管理什么是事务:事务的特性:Spring支持两种方式事务管理编程式的事务管理:声明式的事务管理: 更多文章欢迎访问个人博客 www.herobin.top 什么是事务: 事务指的是逻辑上的一组操作,这组操作要么全部...
  • Java事务管理

    千次阅读 2019-05-22 14:36:49
    事务的ACID属性:原子性...一、Java事务管理 Java事务管理有三种类型: JDBC事务、JTA(Java Transaction API)事务、容器事务 1.1 JDBC事务 JDBC的一切行为包括事务是基于一个Connection的,JDBC通过Connec...
  • 一、注解方式声明式事务管理步骤 (1)注入事务管理器:PlatformTransactionManager (2)启用注解事务管理:@EnableTransactionManagement (3)在方法或者类上添加事务注解@Transactional (4)测试 二...
  • Spring事务管理

    千次阅读 2018-09-11 18:44:10
    Spring事务管理 Spring将事务管理分成了两类:  * 编程式事务管理  - 手动编写代码进行事务管理(很少使用)  * 声明式事务管理  - 基于TransactionProxyFactoryBean的方式(很少使用)  . 需要为每个进行事务管理...
  • Spring 事务——事务管理

    千次阅读 2018-10-18 15:00:39
    事务管理器 Spring只是个容器,因此它并不做任何事务的具体实现。他只是提供了事务管理的接口PlatformTransactionManager,具体内容由就由各个事务管理器来实现。 Spring提供了许多内置事务管理器实现: ...
  • Spring 事务管理

    千次阅读 2018-10-25 23:25:37
    Spring 事务管理,主要将事务由Dao层提升至Service层。 【1】平台事务管理器(PlatformTranscationManager)和 事务定义接口(TranscationDefinition) 【1.1】平台事务管理器(PlatformTranscationManager) ...
  • Mybatis事务管理

    千次阅读 2018-10-24 20:07:19
    一、Mybatis事务概述  对于数据库事务而言,一般包括以下几个操作:创建、提交、回滚、关闭。MyBatis把这些抽象为Transaction接口: 接口定义如下:    接口定义了Connection... 1、使用JDBC的事务管理机制...
  • Mybatis事务(一)事务管理方式

    万次阅读 2016-09-20 21:06:20
    Mybatis管理事务是分为两种方式: ...(2)使用MANAGED的事务管理机制,这种机制mybatis自身不会去实现事务管理,而是让程序的容器(JBOSS,WebLogic)来实现对事务的管理 在Mybatis的配置文件中可以配置事务管理方式如下:
  • springboot事务管理及日志管理

    千次阅读 2019-08-14 10:53:39
    事务管理 Spring 事务管理分为编码式和声明式的两种方式。编程式事务指的是通过编码方式实现事务;声明式事务基于 AOP,将具体业务逻辑与事务处理解耦。声明式事务管理使业务代码逻辑不受污染, 因此在实际使用中声明...
  • 声明式事务管理:(非切面方式) 基于TransactionProxyFactoryBean. 导入:aop相应jar包. 第一步:注册平台事务管理器: &lt;!-- 事务管理器 --&gt; &lt;bean id="transactionManager" ...
  • springboot事务管理详解

    万次阅读 2017-11-24 11:15:09
    之前搭建的Spring boot Mybatis 整合(注解版)中我们简单的使用了springboot的事务管理,那么接下来讲解一下事务管理的详细配置 之前的例子中我们使用了默认的事务配置,可以满足一些基本的事务需求,但是当我们...
  • JPA和事务管理

    万次阅读 2018-07-05 15:58:03
    1 事务1.1事务管理方式spring支持编程式事务管理和声明式事务管理两种方式。编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理,spring推荐使用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 57,492
精华内容 22,996
关键字:

事务管理