[Java知识库]spring学习笔记（五）5.Spring事务管理

5 Spring事务管理

事务原本是数据库中的概念，在 Dao 层。但在实际开发中，一般将事务提升到业务层，即 Service 层。这样做是为了能够使用事务的特性来管理具体的业务。

5.1 Spring事务管理API

Spring 的事务管理，主要用到两个事务相关的接口。

5.1.1 事务管理器接口

事务管理器是 PlatformTransactionManager 接口对象。其主要用于完成事务的提交、回滚，及获取事务的状态信息。

PlatformTransactionManager 接口常用的实现类：

DataSourceTransactionManager：使用 JDBC 或 MyBatis 进行数据库操作时使用。

Spring的回滚方式

Spring 事务的默认回滚方式是：发生运行时异常和 error 时回滚，发生受查(编译)异常时提交。不过，对于受查异常，程序员也可以手工设置其回滚方式。

5.1.2 事务定义接口

事务定义接口 TransactionDefinition 中定义了事务描述相关的三类常量：事务隔离级别、事务传播行为、事务默认超时时限，及对它们的操作。

5.1.2.1 事务隔离级别常量

这些常量均是以 ISOLATION_开头。即形如 ISOLATION_XXX。

• DEFAULT：采用 DB 默认的事务隔离级别。MySql 的默认为 REPEATABLE_READ； Oracle默认为READ_COMMITTED。

• READ_UNCOMMITTED：读未提交。未解决任何并发问题。

• READ_COMMITTED：读已提交。解决脏读，存在不可重复读与幻读。

• REPEATABLE_READ：可重复读。解决脏读、不可重复读，存在幻读

• SERIALIZABLE：串行化。不存在并发问题。

5.1.2.2 事务传播行为常量

所谓事务传播行为是指，处于不同事务中的方法在相互调用时，执行期间事务的维护情况。如，A 事务中的方法 doSome()调用 B 事务中的方法 doOther()，在调用执行期间事务的维护情况，就称为事务传播行为。事务传播行为是加在方法上的。

事务传播行为常量都是以 PROPAGATION_ 开头，形如 PROPAGATION_XXX。

Propagation.REQUIRED

? 当前没有事务的时候，就会创建一个新的事务；如果当前有事务，就直接加入该事务，比较常用的设置

Propagation.SUPPORTS

? 支持当前事务，如果当前有事务，就直接加入该事务；当前没有事务的时候，就以非事务方式执行
Propagation.MANDATORY

? 支持当前事务，如果当前有事务，就直接加入该事务；当前没有事务的时候，就抛出异常

Propagation.REQUIRES_NEW

? 创建新事务，无论当前是否有事务都会创建新的

PROPAGATION_NESTED

PROPAGATION_NEVER

PROPAGATION_NOT_SUPPORTED

5.1.2.3 默认事务超时时限

常量 TIMEOUT_DEFAULT 定义了事务底层默认的超时时限，sql 语句的执行时长。

注意，事务的超时时限起作用的条件比较多，且超时的时间计算点较复杂。所以，该值一般就使用默认值即可。

5.2 声明式事务控制

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

如果用户需要使用spring的声明式事务管理，在配置文件中配置即可：不想使用的时候直接移除配置。这种方式实现了对事务控制的最大程度的解耦。

声明式事务管理，核心实现就是基于AOP。

Spring中提供了对事务的管理。开发者只需要按照spring的方式去做就行。

事务必须在service层统一控制。

事务的粗细粒度：

? 细粒度：对方法中的某几行的代码进行开启提交回滚；

? 粗粒度：对整个方法进行开启提交回滚；

Spring中的aop只能对方法进行拦截，所有我们也就针对方法进行事务的控制。

如果只有单条的查询语句，可以省略事务；如果一次执行的是多条查询语句，例如统计结果、报表查询。必须开启事务。

5.3 基于注解的事务

package com.zisen.service;

import com.zisen.dao.TeamDao;
import com.zisen.pojo.Team;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class TeamService {
    @Autowired
    private TeamDao teamDao;

    /**
     * @Transactional 属性 说明：
     * readOnly:是否只读
     * *
     * rollbackFor={Exception.class}： 遇到什么异常会回滚
     * *
     * propagation事务的传播：
     * Propagation.REQUIRED:当前没有事务的时候，就会创建一个新的事务；如果当前有事务，就直接加入该事务，比较常用的设置
     * Propagation.SUPPORTS:支持当前事务，如果当前有事务，就直接加入该事务；当前没有事务的时候，就以非事务方式执行
     * Propagation.MANDATORY:支持当前事务，如果当前有事务，就直接加入该事务；当前没有事务的时候，就抛出异常
     * Propagation.REQUIRES_NEW:创建新事务，无论当前是否有事务都会创建新的
     * *
     * isolation=Isolation.DEFAULT：事务的隔离级别：默认是数据库的隔离级别
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor ={Exception.class})
    public int insert(Team team) {
        int num1 = teamDao.insert(team);
        System.out.println("第一条执行结果：num1=" + num1);
        System.out.println(10 / 0);
        int num2 = teamDao.insert(team);
        System.out.println("第二条执行结果：num2=" + num2);
        return num2 + num1;
    }
}

<?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:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!--配置文件中添加tx和context约束-->
    
    <!--配置JdbcTemplate的数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/springjdbc?serverTimezone=UTC&amp;characterEncoding=utf8&amp;useUnicode=true&amp;useSSL=false"></property>
        <property name="user" value="root"></property>
        <property name="password" value=""></property>
    </bean>
    <!--创建JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <bean id="teamDao" class="com.zisen.dao.TeamDao">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
    <context:component-scan base-package="com.zisen.service"/>
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

@Test
public void test01(){
    ApplicationContext ac=new
    ClassPathXmlApplicationContext("application.xml");
    TeamService teamService = (TeamService) ac.getBean("teamService");
    int num=teamService.insert(new Team("凯尔特人","波士顿"));
    System.out.println(num);
}

5.4 基于xml的事务

添加依赖

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>

application.xml

<!-- 事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource"/>
</bean>
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="insert*" propagation="REQUIRED"/>
        <tx:method name="add*" propagation="REQUIRED"/>
        <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
    </tx:attributes>
</tx:advice>
<aop:config>
    <aop:pointcut id="pt" expression="execution(* com.kkb.service..*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pt" />
</aop:config>