Transactional声明式事务

介绍

1.声明式事务管理建立在AOP之上的. 其本质是对方法前后进行拦截, 然后在目标方法开始之前创建或者加入一个事务, 在执行完目标方法之后根据执行情况提交或者回滚事务.
2.声明式事务最大的优点就是不需要通过编程的方式管理事务, 这样就不需要在业务逻辑代码中掺杂事务管理的代码, 只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式), 便可以将事务规则应用到业务逻辑中.
3.声明式事务不足的地方在于, 与编程式事务相比, 只能作用到方法级别, 无法像编程式事务那样可以作用到代码块级别.

xml配置

1.添加命名空间

<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/tx
        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

2.添加相关事务支持

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!-- 指向数据源 -->
    <property name="dataSource" ref="masterDataSource"/>
</bean>
<!-- 开启事务的Annotation支持 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

@Transactional注解使用

@Transactional 可以作用于接口,接口方法,类以及类方法上. 只需要在相应接口,类或方法上加上@Transactional注解即可.

@Transactional 注解介绍

package org.springframework.transaction.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.core.annotation.AliasFor;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;

/**
 * @Target({ElementType.METHOD, ElementType.TYPE}) : 可用于接口, 类, 枚举, 注解, 方法
 * @Retention(RetentionPolicy.RUNTIME) : 注解会在class字节码文件中存在，在运行时可以通过反射获取到
 * @Inherited :　子类可以继承父类中的注解
 * @Documented : 注解将被包含在javadoc中
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {

    /**
     * 事务管理器的别名
     * 系统指定多个事务管理器时可通过别名进行区分
     */
    @AliasFor("transactionManager")
    String value() default "";

    /**
     * 可通过在 transactionManager 中设置 <qualifier value="managerOne"/> 属性类指定名称
     * 可用于确定目标事务管理器，匹配特定的限定符值（或bean名称）
     */
    @AliasFor("value")
    String transactionManager() default "";

    /**
     * 事务的传播机制
     * 默认 Propagation.REQUIRED
     */
    Propagation propagation() default Propagation.REQUIRED;

    /**
     * 事务的隔离级别
     * 默认 Isolation.DEFAULT
     */
    Isolation isolation() default Isolation.DEFAULT;

    /**
     * 事务超时时间
     * 默认 TransactionDefinition.TIMEOUT_DEFAULT 即 -1
     */
    int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;

    /**
     * 设置事务只读
     */
    boolean readOnly() default false;

    /**
     * 设置需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，则进行事务回滚
     * rollbackFor = Exception.class 或 rollbackFor = {RuntimeException.class, Exception.class}
     */
    Class<? extends Throwable>[] rollbackFor() default {};

    /**
     * 设置需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时, 事务进行回滚
     */
    String[] rollbackForClassName() default {};

    /**
     * 设置不需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，则不进行事务回滚
     */
    Class<? extends Throwable>[] noRollbackFor() default {};

    /**
     * 设置不需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时, 事务不进行回滚
     */
    String[] noRollbackForClassName() default {};

}

传播行为介绍

事务的传播行为, 一共 7 种
1.枚举介绍

package org.springframework.transaction.annotation;

import org.springframework.transaction.TransactionDefinition;

public enum Propagation {

    /**
     * 支持当前事务, 如果不存在, 则创建一个新事务
     * 事务的默认设置
     */
    REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),

    /**
     * 支持当前事务, 如果不存在, 则以非事务方式执行
     */
    SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),

    /**
     * 支持当前事务, 如果不存在则抛出异常
     */
    MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),

    /**
     * 开始一个新的事务, 并暂停当前事务(如果存在)
     */
    REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),

    /**
     * 以非事务方式执行, 暂停当前事务(如果存在)
     */
    NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),

    /**
     * 以非事务方式执行, 如果存在则抛出异常
     */
    NEVER(TransactionDefinition.PROPAGATION_NEVER),

    /**
     * 如果当前事务存在, 则在嵌套事务中执行.
     * 如果事务不存在, 则等同于 PROPAGATION_REQUIRED
     */
    NESTED(TransactionDefinition.PROPAGATION_NESTED);

    private final int value;

    Propagation(int value) { this.value = value; }

    public int value() { return this.value; }

}

2.列表

Propagation	含义
REQUIRED	支持当前事务, 如果不存在, 则创建一个新事务
SUPPORTS	支持当前事务, 如果不存在, 则以非事务方式执行
MANDATORY	支持当前事务, 如果不存在则抛出异常
REQUIRES_NEW	开始一个新的事务, 并暂停当前事务(如果存在)
NOT_SUPPORTED	以非事务方式执行, 暂停当前事务(如果存在)
NEVER	以非事务方式执行, 如果存在则抛出异常
NESTED	如果当前事务存在, 则在嵌套事务中执行. 如果事务不存在, 则等同于 PROPAGATION_REQUIRED

隔离级别介绍

1.枚举介绍

package org.springframework.transaction.annotation;

import org.springframework.transaction.TransactionDefinition;

public enum Isolation {

    /**
     * 使用底层数据存储默认的隔离级别
     * 一般存储底层默认为: READ_COMMITTED
     */
    DEFAULT(TransactionDefinition.ISOLATION_DEFAULT),

    /**
     * 读未提交
     * 会出现脏读和不可重复读, 一般不使用
     */
    READ_UNCOMMITTED(TransactionDefinition.ISOLATION_READ_UNCOMMITTED),

    /**
     * 读已提交
     * 该级别仅禁止事务读取其中未提交更改的行
     * 可能会出现不可重复读取和幻像读取
     */
    READ_COMMITTED(TransactionDefinition.ISOLATION_READ_COMMITTED),

    /**
     * 可重复读
     * 禁止事务读取其中有未提交更改的行, 并且还禁止一个事务读取一行, 第二个事务更改该行. 并且第一个事务重新读取该行, 第二次获取不同值的情况
     * 即 禁止 读未提交, 不可重复读
     * 会出现幻读
     */
    REPEATABLE_READ(TransactionDefinition.ISOLATION_REPEATABLE_READ),

    /**
     * 串行
     * 所有事物依次执行, 不会影响别的事务, 所以会防止 不可重复读 脏读 幻读
     * 会影响性能
     */
    SERIALIZABLE(TransactionDefinition.ISOLATION_SERIALIZABLE);

    private final int value;

    Isolation(int value) { this.value = value; }

    public int value() { return this.value; }

}

2.列表

Isolation	含义
DEFAULT	使用底层数据存储默认的隔离级别, 一般存储底层默认为: READ_COMMITTED
READ_UNCOMMITTED	读未提交, 会出现脏读和不可重复读, 一般不使用
READ_COMMITTED	该级别仅禁止事务读取其中未提交更改的行. 可能会出现不可重复读取和幻像读取
REPEATABLE_READ	可重复读, 禁止事务读取其中有未提交更改的行, 并且还禁止一个事务读取一行, 第二个事务更改该行. 并且第一个事务重新读取该行, 第二次获取不同值的情况. 即禁止读未提交, 不可重复读. 会出现幻读
SERIALIZABLE	串行, 所有事物依次执行, 不会影响别的事务, 所以会防止不可重复读脏读幻读. 会影响性能

3.脏读幻读不可重复读


脏读	当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。
幻读	事务读取时不存在该数据, 读取后发现该数据存在. 中间因为别的事务在进行插入操作
不可重复读	一个事务在读取该数据时另一个事务在修改该数据, 导致多次读取数据内容不一致