Spring事务详解

程序员文章站 2022-05-09 15:58:27

...

事务简介

事务管理是企业级应用程序开发中比不可少的技术，用来确保数据的完整性和一致性。

事务就是一系列的动作，它们将当做一个单独的工作单元，这些动作要么全部完成，要么全部不起作用。

事务的四个关键属性(ACID)

原子性(atomicity)：事务是一个原子操作，由一系列动作组成，事务的原子性确保动作要么全部完成要么完全不起作用。

一致性(consistency)：一旦所有事务动作完成，事务就被提交，数据和资源就处于一种满足业务规则的一致性状态中。

隔离性(isolation)：可能有许多事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。

持久性(durability)：一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响，通常情况下，事务的结果被写到持久化存储器中。

Spring中的事务管理

作为企业级应用程序框架，Spring在不同的事务管理API之上定义了一个抽象层，而应用程序开发人员不必了解底层的事务管理API，就可以使用Spring的事务管理机制。

Spring即支持编程式事务管理，也支持声明式的事务管理。

编程式事务管理：将事务管理代码嵌入到业务方法中来控制事务的提交和回滚。在编程式管理事务时，必须在每个事务操作中包含额外的事务管理代码。

声明式事务管理：大多数情况下比编程式事务管理更好用，它将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理，事务管理作为一个横切关注点，可以通过AOP方法模块化，Spring通过Spring AOP框架支持声明式事务管理。

Spring中的事务管理器

Spring从不同的事务管理API中抽象了一整套的事务机制，开发人员不必了解底层的事务 API，就可以利用这些事务机制。有了这些事务机制，事务管理代码就能独立于特定的事务技术了。

Spring的核心事务管理抽象是PlatformTransactionManager接口，管理封装了一组独立于技术的方法，无论使用Spring的哪种事务管理策略(编程式或声明式)，事务管理器都是必须的。

PlatformTransactionManager接口封装了三个方法

如：

//获取当前事务的状态
TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
//提交事物
void commit(TransactionStatus status) throws TransactionException;
//回滚事务
void rollback(TransactionStatus status) throws TransactionException;

也就是说想在spring这个平台上使用声明式事务必须提供一个PlatformTransactionManager的子类

我们使用ctrl+t查看一下该接口的子类

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

DataSourceTransactionManager类：在应用程序中只需要处理一个数据源，而且通过JDBC存取

JtaTransactionManager类：在JavaEE应用服务器上用JTA(Java Transaction API)进行事务管理

HibernateTransactionManager类：用Hibernate框架存取数据库

事务管理器以普通的Bean形式声明在SpringIOC容器中

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

事务管理是一种横切关注点

为了在Spring2.x中启用声明式事务管理，可以通过tx Schema中定义<tx:advice>元素声明事务通知，为此必须事先将这个Schema定义添加到<beans>根元素中去。

声明了事务通知后，就需要将它与切入点关联起来，由于事务通知是在<aop:config>元素外部声明的，所以它无法直接与切入点产生关联，必须在<aop:config>元素中声明一个增强器通知与切入点关联起来。

由于Spring AOP是基于代理的方法，所以只能增强公共方法，因此，只有公有方法才能通过SpringAOP进行事务管理。

例：我们要使用到JDBC所以我们这里使用DataSourceTransactionManager来配置事务

 <!-- 
    事务管理器 
    	不再使用jdbc的commit和rollback 必须使用事务管理器提供
 -->
<bean id="transactionMager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<!-- 注入数据源 -->
	<property name="dataSource" ref="dataSource"></property>
</bean>

<!--定义通知  
  	并且关联上事务管理器 需要事务管理器来提交和回滚 如果事务管理器id="transactionManager"下面的transaction-manager可以不写，它会自动关联上事务管理器
  通知作用：当切点定位到下面的方法，它就会自动在前置通知里面加个连接，并且改成手动提交事物，在完成操作之后，提交事物，有异常便自动回滚
  	    可参考下图
-->
<tx:advice id="myAdvise" transaction-manager="transactionManager">
  <!-- 指定拦截方法 -->
  <tx:attributes>
  	<tx:method name="update*"/>
  	<tx:method name="save*"/>
  	<tx:method name="delete*"/>
  	<!-- read-only="true"只读    不开启事务-->
  	<tx:method name="*" read-only="true"/>
  </tx:attributes>
</tx:advice>

<!-- 
  定义切点  切点一般都是操作service层，这里因为是测试所有操作dao层
-->
<aop:config>
  <!-- execution(* cn.*..*.dao.*.upadte*(..)) 定位切点位置：通过execution()指定切点的位置  -->
  <aop:pointcut expression="execution(* cn.*..*.dao.*.*(..))" id="myPoint"/>
  <!-- 
  	通过advice-ref=""将切点与通知关联起来  一拦截到dao方法里的方法便通知myAdvise调事务管理器(transactionManager)开启事务 
  -->
  <aop:advisor advice-ref="myAdvise" pointcut-ref="myPoint"/>
</aop:config>

创建一个java类(dao层)

package cn.et.dao.Impl;

import java.sql.SQLException;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import cn.et.dao.MyMoneyDao;

/**
 * 命名规范
 * 	增加：save*
 * 	修改：update*
 * 	删除：delete*
 * @author Administrator
 */
@Repository
public class MyMoneyDaoImpl implements MyMoneyDao{
	@Autowired
	JdbcTemplate jdbc;
	public void updateAminus(int money) throws SQLException {//A-10
		String sql = "update users set lostedmoney= lostedmoney-"+money+" where userName='A'";
		jdbc.execute(sql);
	}
	
	public void updateBadd(int money) throws SQLException {//B+10
		String sql = "update users set lostedmoney= lostedmoney+"+money+" where userName='B'";
		jdbc.execute(sql);
	}
}

由于拦截的是save*、update*、delete*开头的方法，所以上面的两个方法都将被拦截下来

在调用这两个方法之前开启一个事务，当它执行完就提交事务(自动提交)，如果出错便回滚事务。

现在运行测试还是会报错，我们还需要配置扫描、指定四要素、数据源、数据库连接

<!-- 指定扫描的位置 -->
<context:component-scan base-package="cn.et"></context:component-scan>
  
<!-- 指定四要素的位置 -->
<context:property-placeholder location="classpath:jdbc.properties" />  
<!-- 数据源只是为了获取连接 -->  
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">  
     <property name="url" value="${url}"></property>  
     <property name="driverClassName" value="${driverClass}"></property>  
     <property name="username" value="${userid}"></property>  
     <property name="password" value="${password}"></property>  
</bean>   
<!-- 数据库连接 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
	<!-- 注入数据源 -->
	<property name="dataSource" ref="dataSource"></property>
</bean>

写个main方法

package cn.et;

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;

import cn.et.dao.MyMoneyDao;

public class Test {
	static ConfigurableApplicationContext context;
	static MyMoneyDao dao;
	static{
		context = new GenericXmlApplicationContext("classpath:spring.xml");
		dao = (MyMoneyDao) context.getBean("myMoneyDaoImpl");
	}
	public static void main(String[] args) throws Exception {
		dao.updateAminus(10);
		dao.updateBadd(10);
		context.close();
	}
}

查看数据库

运行main方法再次查看数据库

Spring事务详解

我们弄个错误试一下(按照我们的逻辑，当它报错了，A和B一起回滚)

Spring事务详解

再次运行后我们发现A减了10，B却没有变，说明它们两不在同一次事务中
Spring事务详解
我们需要将它们置于同一个事务中，如何做呢？需要使用到事务传播属性

事务传播属性

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播，例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。

事务的传播行为可以由传播属性指定，Spring定义了7种类传播行为。

Spring支持的事务传播行为

Spring事务详解

REQUIRE：没有事务创建一个事务，有事务使用当前事务

REQUIRE_NEW：不管父方法是否存在事务，都会新建事务

SUPPORTS：父方法存在事务，使用当前事务，没有事务，使用jdbc的事务(自动提交)

NOT_SUPPORTS：不管父方法是否存在事务，都会不会使用事务(挂起事务)

MANDATORY：必须在事务环境下运行，父方法没有事务，抛出异常

No existing transaction found for transaction marked with propagation 'mandatory'

EEVER：父方法不能存在事务，有事务抛出异常

Existing transaction found for transaction marked with propagation 'never'

只需在<tx:method>元素里设置 propagation="REQUIRED"即可

Spring事务详解

下面发布完整的代码

spring.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: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"
	xsi:schemaLocation="
	http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
	">
  <!-- 指定扫描的位置 -->
  <context:component-scan base-package="cn.et.test"></context:component-scan>
  
  	<!-- 指定四要素的位置 -->
    <context:property-placeholder location="classpath:jdbc.properties" />  
 	<!-- 数据源只是为了获取连接 -->  
	 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">  
        <property name="url" value="${url}"></property>  
        <property name="driverClassName" value="${driverClass}"></property>  
        <property name="username" value="${userid}"></property>  
        <property name="password" value="${password}"></property>  
    </bean>   
    <!-- 数据库连接 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<!-- 注入数据源 -->
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
    <!-- 
    	事务管理器 
    		不再使用jdbc的commit和rollback 必须使用事务管理器提供
    -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 注入数据源 -->
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
  	<!-- 
  		定义通知  
  			并且关联上事务管理器 需要事务管理器来提交和回滚 如果事务管理器id="transactionManager"下面的transaction-manager可以不写，它会自动关联上事务管理器
  		通知作用：当切点定位到下面的方法，它就会自动在前置通知里面加个连接，并且改成手动提交事物
  				在完成操作之后，提交事物，有异常便自动回滚
  				可参考下图
  	-->
  	<tx:advice id="myAdvise" transaction-manager="transactionManager">
  		<!-- 指定拦截方法 -->
  		<tx:attributes>
  			<tx:method name="update*" propagation="REQUIRED"/>
  			<tx:method name="save*"/>
  			<tx:method name="delete*"/>
  			<!-- read-only="true"只读    不开启事务-->
  			<tx:method name="*" read-only="true"/>
  		</tx:attributes>
  	</tx:advice>
  	<!-- 
  		定义切点 
  	-->
  	<aop:config>
  		<!-- execution(* cn.*..*.dao.*.upadte*(..)) -->
  		<aop:pointcut expression="execution(* cn.*..*.service.*.*(..))" id="myPoint"/>
  		<!-- 
  			将切点与通知关联起来  一拦截到dao方法里的方法便通知myAdvise调事务管理器(transactionMager)开启事务 
  		-->
  		<aop:advisor advice-ref="myAdvise" pointcut-ref="myPoint"/>
  	</aop:config>
</beans>

持久层代码

package cn.et.test.dao;

import java.sql.SQLException;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;


@Repository
public class AbdaoImpl{
	@Autowired
	JdbcTemplate jdbc;

	public void updateBadd(int money) throws SQLException {
		String sql = "update users set lostedmoney= lostedmoney+"+money+" where userName='B'";
		jdbc.execute(sql);
	}
	public void updateAminus(int money) throws SQLException {
		String sql = "update users set lostedmoney= lostedmoney-"+money+" where userName='A'";
		jdbc.execute(sql);
	}
}

业务层代码

package cn.et.test.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import cn.et.test.dao.AbdaoImpl;

@Service
public class AbServiceImpl {
	@Autowired
	AbdaoImpl dao;
	public void updateAB(Integer money) throws Exception{
		dao.updateAminus(money);
		int i=5/0;
		dao.updateBadd(money);
	}
}

main方法

package cn.et.test;

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;

import cn.et.test.service.AbServiceImpl;

public class Test {
	static ConfigurableApplicationContext context;
	static AbServiceImpl service;
	static{
		context = new GenericXmlApplicationContext("classpath:/cn/et/test/spring.xml");
		service = (AbServiceImpl) context.getBean("abServiceImpl");
	}
	public static void main(String[] args) throws Exception {
		service.updateAB(20);
		context.close();
	}
}

测试-查看数据库将A置为100，B置为200

Spring事务详解

运行main方法-出现异常了

Spring事务详解
再次查看数据库-数据AB都没有变，说明事务传播属性设置成功了

Spring事务详解

事务的隔离级别

从理论上来说，事务应该彼此完全隔离，以避免并发事务所导致的问题，然而，那样会对性能产生极大的影响，因此事务必须按顺序运行。

在实际开发中，为了提升性能，事务会以较低的隔离级别运行。

事务的隔离级别可以通过隔离事务属性指定

Spring支持的事务隔离级别

Spring事务详解

事务的隔离级别要得到底层数据库引擎的支持，而不是应用程序或者框架的支持。

Oracle支持2种事务隔离级别：READ_COMMITED,SERIALIZABLE

Mysql支持4种事务隔离级别。

isolation="DEFAULT" 隔离级别

DEFAULT 使用数据库默认的隔离级别 ORACLE(读已提交)，MYSQL(可重复读)。从隔离级别来讲，oracle的效率比mysql高。

Spring事务详解

READ_UNCOMMITTED：spring实现读未提交(脏读)

READ_COMMITTED：spring实现读已提交(不可重复读+幻读)

REPEATABLE_READ：spring实现可重复读(幻读)

SERIALIZABLE：spring实现串行化(已解决)按顺序执行，一次只有一个事务执行。效率极低。

建议不用配，使用数据库的，只要配置了数据库的隔离级别就可以了

设置隔离事务属性

在spring2.x事务通知中，可以在<tx:method>元素中指定隔离级别

Spring事务详解

设置回滚事务属性

默认情况下只有未检查异常(RuntimeException和Error类型的异常)会导致事务回滚，而受检查异常不会。

事务的回滚规则可以通过在<tx:method>元素中指定回滚规则，如果有不止一种异常，用逗号分隔。

Spring事务运行过程中，碰到运行时异常自动回滚，非运行时异常不会回滚

rollback-for="java.lang.exception"：遇到指定异常必须进行回滚。

no-rollback-for="java.lang.exception"：遇到指定异常，必须不回滚

一般都会设置为rollback-for="java.lang.exception"有异常便回滚。

超时和只读属性

由于事务可以在行和表上获得锁，因此长事务会占用资源，并对整体性能产生影响。

如果一个事务只读取数据但不做修改，数据库引擎可以对这个事务进行优化。

超时事务属性：事务在强制回滚之前可以保持多久，这样可以防止长期运行的事务占用资源。

只读事务属性：表示这个事务只读数据但不更新数据，这样可以帮助数据库引擎优化事务。

设置超时和只读事务属性

超时和只读属性可以在<tx:method>元素中进行指定

Spring事务详解

所需jar包

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>cn.et</groupId>
  <artifactId>Spring_affair</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <dependencies>
  	<!-- spring依赖 -->
  	<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.12.RELEASE</version>
    </dependency>
  	<!-- aop依赖 -->
  	<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.3.11.RELEASE</version>
	</dependency>
	<!-- spring事务依赖 -->
	<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>4.3.11.RELEASE</version>
	</dependency>
	<dependency>
     	<groupId>aopalliance</groupId>
     	<artifactId>aopalliance</artifactId>
     	<version>1.0</version>
	</dependency>
	<dependency>
	     <groupId>aspectj</groupId>
	     <artifactId>aspectjweaver</artifactId>
	     <version>1.5.3</version>
	 </dependency>
	<!-- jdbc依赖 -->
	<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>4.3.12.RELEASE</version>
    </dependency>
    <!-- mysql数据库依赖 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.26</version>
    </dependency>
    <!-- 日志依赖 -->
    <dependency>
    	<groupId>log4j</groupId>
    	<artifactId>log4j</artifactId>
    	<version>1.2.17</version>
    </dependency>
	<dependency>
	     <groupId>aspectj</groupId>
	     <artifactId>aspectjrt</artifactId>
	     <version>1.2</version>
	</dependency>    
  </dependencies>
</project>

Spring事务详解

事务简介

事务的四个关键属性(ACID)

Spring中的事务管理

Spring中的事务管理器

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

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

例：我们要使用到JDBC所以我们这里使用DataSourceTransactionManager来配置事务

事务传播属性

Spring支持的事务传播行为

spring.xml配置文件

持久层代码

业务层代码

main方法

事务的隔离级别

Spring支持的事务隔离级别

设置隔离事务属性

设置回滚事务属性

超时和只读属性

设置超时和只读事务属性

减肥食物热量表详解，想知道就赶快看吧

九、Spring之BeanFactory源码分析(一)

详解iOS开发中app的归档以及偏好设置的存储方式

Android显示全文折叠控件使用方法详解

02Spring基于xml的IOC配置--实例化Bean的三种方式

iOS中的应用启动原理以及嵌套模型开发示例详解

详解iOS中多线程app开发的GCD队列的使用

IOS开发中NSURL的基本操作及用法详解

Spring源码分析之IoC容器初始化

详解iOS开发中UItableview控件的数据刷新功能的实现