Spring-事务处理机制

spring中事务处理机制的相关API

事务管理，其实就是根据给定的规则对事务执行提交或者回滚的操作。spring中相关的接口有以下三种；

TransactionDefinition、PlatdormTransactionManager和TransactionStatus

1、PlatformTransactionManager

//事务管理器-对事物的管理
public interface PlatformTransactionManager {
        //获得事务的状态
        TransactionStatus getTransaction(TransactionDefinition     
         definition) throws TransactionException;
        //事务提交方法
        void commit(TransactionStatus status) throws 
        TransactionException;
         //事务回滚方法
         void rollback(TransactionStatus status) throws 
         TransactionException;
}

2、TransactionDefinition

//规则信息定义--定义事务相关的属性
private interface TransactioinDefinition{
//获取隔离级别
int getIsolationLevel();
//获取传播行为
int getPropagationBehavior();
//获取超时时间
int getTimeout();
//是否可读
boolean isReadOnly();
}

3、TransactionStatus

//事务的状态获取--事务管理的过程中，可以通过改接口中的方法获取事务的状态信息
public interface TransactionStatus{
//当前事务是否是新的事务
boolean isNewTransaction();
//是否有保存点
boolean hasSavepoint();
//设置回滚
void setRollbackOnly();
//是否已被标记为回滚
boolean isRollbackOnly();
}

TransactionDefinition接口定义的事务规则

事务隔离级别、事务传播行为、事务超时、事务的只读属性和事务的回滚规则：

1、事务的隔离级别

所谓的事务的隔离级别是指若干个并发的事务之间的隔离程度。TransactionDefinition接口中定义了五个表示隔离级别的常量：

2、事务的传播行为

所谓事务的传播行为是指，如果在开始当前事务之前，一个事务的上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。TransactionDefinition接口定义了如下几个表示传播行为的常量：

1. PROPAGATION_REQUIRED :支持当前事务，如果不存在就新建一个
- 如果A有事务，B使用A的事务，如果A没有事务，B就开启一个新的事务.(A,B是在一个事务中。)
2. PROPAGATION_SUPPORTS :支持当前事务，如果不存在，就不使用事务
- 如果A有事务，B使用A的事务，如果A没有事务，B就不使用事务.
3. PROPAGATION_MANDATORY :支持当前事务，如果不存在，抛出异常
- 如果A有事务，B使用A的事务，如果A没有事务，抛出异常.
4. PROPAGATION_REQUIRES_NEW 如果有事务存在，挂起当前事务，创建一个新的事务
- 如果A有事务，B将A的事务挂起，重新创建一个新的事务.(A,B不在一个事务中.事务互不影响.)
5. PROPAGATION_NOT_SUPPORTED 以非事务方式运行，如果有事务存在，挂起当前事务
- 非事务的方式运行，A有事务，就会挂起当前的事务.
6. PROPAGATION_NEVER 以非事务方式运行，如果有事务存在，抛出异常
7. PROPAGATION_NESTED 如果当前事务存在，则嵌套事务执行
3、事务超时

事务超时，就是指一个事务被允许执行的最长时间，如果超过改时间限制且事务还没有完成，就会自动回滚事务（单位是秒）。

4、事务的只读属性

事务的只读属性是指对事务性资源进行只读操作或者是读写操作。如果确定只对事务性资源进行查询操作，那么可以可以将事务标志为只读的，可以提高事务处理的性能（boolean控制）。

5、事务的回滚规则

通常情况下，如果事务中抛出了未检查·异常，则默认将回滚事务，如果没有抛出任何异常，或者抛出了已检查异常，则仍然提交事务。

编程式事务

编程式事务是基于传统的事务处理思路，采用在程序中显式调用commit()、rollback()等事务管理的方法，来实现对事务的控制，编程式事务有两种实现方式，下面为编程式事务的实例：

1、基于API

public class AdminServiceImpl implements AdminService {
    private AdminDao adminDao;
    // 定义规则信息接口的对象
    private TransactionDefinition txDefinition;
    // 事务管理器接口的对象
    private PlatformTransactionManager txManager;
    // 通过id修改admin的信息
    public boolean modifyAdminInf(Integer id, Admin admin) {
        // 通过管理器使用规则信息获取一个事务,并启动
        TransactionStatus txStatus = txManager.getTransaction(txDefinition);
        boolean result = false;
        try {
            result = adminDao.updateAdminById(id, admin);
            txManager.commit(txStatus);// 事务提交
        } catch (Exception e) {
            result = false;
            txManager.rollback(txStatus);// 事务回滚
            System.out.println("Modify Error!");
        }
        return result;
    }
}

<bean id="AdminService " class="org.lanqiao.service.AdminServiceImpl ">
    <property name="adminDao" ref="adminDao"/>
    <property name="txManager" ref="transactionManager"/>
    <property name="txDefinition">
    <bean class="org.springframework.transaction.support.DefaultTransactionDefinition">
        <property name="propagationBehaviorName" value="PROPAGATION_REQUIRED"/>
    </bean>
    </property>
</bean>

2、基于TransactionTemplate

public class AdminServiceImpl implements AdminService {
    private AdminDao adminDao;
    private TransactionTemplate transactionTemplate;
    ......
    public boolean modifyAdminInf(Integer id, Admin admin) {
        return (Boolean) transactionTemplate.execute(new TransactionCallback(){
            public Object doInTransaction(TransactionStatus status) {
                Object result;
                try {
                    result = adminDao.updateAdminById(id, admin);
                } catch (Exception e) {
                    status.setRollbackOnly();
                    result = false;
                    System.out.println("Modify Error!");
                }
                return result;
            }
        });
    }
}

<bean id="AdminService " class="org.lanqiao.service.AdminServiceImpl ">
    <property name="adminDao" ref="adminDao"/>
    <property name="transactionTemplate" ref="transactionTemplate"/>
</bean>

从以上两个实现方式可以看出，虽然使用TransactionTemplate可以解决事务处理与程序之间耦合的问题，但是过程过于繁琐。spring中有以下声明式事务来解决耦合和处理复杂的问题。

声明式事务

spring的声明式事务管理是建立在Spring AOP机制之上，他本质是对目标方法所在的切面织入事务操作（创建或者加入一个事务；执行提交或者回滚事务）

1、使用Spring的事务注解管理事务

通过@Transaction注解1方式，可将事务织入到相应的public方法中，实现事务管理。

1、@Transactional 的所有可选属性如下所示：

propagation：用于设置事务传播属性。该属性类型为 Propagation 枚举，
默认值为 Propagation.REQUIRED。
isolation：用于设置事务的隔离级别。该属性类型为 Isolation 枚举，默认
值为 Isolation.DEFAULT。
readOnly：用于设置该方法对数据
库的操作是否是只读的。该属性为
boolean，默认值为 false。
timeout：用于设置本操作与数据库连接的超时时限。单位为秒，类型为 int，
默认值为-1，即没有时限。
rollbackFor：指定需要回滚的异常类。类型为 Class[]，默认值为空数组。
当然，若只有一个异常类时，可以不使用数组。
rollbackForClassName：指定需要回滚的异常类类名。类型为 String[]，默
认值为空数组。当然，若只有一个异常类时，可以不使用数组。
noRollbackFor：指定不需要回滚的异常类。类型为 Class[]，默认值为空数
组。当然，若只有一个异常类时，可以不使用数组。
noRollbackForClassName：指定不需要回滚的异常类类名。类型为 String[]，
默认值为空数组。当然，若只有一个异常类时，可以不使用数组。
Spring 会忽略掉所有非public 方法上的@Transaction 注解。
若@Transaction 注解在类上，则表示该类上所有的方法均将在执行时织入事务。

2、具体步骤

1、声明事务管理器

2、开启注解驱动

3、业务层 public 方法加入事务属性

2、使用 AspectJ的AOP配置管理事务

1、maven 依赖 pom.xml，新加入 aspectj 的依赖坐标

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.2.5.RELEASE</version>
</dependency>

2、在容器中添加事务管理器

3、配置事务通知，为事务通知设置相关属性。用于指定要将事务以什么方式织入给哪些方法。

4、配置增强器，指定将配置好的事务织入给哪个方法。

posted @ 2022-05-05 21:45 起眠阅读(424) 评论(0) 收藏举报

刷新页面返回顶部

ouyangPH