事务PlatformTransactionManager

说到PlatformTransactionManager不得不提事务的三个接口：

1.事务三大接口

PlatformTransactionManager 事务管理器
TransactionDefinition 事务的一些基础信息，如超时时间、隔离级别、传播属性等
TransactionStatus 事务的一些状态信息，如是否一个新的事务、是否已被标记为回滚

2.PlatformTransactionManager

public interface PlatformTransactionManager {
    //根据事务定义TransactionDefinition，获取事务
    TransactionStatus getTransaction(TransactionDefinition definition);
    //提交事务
    void commit(TransactionStatus status);
    //回滚事务
    void rollback(TransactionStatus status);
}

2.1 事务定义接口TransactionDefinition

事务的定义包括: 事务的隔离级别，事务的传播属性，超时时间设置，是否只读
事务的隔离级别是数据库本身的事务功能，事务的传播属性则是spring为我们提供的功能
该接口的实现DefaultTransactionDefinition,默认的事务定义

public class DefaultTransactionDefinition implements TransactionDefinition, Serializable {
    private int propagationBehavior = PROPAGATION_REQUIRED;
    private int isolationLevel = ISOLATION_DEFAULT;
    private int timeout = TIMEOUT_DEFAULT;
    private boolean readOnly = false;
}

1.事务的传播属性为PROPAGATION_REQUIRED，即当前没有事务的时候，创建一个，如果有则使用当前事务 2.事务的隔离级别采用底层数据库默认的隔离级别 3.超时时间采用底层数据库默认的超时时间 4.是否只读为false

2.2 事务接口定义 TransactionStatus

TransactionStatus它继承了SavepointManager接口，SavepointManager是对事务中上述保存点功能的封装，如下：

public interface SavepointManager {
    Object createSavepoint() throws TransactionException;
    void rollbackToSavepoint(Object savepoint) throws TransactionException;
    void releaseSavepoint(Object savepoint) throws TransactionException;
}

TransactionStatus本身更多存储的是事务的一些状态信息

是否是一个新的事物 是否有保存点 是。配个 否已被标记为回滚

整个流程:

 

    @Autowired
    private PlatformTransactionManager transactionManager;
    
    TransactionStatus status = null;
    // 手动开启事务
    status = transactionManager.getTransaction(new DefaultTransactionDefinition());
    // 事务提交
    transactionManager.commit(status);
    // 事务回滚
    if (StringMoreUtils.checkValNotNull(status)) {
        transactionManager.rollback(status);
    }

https://blog.youkuaiyun.com/weixin_42661074/article/details/86687761

3. 事务的基本要素 ACID

原子性，一致性，隔离性，持久性。 

4. 事务的并发问题

脏读，不可重复读，幻读，不可重复读

5. 事务管理方式

spring支持编程式事务管理和声明式事务管理两种方式。
编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。
声明式事务管理建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式)，便可以将事务规则应用到业务逻辑中。
显然声明式事务管理要优于编程式事务管理，这正是spring倡导的非侵入式的开发方式。声明式事务管理使业务代码不受污染，一个普通的POJO对象，只要加上注解就可以获得完全的事务支持。和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法等等。

 

下面提供一个对支持事务操作的工具类，简单的对事物进行的封装，仅供参考

import java.util.function.Function;
import java.util.function.Supplier;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import lombok.extern.slf4j.Slf4j;

/**
 * 提供自定义的事物支持操作
 */
@Slf4j
@Component
public class TransactionWrapper {

    @Autowired
    private PlatformTransactionManager txManager;

    /**
     * 支持自定义事物控制配置
     * 
     * @param def
     * @param function
     * @param params
     * @return
     */
    public <T> T wrap(DefaultTransactionDefinition def, Function<Object[], T> function, Object... params) {
        TransactionStatus status = txManager.getTransaction(def);
        T result = null;
        try {
            result = function.apply(params);
        } catch (Exception ex) {
            txManager.rollback(status);
            throw ex;
        }
        txManager.commit(status);
        return result;
    }

    public void wrap(DefaultTransactionDefinition def, Runnable runnable) {
        TransactionStatus status = txManager.getTransaction(def);
        try {
            runnable.run();
        } catch (Exception ex) {
            txManager.rollback(status);
            throw ex;
        }
        txManager.commit(status);
    }

    @Transactional
    public <T> T wrap(Function<Object[], T> function, Object... params) {
        return function.apply(params);
    }

    @Transactional
    public <T> T wrap(Supplier<T> supplier) {
        return supplier.get();
    }

    @Transactional
    public void wrap(Runnable runnable) {
        runnable.run();
    }
}