SSM之Spring（四）事务

最新推荐文章于 2024-04-01 18:44:33 发布

kaico2018

最新推荐文章于 2024-04-01 18:44:33 发布

阅读量663

点赞数 2

分类专栏： SSM框架

本文链接：https://blog.csdn.net/weixin_44044929/article/details/119112033

版权

SSM框架专栏收录该内容

13 篇文章 1 订阅

订阅专栏

事务控制概述

事务的特性（ACID属性）

原子性（Atomicity）：事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用。
一致性（Consistency）：一旦事务完成（不管成功还是失败），系统必须确保它所建模的业务处于一致的状态，而不会是部分完成部分失败。在现实中的数据不应该被破坏。
隔离性（Isolation）：可能有许多事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。
持久性（Durability）：一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响，这样就能从任何系统崩溃中恢复过来。通常情况下，事务的结果被写到持久化存储器中。

Spring的事务控制是属于Spring Dao模块的。

一般地，**我们事务控制都是在service层做的。**为什么是在service层而不是在dao层呢？？有没有这样的疑问…
service层是业务逻辑层，service的方法一旦执行成功，那么说明该功能没有出错。

一个service方法可能要调用dao层的多个方法…如果在dao层做事务控制的话，一个dao方法出错了，仅仅把事务回滚到当前dao的功能，这样是不合适的[因为我们的业务由多个dao方法组成]。如果没有出错，调用完dao方法就commit了事务，这也是不合适的[导致太多的commit操作]。

事务控制分为两种：

编程式事务控制
声明式事务控制

回滚规则

在默认设置下，事务只在出现运行时异常（runtime exception）时回滚，而在出现受检查异常（checked exception）时不回滚（这一行为和EJB中的回滚行为是一致的）。
不过，可以声明在出现特定受检查异常时像运行时异常一样回滚。同样，也可以声明一个事务在出现特定的异常时不回滚，即使特定的异常是运行时异常。

编程式事务控制

自己手动控制事务，就叫做编程式事务控制。

Jdbc代码：
Conn.setAutoCommite(false); // 设置手动控制事务
Hibernate代码：
Session.beginTransaction(); // 开启一个事务
【细粒度的事务控制：可以对指定的方法、指定的方法的某几行添加事务控制】
(比较灵活，但开发起来比较繁琐：每次都要开启、提交、回滚.)

声明式事务控制

Spring提供对事务的控制管理就叫做声明式事务控制。

Spring提供了对事务控制的实现

如果用户想要使用Spring的事务控制，只需要配置就行了。
当不用Spring事务的时候，直接移除就行了。
Spring的事务控制是基于AOP实现的。因此它的耦合度是非常低的。
【粗粒度的事务控制：只能给整个方法应用事务，不可以对方法的某几行应用事务。】(因为aop拦截的是方法。)

Spring给我们提供了事务的管理器类
在这里插入图片描述
AbstractPlatformTransactionManager抽象类实现了Spring事务的标准流程，其子类DataSourceTransactionManager是我们使用较多的JDBC单数据源事务管理器，而JtaTransactionManager是JTA（Java Transaction API）规范的实现类，另外两个则分别是JavaEE容器WebLogic和WebSphere的JTA事务管理器的具体实现。

代码案例

基于Spring的JDBC来做例子
1、引入jar包

AOP相关的jar包【因为Spring的声明式事务控制是基于AOP的，那么就需要引入AOP的jar包。】
引入tx名称空间
引入AOP名称空间
引入jdbcjar包【jdbc.jar包和tx.jar包】

2、编写java代码
dao接口

public interface IUser {
    void save();
}

UserDao实现类，使用JdbcTemplate对数据库进行操作！


@Repository
public class UserDao implements IUser {

    //使用Spring的自动装配
    @Autowired
    private JdbcTemplate template;

    @Override
    public void save() {
        String sql = "insert into user(name,password) values('zhong','222')";
        template.update(sql);
    }

}

service层代码

@Service
public class UserService {

    @Autowired
    private UserDao userDao;
    public void save() {
		userDao.save();
		//制造异常，测试数据回滚
        int i = 1 / 0;

        userDao.save();
    }
}

3、bean.xml配置：配置数据库连接池、jdbcTemplate对象、扫描注解


<?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:context="http://www.springframework.org/schema/context"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">


    <!--数据连接池配置-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///zhongfucheng"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
        <property name="initialPoolSize" value="3"></property>
        <property name="maxPoolSize" value="10"></property>
        <property name="maxStatements" value="100"></property>
        <property name="acquireIncrement" value="2"></property>
    </bean>

    <!--扫描注解-->
    <context:component-scan base-package="bb"/>

    <!-- 2. 创建JdbcTemplate对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

</beans>

测试代码


public class Test2 {

    @Test
    public void test33() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bb/bean.xml");

        UserService userService = (UserService) ac.getBean("userService");
        userService.save();
    }
}

4、XML方式实现声明式事务控制
首先，要配置事务的管理器类

<!--1.配置事务的管理器类:JDBC-->
<bean id="txManage" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

    <!--引用数据库连接池-->
    <property name="dataSource" ref="dataSource"/>
</bean>

再而，配置事务管理器类如何管理事务


<!--2.配置如何管理事务-->
<tx:advice id="txAdvice" transaction-manager="txManage">
    
    <!--配置事务的属性-->
    <tx:attributes>
        <!--所有的方法，并不是只读-->
        <tx:method name="*" read-only="false"/>
    </tx:attributes>
</tx:advice>

最后，配置拦截哪些方法


<!--3.配置拦截哪些方法+事务的属性-->
<aop:config>
    <aop:pointcut id="pt" expression="execution(* bb.UserService.*(..) )"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"></aop:advisor>
</aop:config>

执行测试代码：
在这里插入图片描述
5、使用注解的方法实现事务控制
当然了，有的人可能觉得到XML文件上配置太多东西了。Spring也提供了使用注解的方式来实现对事务控制

第一步和XML的是一样的，必须配置事务管理器类：


<!--1.配置事务的管理器类:JDBC-->
<bean id="txManage" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

    <!--引用数据库连接池-->
    <property name="dataSource" ref="dataSource"/>
</bean>

第二步：开启以注解的方式来实现事务控制


<!--开启以注解的方式实现事务控制-->
<tx:annotation-driven transaction-manager="txManage"/>

最后，**想要控制哪个方法事务，在其前面添加@Transactional这个注解就行了！**如果想要控制整个类的事务，那么在类上面添加就行了。


@Transactional
public void save() {

    userDao.save();

    int i = 1 / 0;
    userDao.save();
}

事务属性

其实**我们在XML配置管理器类如何管理事务，就是在指定事务的属性！**我们来看一下事务的属性有什么：
在这里插入图片描述

事务的传播行为（机制）

事务的传播性一般用在事务嵌套的场景，比如一个事务方法里面调用了另外一个事务方法，那么两个方法是各自作为独立的方法提交还是内层的事务合并到外层的事务一起提交，这就是需要事务传播机制的配置来确定怎么样执行。（使用的话就是配置事务对应的属性）

常用的事务传播机制如下：

PROPAGATION_REQUIRED
Spring默认的传播机制，能满足绝大部分业务需求，如果外层有事务，则当前事务加入到外层事务，一块提交，一块回滚。如果外层没有事务，新建一个事务执行
PROPAGATION_REQUES_NEW
该事务传播机制是每次都会新开启一个事务，同时把外层事务挂起，当当前事务执行完毕，恢复上层事务的执行。如果外层没有事务，执行当前新开启的事务即可
PROPAGATION_SUPPORT
如果外层有事务，则加入外层事务，如果外层没有事务，则直接使用非事务方式执行。完全依赖外层的事务
PROPAGATION_NOT_SUPPORT
该传播机制不支持事务，如果外层存在事务则挂起，执行完当前代码，则恢复外层事务，无论是否异常都不会回滚当前的代码
PROPAGATION_NEVER
该传播机制不支持外层事务，即如果外层有事务就抛出异常
PROPAGATION_MANDATORY
与NEVER相反，如果外层没有事务，则抛出异常
PROPAGATION_NESTED
该传播机制的特点是可以保存状态保存点，当前事务回滚到某一个点，从而避免所有的嵌套事务都回滚，即各自回滚各自的，如果子事务没有把异常吃掉，基本还是会引起全部回滚的。

传播规则回答了这样一个问题：一个新的事务应该被启动还是被挂起，或者是一个方法是否应该在事务性上下文中运行。

数据库的隔离级别（方法）

事务的隔离级别定义一个事务可能受其他并发务活动活动影响的程度，可以把事务的隔离级别想象为这个事务对于事物处理数据的自私程度。（使用的话就是配置事务对应的属性）

在一个典型的应用程序中，多个事务同时运行，经常会为了完成他们的工作而操作同一个数据。并发虽然是必需的，但是会导致以下问题：

脏读（Dirty read）
脏读发生在一个事务读取了被另一个事务改写但尚未提交的数据时。如果这些改变在稍后被回滚了，那么第一个事务读取的数据就会是无效的。
不可重复读（Nonrepeatable read）
不可重复读发生在一个事务执行相同的查询两次或两次以上，但每次查询结果都不相同时。这通常是由于另一个并发事务在两次查询之间更新了数据。不可重复读重点在修改。
幻读（Phantom reads）
幻读和不可重复读相似。当一个事务（T1）读取几行记录后，另一个并发事务（T2）插入了一些记录时，幻读就发生了。在后来的查询中，第一个事务（T1）就会发现一些原来没有的额外记录。

在理想状态下，事务之间将完全隔离，从而可以防止这些问题发生。然而，完全隔离会影响性能，因为隔离经常涉及到锁定在数据库中的记录（甚至有时是锁表）。**完全隔离要求事务相互等待来完成工作，会阻碍并发。**因此，可以根据业务场景选择不同的隔离级别。

隔离级别：

ISOLATION_DEFAULT：使用后端数据库默认的隔离级别
ISOLATION_READ_UNCOMMITTED：允许读取尚未提交的更改。可能导致脏读、幻读或不可重复读。
ISOLATION_READ_COMMITTED：（Oracle 默认级别）允许从已经提交的并发事务读取。可防止脏读，但幻读和不可重复读仍可能会发生。
ISOLATION_REPEATABLE_READ：（MYSQL默认级别）对相同字段的多次读取的结果是一致的，除非数据被当前事务本身改变。可防止脏读和不可重复读，但幻读仍可能发生。
ISOLATION_SERIALIZABLE：完全服从ACID的隔离级别，确保不发生脏读、不可重复读和幻影读。这在所有隔离级别中也是最慢的，因为它通常是通过完全锁定当前事务所涉及的数据表来完成的。

事务超时

为了使一个应用程序很好地执行，它的事务不能运行太长时间。因此，声明式事务的下一个特性就是它的超时。

假设事务的运行时间变得格外的长，由于事务可能涉及对数据库的锁定，所以长时间运行的事务会不必要地占用数据库资源。这时就可以声明一个事务在特定秒数后自动回滚，不必等它自己结束。

由于超时时钟在一个事务启动的时候开始的，因此，只有对于那些具有可能启动一个新事务的传播行为（PROPAGATION_REQUIRES_NEW、PROPAGATION_REQUIRED、ROPAGATION_NESTED）的方法来说，声明事务超时才有意义。

事务只读

如果一个事务只对数据库执行读操作，那么该数据库就可能利用那个事务的只读特性，采取某些优化措施。通过把一个事务声明为只读，可以给后端数据库一个机会来应用那些它认为合适的优化措施。由于只读的优化措施是在一个事务启动时由后端数据库实施的，因此，只有对于那些具有可能启动一个新事务的传播行为（PROPAGATION_REQUIRES_NEW、PROPAGATION_REQUIRED、 ROPAGATION_NESTED）的方法来说，将事务声明为只读才有意义。

Spring声明式事务配置参考

事物配置中有哪些属性可以配置?以下只是简单的使用参考

事务的传播性：
@Transactional(propagation=Propagation.REQUIRED)
事务的隔离级别：
@Transactional(isolation = Isolation.READ_UNCOMMITTED)

读取未提交数据(会出现脏读, 不可重复读) 基本不使用

只读：
@Transactional(readOnly=true)
该属性用于设置当前事务是否为只读事务，设置为true表示只读，false则表示可读写，默认值为false。
事务的超时性：
@Transactional(timeout=30)
回滚：
指定单一异常类：@Transactional(rollbackFor=RuntimeException.class)
指定多个异常类：@Transactional(rollbackFor={RuntimeException.class, Exception.class})
该属性用于设置需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，则进行事务回滚。