背景

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

面临的难点：

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

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,?)";
        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来标注申明式事务，可以标准在类或者方法上；

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

说明：

事务的安装过程：

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

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

流程如图：

使用方式大大简化；

代码

 @Transactional
    public int insertUserLoginTransaction(String username,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个架子的事务管理器对比：

mybatis的代码实例点我！

事务隔离级别

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

数据库事务4个特性

即ACID

隔离级别：

选择依据

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

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

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

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

事务传播行为

传播行为是方法之间调用事务采取的策略问题。
场景：一个批量任务处在一个事务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
• REQUIRES_NEW
• NESTED

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

代码点我！

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

@Transaction自调用失效问题

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