spring的事务

最新推荐文章于 2024-02-19 17:57:45 发布

hyp1204

最新推荐文章于 2024-02-19 17:57:45 发布

阅读量237

点赞数

分类专栏： spring事务

本文链接：https://blog.csdn.net/huoyunp/article/details/78466332

版权

spring事务专栏收录该内容

1 篇文章 0 订阅

订阅专栏

事务简介

事务管理是企业级应用程序开发中必不可少的技术, 用来确保数据的完整性和一致性.
事务就是一系列的动作, 它们被当做一个单独的工作单元. 这些动作要么全部完成, 要么全部不起作用
事务的四个关键属性(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;
@Repository
public 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>

@Repository
public 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;
     }
}


@Repository
public 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>

“`