spring中声明式事务控制学习记录

深碍√TFBOYSˉ_ 2022-05-10 07:38 42阅读 0赞

### 什么是事务？ ###

数据库的事务，指的是一组操作的执行单元；其中的一组操作指的是一组SQL指令（增、删、改），执行单元指这一组操作全部执行成功，或者全部回滚；（什么是单元，一个才整体交一个单元）

简单理解一下，其实就是：事务是一组sql 语句的集合，这组sql语句要么全部执行成功，要么全部回滚

事务有四个基本要素，简称ACID

atomic（原子性）：事务的所有操作，要么全部完成，要么全部回滚到事务开始前的状态

consistent（一致性）：事务执行的结果必须是从一个一致的状态到另一个一致的状态，不管一个时间点上它有多少个并发事务

isolate（隔离性）：一个事务的执行不能被其他事务干扰，

durable（持久性）：事务一旦提交，事务对数据库的更改被永久性的保存在数据库中，

### Spring提供的事务控制 ###

*  **编程式事务控制**

在代码中控制事务的开始、回滚、和结束，可以自由的控制在哪个方法的哪一行中进行事务控制，其控制的**颗粒度更细**（相对于声明式事务控制）；因为是写在代码中，由程序员自己控制，因此在团队合作中，事务的管理会比较混乱。下面是一个案例：

public int insertDB(){
    	Connection conn = null;
    	PreparedStatement pstmt = null;
    	int result = 0;
    	try {
    		conn = jdbcTemplate.getDataSource().getConnection();
    		conn.setAutoCommit(false);  //默认是自动提交事务的，这个关闭自动提交
    		String sql = "insert into lsjm_user (uname,pwd) values (?,?)";
    		pstmt = conn.prepareStatement(sql);
    		pstmt.setString(1, "801");
    		pstmt.setString(2, "编程式事务控制");
    		System.out.println("编程式事务控制");
    		result =  pstmt.executeUpdate();
    		Object e = 3/0;  // 创造一个异常，进入catch
    		conn.commit(); // 手动提交事务，不写这一行，前面的插入数据到数据库是不起作用的，也不报异常
    	} catch (Exception e) {
    		try {
    			conn.rollback();  // 发生了异常，进行事务回滚
    		} catch (SQLException e1) {
    			e1.printStackTrace();
    		}  
    	}finally{
    		try {
    			conn.setAutoCommit(true);
    			pstmt.close();
    			conn.close();
    		} catch (SQLException e) {
    			e.printStackTrace();
    		}
    	}
    	return result ;
    }

*  **声明式事务控制**

Spring没有直接管理事务，提供事务管理器 调用第三方组件完成事务控制

<table> 
 <thead> 
 <tr> 
 <th style="width:514px;">事务管理器</th> 
 <th style="width:383px;">下面对应目标时使用</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="width:514px;"> org.springframework.jdbc.datasource.DataSourceTransactionManager </td> 
 <td style="width:383px;"> 在单一的JDBC Datasource中管理事务 </td> 
 </tr> 
 <tr> 
 <td style="width:514px;"> org.springframework.orm.hibernate3.HibernateTransactionManager </td> 
 <td style="width:383px;"> 当持久化机制是hibernate时，用它来管理事务 </td> 
 </tr> 
 <tr> 
 <td style="width:514px;"> org.springframework.jdo.JdoTransactionManager </td> 
 <td style="width:383px;">当持久化机制是Jdo时，用它来管理事务</td> 
 </tr> 
 <tr> 
 <td style="width:514px;"> org.springframework.transaction.jta.JtaTransactionManager </td> 
 <td style="width:383px;"> 使用一个JTA实现来管理事务。在一个事务跨越多个资源时必须使用 </td> 
 </tr> 
 <tr> 
 <td style="width:514px;"> org.springframework.orm.ojb.PersistenceBrokerTransactionManager </td> 
 <td style="width:383px;">当apache的ojb用作持久化机制时，用它来管理事务</td> 
 </tr> 
 </tbody> 
</table>

**特点：**

*  配置在配置文件中，解除了和代码的耦合度，不需要事务管理时，去掉配置即可（注解也算是配置）
 *  事务以bean组件的函数为单位，即一个函数正常执行完成后，这个函数中的数据库操作按照一次事务提交

**因为事务以函数为单位，函数与函数之间肯定存在相互调用的关系，此时的事务怎么处理？**

-- spring 提供了一组配置供开发者选择，配置的方式成为事务的传播策略，比如方法A 调用了 方法B

<table> 
 <thead> 
 <tr> 
 <th style="border-color:#000000;vertical-align:top;width:102pt;"> 传播行为 </th> 
 <th style="border-color:#000000;vertical-align:top;"> 意义 </th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="border-color:#000000;vertical-align:top;width:102pt;"> REQUIRED </td> 
 <td style="border-color:#000000;vertical-align:top;"> 业务方法需要在一个事务中运行。如果方法运行时，已经处在一个事务中，那么加入到该事务，否则为自己创建一个新的事务 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#000000;vertical-align:top;width:102pt;"> NOT_SUPPORTED </td> 
 <td style="border-color:#000000;vertical-align:top;"> 声明方法不需要事务。如果方法没有关联到一个事务，容器不会为它开启事务。如果方法在一个事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#000000;vertical-align:top;width:102pt;"> REQUIRESNEW </td> 
 <td style="border-color:#000000;vertical-align:top;"> 属性表明不管是否存在事务，业务方法总会为自己发起一个新的事务。如果方法已经运行在一个事务中，则原有事务会被挂起，新的事务会被创建，直到方法执行结束，新事务才算结束，原先的事务才会恢复执行 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#000000;vertical-align:top;width:102pt;"> MANDATORY </td> 
 <td style="border-color:#000000;vertical-align:top;"> 该属性指定业务方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务。如果业务方法在没有事务的环境下调用，容器就会抛出例外。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#000000;vertical-align:top;width:102pt;"> SUPPORTS </td> 
 <td style="border-color:#000000;vertical-align:top;"> 这一事务属性表明，如果业务方法在某个事务范围内被调用，则方法成为该事务的一部分。如果业务方法在事务范围外被调用，则方法在没有事务的环境下执行 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#000000;vertical-align:top;width:102pt;"> Never </td> 
 <td style="border-color:#000000;vertical-align:top;"> 指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务中执行，容器会抛出例外，只有业务方法没有关联到任何事务，才能正常执行 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#000000;vertical-align:top;width:102pt;"> NESTED </td> 
 <td style="border-color:#000000;vertical-align:top;"> 如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按REQUIRED属性执行.它使用了一个单独的事务， 这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager事务管理器起效 </td> 
 </tr> 
 </tbody> 
</table>

数据库的隔离级别（这个需要再研究一下，暂时贴上）

<table> 
 <thead> 
 <tr> 
 <th style="border-color:#000000;vertical-align:top;width:163pt;"> 隔离级别 </th> 
 <th style="border-color:#000000;vertical-align:top;width:523pt;"> 含义 </th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="border-color:#000000;vertical-align:top;width:163pt;"> DEFAULT </td> 
 <td style="border-color:#000000;vertical-align:top;width:523pt;"> 使用后端数据库默认的隔离级别(spring中的的选择项) </td> 
 </tr> 
 <tr> 
 <td style="border-color:#000000;vertical-align:top;width:163pt;"> READ_UNCOMMITED </td> 
 <td style="border-color:#000000;vertical-align:top;width:523pt;"> 允许你读取还未提交的改变了的数据。可能导致脏、幻、不可重复读 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#000000;vertical-align:top;width:163pt;"> READ_COMMITTED </td> 
 <td style="border-color:#000000;vertical-align:top;width:523pt;"> 允许在并发事务已经提交后读取。可防止脏读，但幻读和 不可重复读仍可发生 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#000000;vertical-align:top;width:163pt;"> REPEATABLE_READ </td> 
 <td style="border-color:#000000;vertical-align:top;width:523pt;"> 对相同字段的多次读取是一致的，除非数据被事务本身改变。可防止脏、不可重复读，但幻读仍可能发生。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#000000;vertical-align:top;width:163pt;"> SERIALIZABLE </td> 
 <td style="border-color:#000000;vertical-align:top;width:523pt;"> 完全服从ACID的隔离级别，确保不发生脏、幻、不可重复读。这在所有的隔离级别中是最慢的，它是典型的通过完全锁定在事务中涉及的数据表来完成的。 </td> 
 </tr> 
 </tbody> 
</table>

### Spring声明式事务控制的使用 （junit测试Demo） ###

1、准备工作

*  导jar包：
    
     *  数据库驱动jar ：mysql-connector-java......
     *  spring核心容器core、context；
     *  spring集成jdbc 的 jar：spring-jdbc...， 事务控制的jar：spring-tx...， AOP的jar：spring-aop...

<dependencies>
 	
 	<dependency>
 		<groupId>junit</groupId>
 		<artifactId>junit</artifactId>
 		<version>4.12</version>
 		<scope>test</scope>
 	</dependency>
 	
 	
 	<dependency>
 		<groupId>mysql</groupId>
 		<artifactId>mysql-connector-java</artifactId>
 		<version>5.1.32</version>
 	</dependency>
 	
 	
 	<dependency>
 		<groupId>org.springframework</groupId>
 		<artifactId>spring-core</artifactId>
 		<version>${spring.version}</version>
 	</dependency>
 	
 	
 	<dependency>
 		<groupId>org.springframework</groupId>
 		<artifactId>spring-context</artifactId>
 		<version>${spring.version}</version>
 	</dependency>
 	
 	
 	<dependency>
 		<groupId>org.springframework</groupId>
 		<artifactId>spring-context-support</artifactId>
 		<version>${spring.version}</version>
 	</dependency>
 	
 	
 	<dependency>
 		<groupId>org.springframework</groupId>
 		<artifactId>spring-aop</artifactId>
 		<version>${spring.version}</version>
 	</dependency>
 
 	<dependency>
 		<groupId>org.springframework</groupId>
 		<artifactId>spring-aspects</artifactId>
 		<version>${spring.version}</version>
 	</dependency>
 	
 	
 	<dependency>
 		<groupId>org.springframework</groupId>
 		<artifactId>spring-jdbc</artifactId>
 		<version>${spring.version}</version>
 	</dependency>
 	
 	
 	<dependency>
 		<groupId>org.springframework</groupId>
 		<artifactId>spring-tx</artifactId>
 		<version>${spring.version}</version>
 	</dependency>
 </dependencies>

2、声明式事务控制配置，内容 和 注释都写在配置文件中

<?xml version="1.0" encoding="UTF-8"?>
 
 
 
 
 <beans xmlns="http://www.springframework.org/schema/beans"
 	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">
 
 
 	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
 		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
 		<property name="url" value="jdbc:mysql://localhost:3306/lsjm?useUnicode=true&characterEncoding=utf8" />
 		<property name="username" value="admin" />
 		<property name="password" value="admin" />
 	</bean>
 	
 	
 	<bean id="userDao1" class="com.chaol.dao.impl.LsjmUserDaoImpl1">
 		<property name="dataSource" ref="dataSource"></property>
 	</bean>
 	
 	
 	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
 		<property name="dataSource" ref="dataSource"></property>
 	</bean>
 	
 	
 	<bean id="userDao" class="com.chaol.dao.impl.LsjmUserDaoImpl">
 		<property name="jdbcTemplate" ref="jdbcTemplate"></property>
 	</bean>
 	
 	
 	
 	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 		<property name="dataSource" ref="dataSource"></property>
 	</bean>
 	
 	
 	<tx:advice id="ad" transaction-manager="transactionManager">
 		<tx:attributes>
 			
 			<tx:method name="insert*" isolation="DEFAULT" propagation="REQUIRED" read-only="false"/>
 		</tx:attributes>
 	</tx:advice>
 	
 	
 <aop:config>
 	 <aop:pointcut expression="execution(* com.chaol.dao.impl.*.*(..))" id="targetPointcut"/>
 	 
 	 <aop:advisor advice-ref="ad" pointcut-ref="targetPointcut"/>
 </aop:config>
 </beans>

在上面的配置 中，配置了对com.chaol.dao.impl 下的任意类中 形如 insert\* 的方法 做事务管理，写一个方法测试一下：

// 这个方法是在 com.chaol.dao.impl.LsjmUserDaoImpl类中
    public int insert(){
    	String sql = "insert into lsjm_user (uname,pwd) values (?,?)";
    	int result = jdbcTemplate.update(sql,new Object[]{"txTest2", "txTest2"});
    	Object e = 3/0;  // 创造一个异常，测试会不会回滚
    	return result;
    }

执行上面方法，取数据库中查看结果：

\-- 可见函数中的数据库操作并没有保存到数据库中，函数发生异常，数据库操作全部回滚（没有抛出异常测试是好的，结果不贴了）：

![70][]

**每一种能用配置写的 ，大都都可以用注解来配置，声明式事务控制的注解配置：**

省去上面的第二步和第三部，然后加上：

<context:component-scan base-package="com.chaol.dao.impl"></context:component-scan>
 
 <tx:annotation-driven transaction-manager="transactionManager"/>
 
 
 <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 	<property name="dataSource" ref="dataSource"></property>
 </bean>

然后在需要事务控制的方法上用@Transactional 注解（测试结果不贴了）：

@Transactional(isolation=Isolation.DEFAULT, propagation=Propagation.REQUIRED,readOnly=false)
    public int insert(){
    	String sql = "insert into lsjm_user (uname,pwd) values (?,?)";
    	int result = jdbcTemplate.update(sql,new Object[]{"txTest3", "txTest3"});
    	Object e = 3/0;  // 创造一个异常，测试会不会回滚
    	return result;
    }

在用junit测试的过程中遇到一个问题，下面贴一下我的junit代码：

public class LsjmUserDaoTest {
    
    	//LsjmUserDaoImpl lsjmUserDaoImpl  
    	LsjmUserDao lsjmUserDaoImpl;
    	
    	@Before
    	public void before(){
    		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    		lsjmUserDaoImpl =(LsjmUserDao) ac.getBean("userDao");
    		
    		//lsjmUserDaoImpl =(LsjmUserDaoImpl) ac.getBean("userDao");
    	}
    	
    	@Test
    	public void test(){
    		System.out.println(lsjmUserDaoImpl.insert());
    	}
    }

**问题：**

如下 使用 接口 LsjmUserDao 的实现类 LsjmUserDaoImpl 来转换对象时，会报错，信息如下：

LsjmUserDaoImpl lsjmUserDaoImpl = (LsjmUserDaoImpl) ac.getBean("userDao");

**java.lang.ClassCastException: com.sun.proxy.$Proxy10 cannot be cast to com.chaol.dao.impl.LsjmUserDaoImpl**

**解决：**

用接口来转换 ac.getBean("userDao") 获取得到的对象

LsjmUserDao lsjmUserDaoImpl = (LsjmUserDao) ac.getBean("userDao");

**原因：**不能用接口的实现类来转换Proxy的实现类，它们是同级，应该用共同的接口来转换（百度到的）

[70]: /images/20220510/7b30f5087a9f4b3f87dfa5b21ab189c8.png