需求：从ID为10086账户给ID为10010账户转账1000元钱。

数据准备：account表（账户）：

————————-

ID        BALANCE

————————-

10010       0

10086    1000

设计一个 Account表

CREATE TABLE `t_account` (

  `id` int(11) NOT NULL AUTO_INCREMENT,

  `balance` int(11) DEFAULT NULL,

  PRIMARY KEY (`id`)

) ENGINE=InnoDB AUTO_INCREMENT=10087 DEFAULT CHARSET=utf8;

编写转账案例

隔离级别

说明

READ_UNCOMMITED

允许你读取还未提交的改变了的数据。可能导致脏、幻、不可重复读（相当于没有做任何事务隔离）

READ_COMMITTED

允许在并发事务已经提交后读取。可防止脏读，但幻读和 不可重复读仍可发生（ORACLE默认级别）

REPEATABLE_READ

对相同字段的多次读取是一致的，除非数据被事务本身改变。可防止脏、不可重复读，但幻读仍可能发生。（MYSQL默认级别）

SERIALIZABLE

完全服从ACID的隔离级别，确保不发生脏、幻、不可重复读。这在所有的隔离级别中是最慢的，它是典型的通过完全锁定在事务中涉及的数据表来完成的。（ORACLE支持）

Spring事务处理接口

描述

TransactionDefinition

封装事务的隔离级别超时时间，是否为只读事务和事务的隔离级别和传播规则等事务属性，可通过XML配置具体信息

PlatformTransactionManager

根据TransactionDefinition提供的事务属性配置信息，创建事务。事物管理器

TransactionStatus

封装了事务的具体运行状态。比如，是否是新开启事务，是否已经提交事务，设置当前事务为rollback-only等

public interface TransactionDefinition {

     //事务的传播行为

int PROPAGATION_REQUIRED = 0;

int PROPAGATION_SUPPORTS = 1;

int PROPAGATION_MANDATORY = 2;

int PROPAGATION_REQUIRES_NEW = 3;

int PROPAGATION_NOT_SUPPORTED = 4;

int PROPAGATION_NEVER = 5;

int PROPAGATION_NESTED = 6;

    //事务的隔离级别

int ISOLATION_DEFAULT = -1;

int ISOLATION_READ_UNCOMMITTED = Connection.TRANSACTION_READ_UNCOMMITTED;

int ISOLATION_READ_COMMITTED = Connection.TRANSACTION_READ_COMMITTED;

int ISOLATION_REPEATABLE_READ = Connection.TRANSACTION_REPEATABLE_READ;

int ISOLATION_SERIALIZABLE = Connection.TRANSACTION_SERIALIZABLE;

    //事务超时管理

int TIMEOUT_DEFAULT = -1;

//获得事务信息

int getPropagationBehavior();

int getIsolationLevel();

int getTimeout();

boolean isReadOnly();

String getName();

}

事务传播规则类型

描述

PROPAGATION_REQUIRED

如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务(最常用操作)-Spring默认使用的就是此规则

PROPAGATION_REQUIRES_NEW

创建一个新的事务，如果当前存在事务，则把当前事务挂起

PROPAGATION_SUPPORTS

如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行

PROPAGATION_NOT_SUPPORTED

以非事务方式运行，如果当前存在事务，则把当前事务挂起

PROPAGATION_NEVER

以非事务方式运行，如果当前存在事务，则抛出异常

PROPAGATION_MANDATORY

如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常

PROPAGATION_NESTED

如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED

<beans xmlns=“http://www.springframework.org/schema/beans”

xmlns:p=“http://www.springframework.org/schema/p”

xmlns:context=“http://www.springframework.org/schema/context”

xmlns:aop=“http://www.springframework.org/schema/aop”

xmlns:tx=“http://www.springframework.org/schema/tx”

xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”

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

    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

    “>

<!– 1，配置事务管理器（应根据情况使用合适的事务管理器） –>

<bean id=“txManager” class=“org.springframework.jdbc.datasource.DataSourceTransactionManager”>

<!– 注入dataSource –>

<property name=“dataSource” ref=“dataSource”/>

</bean>

<!–

1、切入点（Pointcut）：在哪些类，哪些方法上切入（where）；

2、增强（Advice）：早期翻译为通知，在方法执行的什么时机（when：方法前/方法后/方法前后）做什么（what：增强的功能）；

3、切面（Aspect）：切面=切入点+通知，通俗点就是：什么时机，什么地点，做什么！

4、织入（Weaving）：把切面加入到对象，并创建出代理对象的过程。（该过程由Spring来完成）。

 WWW 原则 :

 where : 在什么地方切事务

 what : 干什么(切事务)

 when : 时机(在方法前或者后)

 –>

<!– 事务相关的配置 : 使用AOP面向切面编程(切事务) : 使用 tx: 标签  –>

<!– tx:advice : 配置事物的标签

id : 唯一标识

transaction-manager : 需要用到的事物管理器

 –>

<!– 2，配置管理事务的“增强” :环绕通知–>

<tx:advice id=“txAdvice” transaction-manager=“txManager”>

<tx:attributes>

<!– 配置要切的方法 : trans (默认使用的是环绕通知) –>

<tx:method name=“trans”/>

</tx:attributes>

</tx:advice>

<!– 3,面向切面 :  –>

<aop:config >

<!– 切入点 : where –>

<aop:pointcut expression=“execution ( * cn.zj.spring.service..*.*(..))” id=“pt”/>

<!– 配置切面  切面 = 切入点 + 通知

advice-ref 通知的引用

pointcut–ref 切入点的引入

 –>

<aop:advisor  advice-ref=“txAdvice”  pointcut-ref=“pt” />

<!– 织入（Weaving）：把切面加入到对象，并创建出代理对象的过程。（该过程由Spring来完成） –>

</aop:config>

事务方法属性

描述

name

匹配到的方法模式

read-only

如果为true，开启一个只读事务，只读事务的性能较高，但是不能再只读事务中，使用DML

isolation

代表数据库事务隔离级别(就使用默认)

DEFAULT:让spring使用数据库默认的事务隔离级别;

no-rollback-for

如果遇到的异常是匹配的异常类型,就不回滚事务

rollback-for

如果遇到的异常是指定匹配的异常类型,才回滚事务;spring默认情况下,spring只会去回滚RuntimeException及其子类,不会回滚Exception和Thowable

propagation

事务的传播方式(当一个方法已经在一个开启的事务当中了，应该怎么处理自身的事务)

  1,REQUIRED（默认的传播属性）:如果当前方法运行在一个没有事务环境的情况下，则开启一个新的事务，如果当前方法运行在一个已经开启了的事务里面，把自己加入到开启的那个事务中

  2,REQUIRES_NEW:不管当前方法是否运行在一个事务空间之内，都要开启自己的事务

timeout

事务处理的超时时间,默认事物管理自动处理 ,可以手动配置

<tx:advice id=“txAdvice” transaction-manager=“txManager”>

<tx:attributes>

<!– <tx:method>

name : 需要切面的方法

isolation : 事务的隔离级别 DEFAULT 使用当前数据库默认的隔离级别,不同数据库隔离级别不同(可以不配置)

propagation : 事物的传播规则 ,默认使用 REQUIRED

read-only : 是否是只读事务, DQL配置即可

 –>

<!– 一般DML操作才需要事务,DQL查询操作是不需要事物

* 通配符

 –>

<!– 所有以前缀开都的方法都认为是 查询方法,就不切入事物 –>

<tx:method name=“get*” read-only=“true”/>

<tx:method name=“select*”  read-only=“true” />

<tx:method name=“find*”  read-only=“true”/>

<tx:method name=“query*”  read-only=“true”/>

<tx:method name=“list*”  read-only=“true”/>

<!– 非查询(DQL)方法: DML操作,需要事务管理 –>

<tx:method name=“*” />

</tx:attributes>

</tx:advice>

<!– 1，配置事务管理器（应根据情况使用合适的事务管理器） –>

<bean id=“txManager” class=“org.springframework.jdbc.datasource.DataSourceTransactionManager”>

<!– 注入dataSource –>

<property name=“dataSource” ref=“dataSource”/>

</bean>

<!– 开启注解驱动配置事务

编写此标签:Spring底层就支持注解配置事物,并且已经配置好事物管理器

 –>

<tx:annotation-driven transaction-manager=“txManager”/>

@Service

/* @Transactional

 * 贴上此当前类已经被Spring事务管理

 * 注意： @Transactional 只能对当前贴的Service类有效

 *  常用属性 ：

 *   isolation=Isolation.REPEATABLE_READ,  隔离级别

propagation=Propagation.REQUIRED,传播规则

readOnly=true 是否只读事务

 *  

 */@Transactional(isolation=Isolation.DEFAULT,propagation=Propagation.REQUIRED)

public class AccountServiceImpl implements AccountService{

@Autowired

private AccountDao dao;

public void trans(Integer transOutId,

Integer transInId, Integer money) {

dao.tranOut(transOutId, money);

System.out.println(1 / 0);// 模拟断电

dao.tranIn(transInId, money);

}

//单独为某一个方法配置具体的事物细节:如查询方法,事物是只读的

@Transactional(readOnly=true)

public Object getUser() {

//查询操作

return null;

}

@Transactional(readOnly=true)

public List<Object> getUsers() {

//查询操作

return null;

}

}