[Java知识库]声明式事务控制

编程式事务控制相关对象

编程式是自己使用Java的API写代码，声明式是以配置的方式进行配置一些东西

PlatformTransactionManager

PlatformTransactionManager接口是spring的事务管理器，它里面提供了我们常用的操作事务的方法，即事务是如何控制的

注意：PlatformTransactionManager是接口类型，不同的Dao层技术则有不同的实现类，例如：Dao层技术是jdbc或mybatis时：org.springframework.jdbc.datasource.DataSourceTransactionManager;Dao层技术是hibernate时:org.springframework.orm.hibernate5.HibernateTransactionManager

TransactionDefinition

维护事务的属性信息
TransactionDefinition是事务的定义信息对象，里面有如下方法

事务隔离级别

设置隔离级别，可以解决事务并发产生的问题，如脏读、不可重复读和虚读
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复度：在同一个事务中，两次读取到的数据不一样
幻读：一个事务操作（DML）数据表示所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。
ISOLATION_DEFAULT 默认的
ISOLATION_READ_UNCOMITTED 读未提交（产生的问题：脏读、不可重负读、幻读）
ISOLATION_READ_COMMITTED 读已提交（产生的问题：不可重负读、幻读）
ISOLATION_REPEATABLE_READ 不可重复读
ISOLATION_SERIALIZABLE 串行化，可以解决所有问题

事务传播行为

在事运行过程中封装一些状态信息，被动信息
业务方法在调用业务方法时事务统一性的问题。在正常开发中，业务层有很多方法，当A B两个方法互相调用时，我们事先都对他们进行事务控制，就可能会出现事务重复的问题
REQUIRED:如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值)
SUPPORTS:支持当前事务，如果当前没有事务，就以非事务方式执行(没有事务)
MANDATORY:使用当前的事务，如果当前没有事务，就抛出异常
REQUERS_NEW:新建事务，如果当前在事务中，把当前事务挂起。
NOT_SUPPORTED:以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
NEVER:以非事务方式运行，如果当前存在事务，抛出异常
NESTED:如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行REQUIRED类似的操作
超时时间:默认值是-1，没有超时限制。如果有，以秒为单位进行设置
是否只读:建议查询时设置为只读

TransactionStatus

TransactionStatus接口提供的是事务具体的运行状态，方法介绍如下

基于XML的声明式事务控制

Spring的声明式事务顾名思义就是采用声明的方式来处理事务，这里所说的声明，就是指在配置文件中声明，用在Spring配置文件中声明式的处理事务来代替码式的处理事务。

声明式事务处理的作用

1、事务管理不侵入开发的组件，具体来说，业务逻辑对象就不会意识到正在事务管理之中，事实上也应该如此，因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策划的话，也只需要在定义文件中重新配置即可
2、在不需要事务管理的时候，只要在设文件上修改一下，即可移去事务管理服务，无需改变代码重新编译，这样维护起来及其方便
Spring声明式事务控制的底层就是AOP

声明式事务控制的实现

声明式事务控制的明确事项：
谁是切点？业务方法被增强
谁是通知？事务增强
配置切面？将事务增强和业务方法进行织入
0、编写dao层和service层

package com.zg.dao.impl;
import com.zg.dao.AccountDao;
import org.springframework.jdbc.core.JdbcTemplate;

public class AccountDaoImpl implements AccountDao {

    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public void out(String outMan, double money) {
        jdbcTemplate.update("update account set money=money-? where name=?",money,outMan);
    }

    public void in(String inMan, double money) {
        jdbcTemplate.update("update account set money=money+? where name=?",money,inMan);
    }
}

package com.zg.service.impl;


import com.zg.dao.AccountDao;
import com.zg.service.AccountService;

public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao;
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public void transfer(String outMan, String inMan, double money) {
        //这里本来需要开启事务
        accountDao.out(outMan,money);
        int i = 1/0;
        accountDao.in(inMan,money);
        //提交事务
    }
}

1、引入tx命名空间，配置事务增强，配置事务AOP织入

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

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test?serverTimezone=UTC"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <bean id="accountDao" class="com.zg.dao.impl.AccountDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>

    <!--目标对象，内部的方法就是切点-->
    <bean id="accountService" class="com.zg.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>

    <!--配置一个平台事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
        <!--transactionManager底层需要从dataSource中获取一个进行事务的控制-->
        <!--jdbc模板就是对jdbc简单的封装，这个平台管理器内部在管理事务时，需要连接对象connection，connection源于数据源所需要注入dataSource-->
    </bean>

    <!--通知 事务的增强事务的命名空间为tx-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes<--tx 事务 attributs 属性-->
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

    <!--配置aop的事务织入-->
    <aop:config>
        <!--advisor是Spring对事务控制的专门配置-->
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.zg.service.impl.*.*(..))"></aop:advisor>
    </aop:config>
</beans>

如果dao层的实现不是原生的jdbc，不是Mybatis，有可能平台管理器会跟着变化
2、测试事务控制转账业务代码

package com.zg.service.impl;


import com.zg.dao.AccountDao;
import com.zg.service.AccountService;

public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao;
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public void transfer(String outMan, String inMan, double money) {
        //这里本来需要开启事务
        accountDao.out(outMan,money);
        int i = 1/0;
        accountDao.in(inMan,money);
        //提交事务
    }
}

切点方法的事务参数的配置

<!--通知 事务的增强事务的命名空间为tx-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

其中，<tx:method>代表切点方法的事务参数的配置，例如
<tx:attributes>就是设置事务的属性信息

<tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" timeout="-1" read-only="false"/>
<--这里因为transfer是增强，所以是对transfer单独的事务配置，如果还有其他方法则复制重新写，一个事务可以分别配置属于该事务的属性参数-->

nam="*" *：代表任意方法
name="update*" ：表示以update开头的方法
name:切点方法名称
isolation:事务的隔离级别
propagation：事务的传播行为
timeout：超时时间
read-only：是否可读

基于注解的声明式事务控制

使用注解配置声明式事务控制

1、编写dao

package com.zg.dao.impl;
import com.zg.dao.AccountDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;


    public void out(String outMan, double money) {
        jdbcTemplate.update("update account set money=money-? where name=?",money,outMan);
    }

    public void in(String inMan, double money) {
        jdbcTemplate.update("update account set money=money+? where name=?",money,inMan);
    }
}

2、编写service

package com.zg.service.impl;


import com.zg.dao.AccountDao;
import com.zg.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service("accountService")
//也可在类上添加事务控制，表示底下这个类中的所有方法都使用这个指定的事务控制参数
@Transactional(isolation = Isolation.READ_COMMITTED)
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;
    //上下都有则就近原则为主
    @Transactional(isolation = Isolation.READ_COMMITTED,propagation = Propagation.REQUIRED)
    public void transfer(String outMan, String inMan, double money) {
        //这里本来需要开启事务
        accountDao.out(outMan,money);
        int i = 1/0;
        accountDao.in(inMan,money);
        //提交事务
    }
}

3、编写application.xml配置文件

<?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:aop="http://www.springframework.org/schema/aop"
       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/aop http://www.springframework.org/schema/aop/spring-aop.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
">
    <!--组件扫描-->
    <context:component-scan base-package="com.zg"/>

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test?serverTimezone=UTC"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>


    <!--配置一个平台事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
        <!--transactionManager底层需要从dataSource中获取一个进行事务的控制-->
        <!--jdbc模板就是对jdbc简单的封装，这个平台管理器内部在管理事务时，需要连接对象connection，connection源于数据源所需要注入dataSource-->
    </bean>
    <!--事务的注解驱动-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
</beans>

这里通过在xml文件中开启的事务注解驱动"通知"Spring容器对标注@Transactional注解的Bean进行加工处理，以织入事务管理切面

注解配置声明式事务控制解析

1、@Transactional在需要进行事务控制的类或方法上修饰，注解可用的属性同xml配置方式，例如：隔离级别、传播行为等。
2、注解使用在类上，那么该类下的所有方法都使用同一套注解参数配置
3、使用在方法上，不同的方法可以采用不同的事务参数配置
4、XML配置文件中要开启事务的注解驱动<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>