关键词：

背景

互联网的金融和电商行业，最关注数据库事务。

业务核心	说明
金融行业-金融产品金额	不允许发生错误
电商行业-商品交易金额，商品库存	不允许发生错误

面临的难点：

高并发下保证： 数据一致性，高性能；

spring对事物的处理：

采用AOP技术提供事务支持，申明式事务，去除了代码中重复的try-catch-finally代码；

两个场景的解决方案：

场景	解决办法
库存扣减，交易记录，账户金额的数据一致性	数据库事务保证一致性
批量处理部分任务失败不影响批量任务的回滚	数据库事务传播行为

jdbc处理事务

代码

package com.springbootpractice.demo.demo_jdbc_tx.biz;
import lombok.SneakyThrows;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Objects;
import java.util.Optional;
/**
 * 说明：代码方式事务编程 VS 申明式事物编程
 * @author carter
 * 创建时间： 2020年01月08日 11:02 上午
 **/
@Service
public class TxJdbcBiz {
    private final JdbcTemplate jdbcTemplate;

    public TxJdbcBiz(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @SneakyThrows
    public int insertUserLogin(String username, String note) {
        Connection connection = null;
        int result = 0;
        try {
            connection = Objects.requireNonNull(jdbcTemplate.getDataSource()).getConnection();

            connection.setAutoCommit(false);

            connection.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);

            final PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO user_login(user_name,password,sex,note)  VALUES(?,?,?,?)");

            preparedStatement.setString(1, username);
            preparedStatement.setString(2, "abc123");
            preparedStatement.setInt(3, 1);
            preparedStatement.setString(4, note);

            result = preparedStatement.executeUpdate();

            connection.commit();
        } catch (Exception e) {
            Optional.ofNullable(connection)
                    .ifPresent(item -> {
                        try {
                            item.rollback();
                        } catch (SQLException ex) {
                            ex.printStackTrace();
                        }
                    });
            e.printStackTrace();
        } finally {
            Optional.ofNullable(connection)
                    .filter(this::closeConnection)
                    .ifPresent(item -> {
                        try {
                            item.close();
                        } catch (SQLException e) {
                            e.printStackTrace();
                        }
                    });
        }
        return result;
    }
    private boolean closeConnection(Connection item) {
        try {
            return !item.isClosed();
        } catch (SQLException e) {
            e.printStackTrace();
            return false;
        }
    }
    @Transactional
    public int insertUserLoginTransaction(String username, String note) {
        String sql = "INSERT INTO user_login(user_name,password,sex,note)  VALUES(?,?,?,?)";
        Object[] params = {username, "abc123", 1, note};
        return jdbcTemplate.update(sql, params);
    }
}

测试代码

package com.springbootpractice.demo.demo_jdbc_tx;
import com.springbootpractice.demo.demo_jdbc_tx.biz.TxJdbcBiz;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.TransactionManager;
import org.springframework.util.Assert;
@SpringBootTest
class DemoJdbcTxApplicationTests {
    @Autowired
    private TxJdbcBiz txJdbcBiz;
    @Autowired
    private TransactionManager transactionManager;

    @Test
    void testInsertUserTest() {
        final int result = txJdbcBiz.insertUserLogin("monika.smith", "xxxx");
        Assert.isTrue(result > 0, "插入失败");
    }

    @Test
    void insertUserLoginTransactionTest() {
        final int result = txJdbcBiz.insertUserLoginTransaction("stefan.li", "hello transaction");
        Assert.isTrue(result > 0, "插入失败");
    }

    @Test
    void transactionManagerTest() {
        System.out.println(transactionManager.getClass().getName());
    }
}

代码中有一个很讨厌的地方，就是 try-catch-finally;

流程图

整体流程跟AOP的流程非常的相似，使用AOP,可以把执行sql的步骤抽取出来单独实现，其它的固定流程放到通知里去做。

jdbc使用事物编程代码点我！

申明式事务

通过注解@Transaction来标注申明式事务，可以标准在类或者方法上；

@Tranaction使用位置	说明
类上或者接口上	类中所有的 公共非静态方法 都将启用事务，spring推荐放在实现类上，否则aop必须基于接口的代理生效的时候才能生效
方法上	本方法

@Transaction的源码和配置项

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.transaction.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.core.annotation.AliasFor;

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
    @AliasFor("transactionManager")
    String value() default "";

    @AliasFor("value")
    String transactionManager() default "";

    Propagation propagation() default Propagation.REQUIRED;

    Isolation isolation() default Isolation.DEFAULT;

    int timeout() default -1;

    boolean readOnly() default false;

    Class<? extends Throwable>[] rollbackFor() default {};

    String[] rollbackForClassName() default {};

    Class<? extends Throwable>[] noRollbackFor() default {};

    String[] noRollbackForClassName() default {};
}

说明：

属性	说明
isolation	事务的隔离级别
propagation	传播行为
rollbackFor，rollbakcForClassName	哪种异常会触发事务回滚
value	事务管理器
timeout	事务超时时间
readOnly	是否是只读事务
noRollbackFor,noRollbackForClassName	哪些异常不会触发事务回滚

事务的安装过程：

springIOC容器启动的时候，会把@Transactional注解的配置信息解析出来，然后存到事务定义器（TransactionDefinition）,并记录哪些类的方法需要启动事务，采取什么策略去执行事务。

我们要做的只是标注@Transactional和配置属性即可；

流程如图：

使用方式大大简化；

代码

 @Transactional
    public int insertUserLoginTransaction(String username, String note) {
        String sql = "INSERT INTO user_login(user_name,password,sex,note)  VALUES(?,?,?,?)";
        Object[] params = {username, "abc123", 1, note};
        return jdbcTemplate.update(sql, params);
    }

事务管理器

事务的打开，提交，回滚都是放在事务管理器上的。TransactionManager;

TransactionManager代码

package org.springframework.transaction;

public interface TransactionManager {
}

这是一个空接口，实际起作用的是PlatfromTransactionManager;

PlatfromTransactionManager代码：

package org.springframework.transaction;

import org.springframework.lang.Nullable;

public interface PlatformTransactionManager extends TransactionManager {
    TransactionStatus getTransaction(@Nullable TransactionDefinition var1) throws TransactionException;

    void commit(TransactionStatus var1) throws TransactionException;

    void rollback(TransactionStatus var1) throws TransactionException;
}

3个架子的事务管理器对比：

架子	事务管理	说明
spring-jdbc	DatasourceTransactionManager
jpa	JpaTransactionManager
mybatis	DatasourceTransactionManager

mybatis的代码实例点我！

事务隔离级别

场景：电商行业的库存扣减，时刻都是多线程的环境中扣减库存，对于数据库而言，就会出现多个事务同事访问同一记录，这样引起的数据不一致的情况，就是数据库丢失更新。

数据库事务4个特性

即ACID

事务的特性	英文全称	说明
原子性	Atomic	一个事务中包含多个步骤操作A,B,C，原子性是标识这些操作要目全部成功，要么全部失败，不会出现第三种情况
一致性	Consistency	在事务完成后，所有的数据都保持一致状态
隔离性	Isolation	多个线程同时访问同一数据，每个线程处在不同的事务中，为了压制丢失更新的产生，定了隔离级别，通过隔离性的设置，可以压制丢失更新的发生，这里存在一个选择的过程
持久性	Durability	事务结束后，数据都会持久化，断电重启后也是可以提供给程序继续使用

隔离级别：

隔离级别	说明	问题	并发性能
读未提交【read uncommitted】	允许事务读取另外一个事务没有提交的数据，事务要求比较高的情况下不适用，适用于对事务要求不高的场景	脏读（单条）	并发性能最高
读已提交【read committed】	一个事务只能读取另外一个事务已经提交的数据	不可重复读（单条）	并发性能一般
可重复读【read repeated】	事务提交的时候也会判断最新的值是否变化	幻想读（多条数据而言）	并发性能比较差
串行化【serializable】	所有的sql都按照顺序执行	数据完全一致	并发性能最差

选择依据

隔离级别	脏读	不可重复读	幻象读
读未提交	是	是	是
读已提交	否	是	是
可重复读	否	否	是
串行化	否	否	否

按照实际场景的允许情况来设置事务的隔离级别；

隔离级别会带来锁的代价；优化方法：

1. 乐观锁，
2. redis分布式锁,
3. zk分布式锁；

数据库	事务隔离级别	默认事务隔离级别
mysql	4种	可重复读
oracle	读已提交，串行化	读已提交

springboot配置应用默认的事务隔离级别：spring.datasource.xxx.default-transaction-isolation=2

数字	对应隔离级别
-1	无
1	读未提交
2	读已提交
4	可重复读
8	串行化

事务传播行为

传播行为是方法之间调用事务采取的策略问题。 场景：一个批量任务处在一个事务A中，每个单独是事务都有一个独立的事务Bn; 子任务的回滚不影响事务A的回滚；

传播行为源码

package org.springframework.transaction.annotation;
import org.springframework.transaction.TransactionDefinition;
public enum Propagation {
	REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),
	SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),
	MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),
	REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),
	NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),
	NEVER(TransactionDefinition.PROPAGATION_NEVER),
	NESTED(TransactionDefinition.PROPAGATION_NESTED);
	private final int value;
	Propagation(int value) {
		this.value = value;
	}
	public int value() {
		return this.value;
	}
}

列举了7种传播配置属性，下面分别说明：

传播行为	父方法中存在事务子方法行为	父方法中不存在事务子方法行为
REQUIRED	默认传播行为，沿用，	创建新的事务
SUPPORTS	沿用；	无事务，子方法中也无事务
MANDATORY	沿用	抛出异常
REQUIRES_NEW	创建新事务	创建新事务
NOT_SUPPORTED	挂起事务，运行子方法	无事务，运行子方法
NEVER	抛异常	无事务执行子方法
NESTED	子方法发生异常，只回滚子方法的sql,而不回滚父方法中的事务	发生异常，只回滚子方法的sql，跟父方法无关

常用的三种传播行为：

• REQUIRED
• REQUIRES_NEW
• NESTED

代码测试这三种传播行为：

代码点我！

spring使用了save point的技术来让子事务回滚，而父事务不会滚；如果不支持save point,则新建一个事务来运行子事务；

区别点	RequestNew	Nested
传递	拥有自己的锁和隔离级别	沿用父事务的隔离级别和锁

@Transaction自调用失效问题

事务的实现原理是基于AOP,同一个类中方法的互相调用，是自己调用自己，而没有代理对象的产生，就不会用到aop，所以，事务会失效； **解决办法：**通过spring的ioc容器得到当前类的代理对象，调用本类的方法解决； 原创不易，转载请注明出处。

一文解析spring编程式和声明式事务实例讲解

接上一篇：一文解析Spring事务管理详解；通俗易懂，轻松掌握！Spring事务管理Spring支持两种方式的事务管理：编程式事务管理：?通过TransactionTemplate手动管理事务，实际应用中很少使用，使用XML配置声明式事务：?推荐使用（代码... 查看详情

spring事务的开启方式（编程式和声明式）

...务：编码方式实现事务管理（代码演示为JDBC事务管理）Spring实现编程式事务，依赖于2大类，分别是上篇文章提到的PlatformTransactionManager，与模版类TransactionTemplate（推荐使用）。下面分别详细介绍Spring是如何通过该类实现事务管... 查看详情

spring(十五)之声明式事务

声明式事务管理方法允许你在配置的帮助下而不是源代码硬编程来管理事务。这意味着你可以将事务管理从事务代码中隔离出来。你可以只使用注释或基于配置的XML来管理事务。bean配置会指定事务型方法。下面是与声明式事务... 查看详情

jdbctemplate和声明式事务（spring框架）

Spring框架整理第三发，JdbcTemplate的使用和声明式事务。JdbcTemplate   简介：JdbcTemplate是Spring框架提供的操作数据库的工具类，功能和DBUtils类似 JdbcTemplate使用方法：   导包：数据库连接：c3p0-0.9.1.2.jar mys... 查看详情

jdbctemplate和声明式事务（spring框架）

Spring框架整理第三发，JdbcTemplate的使用和声明式事务。JdbcTemplate   简介：JdbcTemplate是Spring框架提供的操作数据库的工具类，功能和DBUtils类似 JdbcTemplate使用方法：   导包：数据库连接：c3p0-0.9.1.2.jar mys... 查看详情

spring事务

就使用者角度来说，所谓的事务主要分两方面： 开启事务： 说明式事务： Springmvc（传统web项目）： <!--(事务管理)transactionmanager,useJtaTransactionManagerforglobaltx--> <beanid="transactionManager" class="org. 查看详情

spring事务转

出处：  spring事务 1.背景　　Spring提供了编程式事务和声明式事务，但由于编程性事务的侵入性，开发中普遍会使用Spring的声明式事务，下文中所说的Spring事务也都是指声明式事务。　　Spring声明式事务底层是建立在A... 查看详情

spring事务管理---上

Spring事务管理---上编程式事务管理使用PlatformTransactionManager进行编程式事务管理使用TransactionTemplate进行编程式事务管理编程创建基于SavePoint的嵌套事务声明式事务管理模拟声明式事务小结XML元数据驱动的声明式事务ProxyFactory或者... 查看详情

spring中事务的回滚

https://www.cnblogs.com/zeng1994/p/8257763.html（浅谈Spring中的事务回滚）http://www.cnblogs.com/nnngu/p/8627662.html （Spring的编程式事务和声明式事务） 查看详情

spring事件机制支持事务吗

参考技术A支持。Spring支持事务类型：编程式事务和声明式事务。编程式事务是在代码中进行硬编码，与业务的耦合度高，难以复用。声明式事务：本质使用AOP，将业务和事务管理分离，降低耦合度和提高事务的复用能力。声明... 查看详情

怎么使用spring配置事务?

Spring同时支持编程式事务策略和声明式事务策略，大部分时候都采用声明式事务策略。声明式事务管理的配置方式，通常有以下4种：(1)使用TransactionProxyFactoryBean为目标Bean生成事务代理的配置。此方式是最传统、配置文件最臃肿... 查看详情

数据库事务之声明式事务

一、事务概述    1、在JavaEE企业级开发的应用领域，为了保证数据的完整性和一致性，必须引入数据库事务的概念，所以事务管理是企业级应用程序开发中必不可少的技术。    2、事务就是一组由于... 查看详情

spring声明式事务注解@transactional

spring支持编程式事务管理和声明式事务管理两种方式。编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。声明式事务管理建立在AOP之上的。其本... 查看详情

spring事务实现方式有哪些？

Spring提供了编程式事务和声明式事务两种实现方式，编程式事务允许用户在代码中精确定义事务的边界，而声明式事务（基于AOP）有助于用户将操作与事务规则进行解耦。简单地说，编程式事务侵入到了业务代码里面，但是提供... 查看详情

spring的事务，详解注解@transactional

事务管理是应用系统开发中必不可少的一部分。Spring为事务管理提供了丰富的功能支持。Spring事务管理分为编程式和声明式的两种方式。编程式事务指的是通过编码方式实现事务，编程式事务管理使用TransactionTemplate或者直接使... 查看详情

一文让你搞懂spring的统一事务模型

Spring事务的知识体系进入主题之前，先来了解一下Spring事务，都有哪些内容：Spring事务包含对分布式事务和单机事务的支持，我们用的比较多的是单机事务，也就是只操作一个数据库的事务。单机事务，按照用法分，又可以分为... 查看详情

java面试--java框架

1、spring是如何管理事务的？Spring并不是直接管理事务，而是提供了多种事务管理器，他们将事务管理的职责委托给持久化机制所提供的相关平台框架的事务来实现，spring为不同的事务API提供一致的编程模型。Spring的事务分为编... 查看详情

spring事务注解@transactional

事务管理一般有编程式和声明式两种，编程式是直接在代码中进行编写事物处理过程，而声名式则是通过注解方式或者是在xml文件中进行配置，相对编程式很方便。而注解方式通过@Transactional是常见的。我们可以使用@EnableTransacti... 查看详情