事务简介
事务管理是企业级应用程序开发中比不可少的技术,用来确保数据的完整性和一致性。
事务就是一系列的动作,它们将当做一个单独的工作单元,这些动作要么全部完成,要么全部不起作用。
事务的四个关键属性(ACID)
原子性(atomicity):事务是一个原子操作,由一系列动作组成,事务的原子性确保动作要么全部完成要么完全不起作用。
一致性(consistency):一旦所有事务动作完成,事务就被提交,数据和资源就处于一种满足业务规则的一致性状态中。
隔离性(isolation):可能有许多事务会同时处理相同的数据,因此每个事务都应该与其他事务隔离开来,防止数据损坏。
持久性(durability):一旦事务完成,无论发生什么系统错误,它的结果都不应该受到影响,通常情况下,事务的结果被写到持久化存储器中。
Spring中的事务管理
作为企业级应用程序框架,Spring在不同的事务管理API之上定义了一个抽象层,而应用程序开发人员不必了解底层的事务管理API,就可以使用Spring的事务管理机制。
Spring即支持编程式事务管理,也支持声明式的事务管理。
编程式事务管理:将事务管理代码嵌入到业务方法中来控制事务的提交和回滚。在编程式管理事务时,必须在每个事务操作中包含额外的事务管理代码。
声明式事务管理:大多数情况下比编程式事务管理更好用,它将事务管理代码从业务方法中分离出来,以声明的方式来实现事务管理,事务管理作为一个横切关注点,可以通过AOP方法模块化,Spring通过Spring AOP框架支持声明式事务管理。
Spring中的事务管理器
Spring从不同的事务管理API中抽象了一整套的事务机制,开发人员不必了解底层的事务 API,就可以利用这些事务机制。有了这些事务机制,事务管理代码就能独立于特定的事务技术了。
Spring的核心事务管理抽象是PlatformTransactionManager接口,管理封装了一组独立于技术的方法,无论使用Spring的哪种事务管理策略(编程式或声明式),事务管理器都是必须的。
PlatformTransactionManager接口封装了三个方法
如:
1
2
3
4
5
6
7 1//获取当前事务的状态
2TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
3//提交事物
4void commit(TransactionStatus status) throws TransactionException;
5//回滚事务
6void rollback(TransactionStatus status) throws TransactionException;
7
1
2 1 也就是说想在spring这个平台上使用声明式事务必须提供一个
2
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来配置事务
1
2
3
4
5
6
7
8
9 1 <!--
2 事务管理器
3 不再使用jdbc的commit和rollback 必须使用事务管理器提供
4 -->
5<bean id="transactionMager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
6 <!-- 注入数据源 -->
7 <property name="dataSource" ref="dataSource"></property>
8</bean>
9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 1<!--定义通知
2 并且关联上事务管理器 需要事务管理器来提交和回滚 如果事务管理器id="transactionManager"下面的transaction-manager可以不写,它会自动关联上事务管理器
3 通知作用:当切点定位到下面的方法,它就会自动在前置通知里面加个连接,并且改成手动提交事物,在完成操作之后,提交事物,有异常便自动回滚
4 可参考下图
5-->
6<tx:advice id="myAdvise" transaction-manager="transactionManager">
7 <!-- 指定拦截方法 -->
8 <tx:attributes>
9 <tx:method name="update*"/>
10 <tx:method name="save*"/>
11 <tx:method name="delete*"/>
12 <!-- read-only="true"只读 不开启事务-->
13 <tx:method name="*" read-only="true"/>
14 </tx:attributes>
15</tx:advice>
16
1
2
3
4
5
6
7
8
9
10
11
12 1<!--
2 定义切点 切点一般都是操作service层,这里因为是测试所有操作dao层
3-->
4<aop:config>
5 <!-- execution(* cn.*..*.dao.*.upadte*(..)) 定位切点位置:通过execution()指定切点的位置 -->
6 <aop:pointcut expression="execution(* cn.*..*.dao.*.*(..))" id="myPoint"/>
7 <!--
8 通过advice-ref=""将切点与通知关联起来 一拦截到dao方法里的方法便通知myAdvise调事务管理器(transactionManager)开启事务
9 -->
10 <aop:advisor advice-ref="myAdvise" pointcut-ref="myPoint"/>
11</aop:config>
12
1
2 1 创建一个java类(dao层)
2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32 1package cn.et.dao.Impl;
2
3import java.sql.SQLException;
4
5import org.springframework.beans.factory.annotation.Autowired;
6import org.springframework.jdbc.core.JdbcTemplate;
7import org.springframework.stereotype.Repository;
8
9import cn.et.dao.MyMoneyDao;
10
11/**
12 * 命名规范
13 * 增加:save*
14 * 修改:update*
15 * 删除:delete*
16 * @author Administrator
17 */
18@Repository
19public class MyMoneyDaoImpl implements MyMoneyDao{
20 @Autowired
21 JdbcTemplate jdbc;
22 public void updateAminus(int money) throws SQLException {//A-10
23 String sql = "update users set lostedmoney= lostedmoney-"+money+" where userName='A'";
24 jdbc.execute(sql);
25 }
26
27 public void updateBadd(int money) throws SQLException {//B+10
28 String sql = "update users set lostedmoney= lostedmoney+"+money+" where userName='B'";
29 jdbc.execute(sql);
30 }
31}
32
1
2 1 由于拦截的是save\*、update\*、delete\*开头的方法,所以上面的两个方法都将被拦截下来
2
在调用这两个方法之前开启一个事务,当它执行完就提交事务(自动提交),如果出错便回滚事务。
现在运行测试还是会报错,我们还需要配置扫描、指定四要素、数据源、数据库连接
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 1<!-- 指定扫描的位置 -->
2<context:component-scan base-package="cn.et"></context:component-scan>
3
4<!-- 指定四要素的位置 -->
5<context:property-placeholder location="classpath:jdbc.properties" />
6<!-- 数据源只是为了获取连接 -->
7<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
8 <property name="url" value="${url}"></property>
9 <property name="driverClassName" value="${driverClass}"></property>
10 <property name="username" value="${userid}"></property>
11 <property name="password" value="${password}"></property>
12</bean>
13<!-- 数据库连接 -->
14<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
15 <!-- 注入数据源 -->
16 <property name="dataSource" ref="dataSource"></property>
17</bean>
18
1
2 1 写个main方法
2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 1package cn.et;
2
3import org.springframework.context.ConfigurableApplicationContext;
4import org.springframework.context.support.GenericXmlApplicationContext;
5
6import cn.et.dao.MyMoneyDao;
7
8public class Test {
9 static ConfigurableApplicationContext context;
10 static MyMoneyDao dao;
11 static{
12 context = new GenericXmlApplicationContext("classpath:spring.xml");
13 dao = (MyMoneyDao) context.getBean("myMoneyDaoImpl");
14 }
15 public static void main(String[] args) throws Exception {
16 dao.updateAminus(10);
17 dao.updateBadd(10);
18 context.close();
19 }
20}
21
22
查看数据库
运行main方法再次查看数据库
我们弄个错误试一下(按照我们的逻辑,当它报错了,A和B一起回滚)
再次运行后我们发现A减了10,B却没有变,说明它们两不在同一次事务中
我们需要将它们置于同一个事务中,如何做呢?需要使用到事务传播属性
事务传播属性
当事务方法被另一个事务方法调用时,必须指定事务应该如何传播,例如:方法可能继续在现有事务中运行,也可能开启一个新事务,并在自己的事务中运行。
事务的传播行为可以由传播属性指定,Spring定义了7种类传播行为。
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.xml配置文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71 1<?xml version="1.0" encoding="UTF-8"?>
2<beans
3 xmlns="http://www.springframework.org/schema/beans"
4 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5 xmlns:p="http://www.springframework.org/schema/p"
6 xmlns:context="http://www.springframework.org/schema/context"
7 xmlns:aop="http://www.springframework.org/schema/aop"
8 xmlns:tx="http://www.springframework.org/schema/tx"
9 xsi:schemaLocation="
10 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
11 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
12 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
13 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
14 ">
15 <!-- 指定扫描的位置 -->
16 <context:component-scan base-package="cn.et.test"></context:component-scan>
17
18 <!-- 指定四要素的位置 -->
19 <context:property-placeholder location="classpath:jdbc.properties" />
20 <!-- 数据源只是为了获取连接 -->
21 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
22 <property name="url" value="${url}"></property>
23 <property name="driverClassName" value="${driverClass}"></property>
24 <property name="username" value="${userid}"></property>
25 <property name="password" value="${password}"></property>
26 </bean>
27 <!-- 数据库连接 -->
28 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
29 <!-- 注入数据源 -->
30 <property name="dataSource" ref="dataSource"></property>
31 </bean>
32
33 <!--
34 事务管理器
35 不再使用jdbc的commit和rollback 必须使用事务管理器提供
36 -->
37 <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
38 <!-- 注入数据源 -->
39 <property name="dataSource" ref="dataSource"></property>
40 </bean>
41
42 <!--
43 定义通知
44 并且关联上事务管理器 需要事务管理器来提交和回滚 如果事务管理器id="transactionManager"下面的transaction-manager可以不写,它会自动关联上事务管理器
45 通知作用:当切点定位到下面的方法,它就会自动在前置通知里面加个连接,并且改成手动提交事物
46 在完成操作之后,提交事物,有异常便自动回滚
47 可参考下图
48 -->
49 <tx:advice id="myAdvise" transaction-manager="transactionManager">
50 <!-- 指定拦截方法 -->
51 <tx:attributes>
52 <tx:method name="update*" propagation="REQUIRED"/>
53 <tx:method name="save*"/>
54 <tx:method name="delete*"/>
55 <!-- read-only="true"只读 不开启事务-->
56 <tx:method name="*" read-only="true"/>
57 </tx:attributes>
58 </tx:advice>
59 <!--
60 定义切点
61 -->
62 <aop:config>
63 <!-- execution(* cn.*..*.dao.*.upadte*(..)) -->
64 <aop:pointcut expression="execution(* cn.*..*.service.*.*(..))" id="myPoint"/>
65 <!--
66 将切点与通知关联起来 一拦截到dao方法里的方法便通知myAdvise调事务管理器(transactionMager)开启事务
67 -->
68 <aop:advisor advice-ref="myAdvise" pointcut-ref="myPoint"/>
69 </aop:config>
70</beans>
71
持久层代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 1package cn.et.test.dao;
2
3import java.sql.SQLException;
4
5import org.springframework.beans.factory.annotation.Autowired;
6import org.springframework.jdbc.core.JdbcTemplate;
7import org.springframework.stereotype.Repository;
8
9
10@Repository
11public class AbdaoImpl{
12 @Autowired
13 JdbcTemplate jdbc;
14
15 public void updateBadd(int money) throws SQLException {
16 String sql = "update users set lostedmoney= lostedmoney+"+money+" where userName='B'";
17 jdbc.execute(sql);
18 }
19 public void updateAminus(int money) throws SQLException {
20 String sql = "update users set lostedmoney= lostedmoney-"+money+" where userName='A'";
21 jdbc.execute(sql);
22 }
23}
24
业务层代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 1package cn.et.test.service;
2
3import org.springframework.beans.factory.annotation.Autowired;
4import org.springframework.stereotype.Service;
5
6import cn.et.test.dao.AbdaoImpl;
7
8@Service
9public class AbServiceImpl {
10 @Autowired
11 AbdaoImpl dao;
12 public void updateAB(Integer money) throws Exception{
13 dao.updateAminus(money);
14 int i=5/0;
15 dao.updateBadd(money);
16 }
17}
18
main方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 1package cn.et.test;
2
3import org.springframework.context.ConfigurableApplicationContext;
4import org.springframework.context.support.GenericXmlApplicationContext;
5
6import cn.et.test.service.AbServiceImpl;
7
8public class Test {
9 static ConfigurableApplicationContext context;
10 static AbServiceImpl service;
11 static{
12 context = new GenericXmlApplicationContext("classpath:/cn/et/test/spring.xml");
13 service = (AbServiceImpl) context.getBean("abServiceImpl");
14 }
15 public static void main(String[] args) throws Exception {
16 service.updateAB(20);
17 context.close();
18 }
19}
20
1
2 1 测试-查看数据库将A置为100,B置为200
2
运行main方法-出现异常了
再次查看数据库-数据AB都没有变,说明事务传播属性设置成功了
事务的隔离级别
从理论上来说,事务应该彼此完全隔离,以避免并发事务所导致的问题,然而,那样会对性能产生极大的影响,因此事务必须按顺序运行。
在实际开发中,为了提升性能,事务会以较低的隔离级别运行。
事务的隔离级别可以通过隔离事务属性指定
Spring支持的事务隔离级别
事务的隔离级别要得到底层数据库引擎的支持,而不是应用程序或者框架的支持。
Oracle支持2种事务隔离级别:READ_COMMITED,SERIALIZABLE
Mysql支持4种事务隔离级别。
isolation="DEFAULT" 隔离级别
DEFAULT 使用数据库默认的隔离级别 ORACLE(读已提交),MYSQL(可重复读)。从隔离级别来讲,oracle的效率比mysql高。
READ_UNCOMMITTED:spring实现读未提交(脏读)
READ_COMMITTED:spring实现读已提交(不可重复读+幻读)
REPEATABLE_READ:spring实现可重复读(幻读)
SERIALIZABLE:spring实现串行化(已解决)按顺序执行,一次只有一个事务执行。效率极低。
建议不用配,使用数据库的,只要配置了数据库的隔离级别就可以了
设置隔离事务属性
在spring2.x事务通知中,可以在tx:method元素中指定隔离级别
设置回滚事务属性
默认情况下只有未检查异常(RuntimeException和Error类型的异常)会导致事务回滚,而受检查异常不会。
事务的回滚规则可以通过在tx:method元素中指定回滚规则,如果有不止一种异常,用逗号分隔。
Spring事务运行过程中,碰到运行时异常自动回滚,非运行时异常不会回滚
rollback-for="java.lang.exception":遇到指定异常必须进行回滚。
**no-rollback-for="**java.lang.exception":遇到指定异常,必须不回滚
一般都会设置为rollback-for="java.lang.exception"有异常便回滚。****
超时和只读属性
由于事务可以在行和表上获得锁,因此长事务会占用资源,并对整体性能产生影响。
如果一个事务只读取数据但不做修改,数据库引擎可以对这个事务进行优化。
超时事务属性:事务在强制回滚之前可以保持多久,这样可以防止长期运行的事务占用资源。
只读事务属性:表示这个事务只读数据但不更新数据,这样可以帮助数据库引擎优化事务。
设置超时和只读事务属性
超时和只读属性可以在tx:method元素中进行指定
所需jar包
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61 1<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">
2 <modelVersion>4.0.0</modelVersion>
3 <groupId>cn.et</groupId>
4 <artifactId>Spring_affair</artifactId>
5 <version>0.0.1-SNAPSHOT</version>
6 <packaging>war</packaging>
7 <dependencies>
8 <!-- spring依赖 -->
9 <dependency>
10 <groupId>org.springframework</groupId>
11 <artifactId>spring-context</artifactId>
12 <version>4.3.12.RELEASE</version>
13 </dependency>
14 <!-- aop依赖 -->
15 <dependency>
16 <groupId>org.springframework</groupId>
17 <artifactId>spring-aop</artifactId>
18 <version>4.3.11.RELEASE</version>
19 </dependency>
20 <!-- spring事务依赖 -->
21 <dependency>
22 <groupId>org.springframework</groupId>
23 <artifactId>spring-orm</artifactId>
24 <version>4.3.11.RELEASE</version>
25 </dependency>
26 <dependency>
27 <groupId>aopalliance</groupId>
28 <artifactId>aopalliance</artifactId>
29 <version>1.0</version>
30 </dependency>
31 <dependency>
32 <groupId>aspectj</groupId>
33 <artifactId>aspectjweaver</artifactId>
34 <version>1.5.3</version>
35 </dependency>
36 <!-- jdbc依赖 -->
37 <dependency>
38 <groupId>org.springframework</groupId>
39 <artifactId>spring-jdbc</artifactId>
40 <version>4.3.12.RELEASE</version>
41 </dependency>
42 <!-- mysql数据库依赖 -->
43 <dependency>
44 <groupId>mysql</groupId>
45 <artifactId>mysql-connector-java</artifactId>
46 <version>5.1.26</version>
47 </dependency>
48 <!-- 日志依赖 -->
49 <dependency>
50 <groupId>log4j</groupId>
51 <artifactId>log4j</artifactId>
52 <version>1.2.17</version>
53 </dependency>
54 <dependency>
55 <groupId>aspectj</groupId>
56 <artifactId>aspectjrt</artifactId>
57 <version>1.2</version>
58 </dependency>
59 </dependencies>
60</project>
61