spring的事务

事务简介

事务管理是企业级应用程序开发中必不可少的技术, 用来确保数据的完整性和一致性.
事务就是一系列的动作, 它们被当做一个单独的工作单元. 这些动作要么全部完成, 要么全部不起作用
事务的四个关键属性(ACID)
原子性(atomicity): 事务是一个原子操作, 由一系列动作组成. 事务的原子性确保动作要么全部完成要么完全不起作用.
一致性(consistency): 一旦一个事务结束了(不管成功与否)，系统所处的状态和它的业务规则是一致的。即数据应当不会被破坏。
一旦数据被约束成某种 类型或者某些值 那么就必须对应满足这些类型或者某些值
隔离性(isolation): 指多个事务同时操作同一数据时，每个事务都有各自的完整数据空间。( 未提交的数据 在其他的客户端中是无法看到因为 因为隔离性)
持久性(durability): 一旦事务完成, 无论发生什么系统错误, 它的结果都不应该受到影响. 一旦事务完成，事务的结果应该持久化

Spring 中的事务管理

Spring 既支持编程式事务管理, 也支持声明式的事务管理.
编程式事务管理: 将事务管理代码嵌入到业务方法中来控制事务的提交和回滚.
例子：

/** * 编程式事务 */public class TestCotainer {    static DataSource dataSource;    static Connection con;    static{//创建容器对象ApplicationContext context=new ClassPathXmlApplicationContext("classpath:/com/et/lession04/jdbc/spring.xml");    dataSource=(DataSource)context.getBean("dataSource");    }    public static void main(String[] args) throws SQLException {        try {            //前置通知             con=dataSource.getConnection();             //设置为手动提交             con.setAutoCommit(false);             //业务逻辑             //jdbc默认自动提交             aminus(10);             int i=5/0;             badd(10);             //后置通知             con.commit();        } catch (Exception e) {            con.rollback();            e.printStackTrace();        }finally{            con.close();        }    }    /**     * 扣钱     * @param money     * @throws SQLException     */     public static void aminus(int money) throws SQLException{         String sql="update mymoney set lostedmoney=lostedmoney-"+money+" where username='A'";         con.prepareStatement(sql).executeUpdate();     }    /**     * 加钱     * @param money     * @throws SQLException     */     public static void badd(int money) throws SQLException{         String sql="update mymoney set lostedmoney=lostedmoney+"+money+" where username='A'";         con.prepareStatement(sql).executeUpdate();     }}

spring.xml<!-- 获取数据库连接 --> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" >    <property name="url" value="${url}"></property>    <property name="username" value="${username1}"></property>    <property name="password" value="${password2}"></property>    <property name="driverClassName" value="${driverClass}"></property> </bean>

声明式事务管理: 大多数情况下比编程式事务管理更好用. 它将事务管理代码从业务方法中分离出来, 以声明的方式来实现事务管理.
声明式事务{
1.xml声明（全局）
2.注解声明

Spring 中的事务管理器的不同实现

:在应用程序中只需要处理一个数据源, 而且通过 JDBC 存取
: 在 JavaEE 应用服务器上用 JTA(Java Transaction API) 进行事务管理
: 用 Hibernate 框架存取数据库事务管理器以普通的 Bean 形式声明在 Spring IOC 容器中

用事务通知声明式地管理事务

声明式事务管理, 可以通过 tx Schema 中定义的 元素声明事务通知, 为此必须事先将这个 Schema 定义添加到 根元素中去.
定义通知必须引用tx标签同时引用aop标签：

xmlns:tx="http://www.springframework.org/schema/tx"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="    http://www.springframework.org/schema/tx    http://www.springframework.org/schema/tx/spring-tx-4.2.xsd    http://www.springframework.org/schema/aop    http://www.springframework.org/schema/aop/spring-aop-4.2.xsd    ">

Schema 中定义的 元素声明事务通知, 为此必须事先将这个 Schema 定义添加到 根元素中去.
声明了事务通知后, 就需要将它与切入点关联起来. 由于事务通知是在 元素外部声明的, 所以它无法直接与切入点产生关联. 所以必须在 元素中声明一个增强器通知与切入点关联起来.

spring.xml<!-- 扫描 --> <context:component-scan base-package="com.et.lession04"></context:component-scan> <context:property-placeholder location="classpath:/com/et/lession04/jdbc/mysql.properties"/> <!-- 获取数据库连接 --> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" >    <property name="url" value="${url}"></property>    <property name="username" value="${username1}"></property>    <property name="password" value="${password2}"></property>    <property name="driverClassName" value="${driverClass}"></property> </bean> <!-- 事务管理器 不再使用jdbc的commit和roolback 必须使用事务管理器提供 --><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  <property name="dataSource" ref="dataSource"></property></bean> <!-- 定义通知 通知的代码spring已经实现      transaction-manager="transactionManager" 关联上面的事务管理器 --> <tx:advice id="myAdvisor" transaction-manager="transactionManager">    <tx:attributes>        <tx:method name="update*"/>        <tx:method name="save*"/>        <tx:method name="delete*"/>        <!-- 除了以上三种方法以外的所有 -->        <tx:method name="*" read-only="true"/>    </tx:attributes> </tx:advice> <!-- 定义切点 --> <aop:config>    <aop:pointcut expression="execution(* com.*..*.dao.*.*(..))" id="myPopint"/>     <!-- advice-ref="引入通知"myAdvisor         pointcut-ref="引入切点"myPopint      -->    <aop:advisor advice-ref="myAdvisor" pointcut-ref="myPopint"/> </aop:config> <!-- 封装一些操作的方法 增删改查--> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <!-- 注入数据源 -->     <property name="dataSource" ref="dataSource"></property> </bean>

接口public interface MyMoneyDao {    void updateAminus(int money) throws SQLException;    /**     * 加钱     * @param money     * @throws SQLException     */    void updateBbadd(int money) throws SQLException;}

实现接口的类import java.sql.SQLException;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.stereotype.Repository;import com.et.lession04.jdbc.dao.MyMoneyDao;@Repositorypublic class MyMoneyDaoImpl implements MyMoneyDao {    /**     * 扣钱     */    @Autowired    JdbcTemplate jdbc;    public  void updateAminus(int money) throws SQLException{         String sql="update mymoney set lostedmoney=lostedmoney-"+money+" where username='A'";         jdbc.execute(sql);     }    /**     * 加钱     */     public void updateBbadd(int money) throws SQLException{         String sql="update mymoney set lostedmoney=lostedmoney+"+money+" where username='B'";         jdbc.execute(sql);     }}

测试类 public class Test {    static MyMoneyDao myMoneyDao;    static{    //创建容器对象    ApplicationContext context=new ClassPathXmlApplicationContext("classpath:/com/et/lession04/jdbc/spring.xml");        myMoneyDao=(MyMoneyDao)context.getBean("myMoneyDaoImpl");    }    public static void main(String[] args) throws SQLException {        myMoneyDao.updateAminus(10);        int i=5/0;        myMoneyDao.updateBbadd(10);    }}

事务传播属性

当事务方法被另一个事务方法调用时, 必须指定事务应该如何传播. 例如: 方法可能继续在现有事务中运行, 也可能开启一个新事务, 并在自己的事务中运行.
事务的传播行为可以由传播属性指定. Spring 定义了 7 种类传播行为.

 propagation="REQUIRED"默认的传播特性，方法和方法之间式父子关系         REQUIRED:没有事务就创建事务，有就使用当前事务         REQUIRES_NEW：不管父方法是否存在事务，都会新建事务         SUPPORTS: 父方法存在事务使用当前事务，没有事务就使用jdbc的事务（自动提交）         NOT_SUPPORTED: 不管父方法是否存在事务都不会使用事务（挂起事务）         MANDATORY: 必须在事务环境下运行 父方法没有事务会抛出异常            No existing transaction found for transaction marked with propagation 'mandatory'         NEVER: 父方法不能存在事务，有事务就抛出异常            Existing transaction found for transaction marked with propagation 'never'NESTED: 如果有事务在运行，当前的方法就应该在这个事务的嵌套事务内运行，否则就启动一个新的事务，并在它自己的事务内运行。

事务通知中, 可以像下面这样在 元素中设定传播事务属性：

<!-- 定义通知 --><tx:advice id="myAdvisor" transaction-manager="transactionManager">    <tx:attributes>        <tx:method name="update*" propagation="REQUIRED"/>        <tx:method name="save*" propagation="NEVER"/>        <tx:method name="delete*"/>        <!-- 除了以上三种方法以外的所有 -->        <tx:method name="*" read-only="true"/>    </tx:attributes> </tx:advice>

@Repositorypublic class AdaoImpl {    @Autowired    JdbcTemplate jdbc;    @Autowired    BdaoImpl b;    /**     * 扣钱     * @param money     * @throws SQLException     */    public  void updateAminus(int money) throws SQLException{        //扣钱         String sql="update mymoney set lostedmoney=lostedmoney-"+money+" where id=1";         jdbc.execute(sql);         //加钱         b.saveBadd(money);         int i=5/0;     }}

@Repositorypublic class BdaoImpl {    @Autowired    JdbcTemplate jdbc;    /**     * 扣钱     * @param money     * @throws SQLException     */    public  void saveBadd(int money) throws SQLException{         String sql="update mymoney set lostedmoney=lostedmoney+"+money+" where id=2";         jdbc.execute(sql);     }}

public class Test {    static AdaoImpl Dao;    static{        //创建容器对象        ApplicationContext context=new ClassPathXmlApplicationContext("classpath:/com/et/lession04/testm/spring.xml");        Dao=(AdaoImpl)context.getBean("adaoImpl");    }    public static void main(String[] args) throws SQLException {        Dao.updateAminus(10);       }}

并发事务所导致的问题

并发事务所导致的问题可以分为下面三种类型:

脏读: 对于两个事务 T1,T2,T1读取了已经被T2 更新但 还没有被提交的字段.之后,若T2回滚,T1读取的内容就是临时且无效的.不可重复读:对于两个事务T1,T2,T1读取了一个字段,然后T2更新了该字段.之后,T1再次读取同一个字段,值就不同了.幻读:对于两个事务 T1,T2,T1从一个表中读取了一个字段,然后T2在该表中插入了一些新的行.之后,如果T1再次读取同一个表,就会多出几行.

事务的隔离级别

事务应该彼此完全隔离, 以避免并发事务所导致的问题. 然而, 那样会对性能产生极大的影响, 因为事务必须按顺序运行.
在实际开发中, 为了提升性能, 事务会以较低的隔离级别运行.
事务的隔离级别可以通过隔离事务属性指定

Spring 支持的事务隔离级别

spring中默认的隔离级别:isolation="DEFAULT"DEFAULT:数据库本身的隔离级别  oracle（读已提交） mysql（可重复读）READ_UNCOMMITTED：spring实现读未提交(产生脏读)READ_COMMITTED：spring实现读已提交 可以避免脏读（但不可重复读和幻读的问题任然可能出现）REPEATABLE_READ：spring实现可重复读 可以避免脏读和不可重复读（但可能产生幻读）SERIALIZABLE：spring实现串行化（所有并发问题都可以避免，但性能十分低）效率极低 

事务的隔离级别要得到底层数据库引擎的支持, 而不是应用程序或者框架的支持.
Oracle 支持的 2 种事务隔离级别：READ_COMMITED , SERIALIZABLE
Mysql 支持 4 中事务隔离级别.

设置隔离事务属性

在 Spring.xml 事务通知中, 可以在 元素中指定隔离级别

<tx:advice id="myAdvisor" transaction-manager="transactionManager">    <tx:attributes>    <!--  spring中默认的隔离级别:isolation="DEFAULT" -->        <tx:method name="update*" propagation="REQUIRED" isolation="DEFAULT"/>        <tx:method name="save*" propagation="REQUIRED"/>        <tx:method name="delete*"/>        <!-- 除了以上三种方法以外的所有 -->        <tx:method name="*" read-only="true"/>    </tx:attributes> </tx:advice>

设置回滚事务属性

 spring事务 运行过程中碰到运行时异常 （自动回滚） 非运行时异常（不会回滚）  rollback-for="java.io.FileNotFoundException" 指定会回滚的非运行时异常 no-rollback-for="java.lang.RuntimeException" 指定某些运行时异常抛出时 不会回滚

设置回滚事务属性：
在 Spring.xml 事务通知中, 可以在 元素中指定回滚规则. 如果有不止一种异常, 用逗号分隔.

<tx:advice id="myAdvisor" transaction-manager="transactionManager">    <tx:attributes>    <!--  spring中事务的回滚 -->        <tx:method name="update*"         propagation="REQUIRED"        no-rollback-for="java.lang.RuntimeException"        rollback-for="java.io.FileNotFoundException"        />        <tx:method name="save*" propagation="REQUIRED"/>        <tx:method name="delete*"/>        <!-- 除了以上三种方法以外的所有 -->        <tx:method name="*" read-only="true"/>    </tx:attributes> </tx:advice>

超时和只读属性

超时事务属性: 事务在强制回滚之前可以保持多久. 这样可以防止长期运行的事务占用资源.
只读事务属性: 表示这个事务只读取数据但不更新数据, 这样可以帮助数据库引擎优化事务.

在 Spring.xml 事务通知中, 超时和只读属性可以在 元素中进行指定.
spring的超时事务 timeout=”10” mysql默认10秒自动超时 oracle永不超时

<tx:advice id="myAdvisor" transaction-manager="transactionManager">    <tx:attributes>    <!--  spring中事务的回滚 -->        <tx:method name="update*"         propagation="REQUIRED"        no-rollback-for="java.lang.RuntimeException"        rollback-for="java.io.FileNotFoundException"        timeout="10"         />        <tx:method name="save*" propagation="REQUIRED"/>        <tx:method name="delete*"/>        <!-- 设置只读事务read-only="true" -->        <tx:method name="*" read-only="true"/>    </tx:attributes> </tx:advice>

“`