其他分享
首页 > 其他分享> > 小白学习Spring(三)Spring的事务处理

小白学习Spring(三)Spring的事务处理

作者：互联网

Spring的事务处理

回答问题

1.什么是事务

讲mysql的时候，提出了事务，事务是指一组sql语句的集合，集合中有多条sql语句

可能是insert，update，select，delete 或者组合，我们希望这些多个sql语句都能成功，

或者都失败，这些sql语句的执行是一致的，作为一个整体执行。

2.在什么时候要想到使用这个事务

当我的操作涉及到多个表，或者是多个sql语句的insertinsert，update，select，delete 。需要保证

这些语句都是成功才能完成我的功能，或者都失败，保证操作是符合要求的。

​ 银行转账问题 A B账户需要平衡

​ 现在java代码中写程序来控制事务，事务应该放在哪里那？

​ service类的业务方法上，因为业务方法会调用多个dao方法，执行多个sql语句

3.通常使用jdbc访问数据库，还是mybatis 访问数据库怎么处理事务

jdbc访问数据库，处理事务，Connection con ;conn.commit();conn.rollback();

​ mybatis访问数据库，处理事务，SqlSession.commit();SqlSession.rollback();

​ hibernate访问数据库，处理事务，Sesession.commit();Session.rollback();

4.问题中事务的处理方式，有什么不足

​ 1)不同的数据库访问技术，处理事务的对象，方法不同，

​ 需要去了解不同数据库访问技术使用事务的原理

​ 2）掌握多种数据库中事务的处理逻辑。什么时候提交事务，什么时候回滚事务。

​ 3）处理事务的多种方法。

​ 总结：就是多种数据库的访问技术，有不同的事务处理的机制，对象，方法。

5.怎么解决不足

​ spring提供了一种处理事务的统一模型，能使用统一的步骤，方式完成多种不同数据库访问技术的事务处理。

使用spring的事务处理机制，可以完成mybatis访问数据库的事务处理。

使用spring的事务处理机制，可以完成hibernate访问数据库的事务处理。
在这里插入图片描述

6.处理事务，需要怎么做，做什么

spring处理事务的模型，使用的步骤都是固定的。把事务使用的一一些信息提供给spring就可以了

1）spring事务提交，回滚事务，

​ 使用的事务管理器对象，代替你完成commit，rollback

​ 事务管理器是一个接口和实现类和他的众多实现类。

​ 接口：PlatformTransactionManager,定义了事务重要方法 commit，rollback

​ 实现类：spring把每一种数据库访问技术，对应的事务处理类都创建好了。

​ mybatis访问数据库—spring创建好的是DataSourceTransactionManager

​ hibernate访问数据库----spring创建的是HibernateTransactionsManager

​ 怎么使用：你要告诉spring你用是那种数据库的访问技术，怎么告诉spring？

声明数据库访问技术对应的实现类，在spring的配置文件中使用声明就可以了

例如，你要使用mybatis访问数据库，你应该在xml配置文件中

2)你的业务方法需要什么样的事务，说明需要事务的类型。

说明方法需要的事务：

1）事务的隔离级别:有4个值

​ 在接口事务接口TransactionDefinition中定义了这些关于事务的常量

​ 这些常量的前缀均是以ISOLATION_开头的

​ ISOLATION_xxx

​ DEFAULT：采用DB默认的事务隔离级别。MySql的默认为REPEATABLE_READ;

​ Oracle默认为READ_COMMITTED:

​ READ_UNCOMMITTED:读未提交。未解决任何并发问题。

​ READ_COMMITTED:读已提交。解决脏读，存在不可重复与幻读。

​ REPEATABLE_READ:可重复读。解决脏读、不可重复读，存在幻读。

​ SERIALIZABLE:串行化。不存在并发问题。、

2)事务的超时时间:

​ 表示一个方法最长的执行时间，如果方法执行时超过了这个时间，事务就回滚 。

​ 单位是秒，整数值，默认是 -1. TIME_OUT

3）事务的传播行为

​ 控制业务方法是不是有事务的，是什么样事务的，是什么样的事务的。

​ 7个传播行为，表示你的业务方法调用时，事务在方法之间是如果使用的。

​ 事务传播行为常量都是以PROPAGATION_开头，形如PROPAGATION_XXX

​ PROPAGATION_REQUIRED

​ 指定的方法必须在事务内执行。若当前存在事务，就加入到当前事务中；若当前没有事务，则创建一个新事务，这种传播行为是最常见的选择，也是spring默认的事务传播行为。

​ 如该传播行为加上doOther()方法上。若doSome()方法在调用doOther()方法时就是在事务内运行的，则doOther()方法的执行也加入到该事务内执行。若doSome()方法在调用doOther()方法时没有在事务内执行，则doOther()方法会创建一个事务，并在其中执行。
在这里插入图片描述
PROPAGATION_REQUIRED_NEW

​ 指定的方法支持当前事务，但若当前没有事务，也可以以非事务方式进行

​ PROPAGATION_REQUIRES_NEW

​ 总是新建一个事务，若当前存在事务，就当前事务挂起，知道新事物执行完毕。

​ 以上需要掌握

​ PROPAGATION_MANDATORY

​ PROPAGATION_NSSTED

​ PROPAGATION_NEVER

​ PROPAGATION_NOT_SUPPORTED

​ 4）事务提交事务，回滚事务的时机

​ 1）当你的业务方法，执行成功，没有异常抛出，当方法执行完毕，spring在方法执行后提交事务。

​ 2）当你的业务方法抛出运行时异常或Error，spring执行回滚，调用事务管理器的rollback

​ 运行时异常的定义:RuntimeException 和他的子类都是运行时异常，例如 NUllPointException,NumberFormatEcption

​ 3)当你的业务方法抛出非运行时异常，主要是受查异常时 ，提交事务

​ 受查异常:在你写代码时，必须处理的异常。例如 IOException,SQLException

总结spring的事务

​ 1.管理事务的是 事务管理 和他的实现类

​ 2.spring的事务是个统一模型

​ 1）指定要使用的事务管理器的实现类bean

​ 2) 指定那些类，哪些方法需要加入事务的功能

​ 3）指定方法需要的隔离级别，传播行为，超时。

​ 你需要告诉spring,你的项目中类信息，方法的名称。方法的事务传播行为。

Spring的事务管理示例

电商购买商品创建实体类

Step0:创建数据库表

创建两个数据库表sale，goods

sale 销售表

spring框架中他提供的事务处理方案

1.适合中小项目使用的注解方案。

​ spring框架自己用aop实现给业务方法增加事务的功能，使用@Transactional注解增加事务，

​ @Transactional注解时spring框架自己注解，放在public方法的上面，表示当前方法具有事务

​ 可以给注解的属性赋值，表示具体的隔离级别，传播行为，异常信息的等等

使用Spring的事务注解管理事务（掌握）

@Transactional，可将事务织入到相应的public方法中，实现事务管理。

@Transactional的所有可选属性如下所示：

propagation:

​ 用于设置事务传播属性。该属性类型为Propagation枚举,默认值为Proagation.REQUIRED

isolation:

​ 用于设置事务的隔离级别。该属性类型为 isolation枚举，默认值为isolation.DEFAULT。

readOnly:

​ 用于设置该方法对数据库的操作是否是只读的。该属性为boolean，默认值为false。

timeout:

​ 用于设置本操作与数据库连接的超时时限。单位为秒，类型为int，默认值为 false。

rollbackFor:

​ 指定需要回滚的异常类。类型为Clss[],默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

rollbackForClassName:

​ 指定需要回滚的异常类类名。类型为String[],默认值为空数组。当然，若只有一个异常类时，可以不使用数组[]

noRollbackFor:

​ 指定不需要回滚的异常类。类型为Class[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

noRollbackForClassName:

​ 指定不需要回滚的异常类类名。类型为String[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

需要注意的时，@Transactional若用在方法上，只能用于public方法上。对于其他非public方法 ，如果加上了注解@

Transactional，虽然spring不会报错。但不会将指定事务织入到该方法中 ，因为spring会忽略到掉所有非public方法上

@Transactional注解

使用@Transactional的步骤:

1.需要声明事务管理器对象

​

2.开启事务注解驱动，告诉spring框架，我要使用注解的方式去管理事务。

​ spring会使用 aop这个机制，创建@Transactional所在的类代理对象 ，给方法加入事务的功能。

​ spring给业务方法加入事务：

​ 在你的业务方法执行之前，先开启事务，在业务方法之后一脚或回滚事务 ，使用aop的环绕通知

​ @Around(“你要增加的业务功能 的业务 方法名称”)

​ Object myAround(){

​ 开启事务 ，spring给你开启

​ try{

​ buy（1001，10）;

​ spring的事务管理 .commit();

​ }catch(Exception e)

​ spring的事务管理.rollback();

​ }

2.适合大型项目，有很多类的，方法，

需要大量的配置事务，使用aspectj框架功能，在spring配置文件中声明类，方法需要的事务。这种方式业务方法和事务配置完全分离。

实现步骤：都是在xml配置文件中实现。

1）要使用的是aspectj框架，需要加入依赖

​	<dependency>
​	    <groupId>org.springframework</groupId>
​	    <artifactId>spring-aspects</artifactId>
​	    <version>5.3.5</version>
​	</dependency>

2）声明事务管理器对象

​

3)声明方法需要的事务类型（配置方法的事务属性【隔离级别，传播行为，超时】）

4）配置aop:指定哪些哪类型要从创建代理。

两种方式

第一种：

<?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:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	xmlns:mybatis-spring="http://mybatis.org/schema/mybatis-spring"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.3.xsd
		http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring-1.2.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

	 <!-- 把数据库的配置信息，卸载一个独立的文件中，编译修改数据库的配置内容
	 	spring知道jdbc.properties文件的位置
	  -->
	<context:property-placeholder location="classpath:jdbc.properties"/>
	
	<!-- 声明数据源DataSource,作用是连接数据库 -->
	 <bean id="mydataSource" class="com.alibaba.druid.pool.DruidDataSource" 
	 init-method="init" 
	 destroy-method="close"> 
	
	 <!-- 使用set注入给DruidDataSrouce提供连接数据库信息 -->
	 <property name="url" value="${jdbc.url}" />
	 <property name="username" value="${jdbc.username}" />
	 <property name="password" value="${jdbc.password}" />
	 <property name="maxActive" value="${jdbc.maxActive}" />
	 </bean>
	
	<!-- 声明的是mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory -->
	
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
	<!-- set注入，把数据连接池赋给了dataSource -->
		<property name="dataSource" ref="mydataSource"/>
	<!-- mybatis主配置文件 
	
		configLocationResource属性是Resource类型，读取配置文件
		他的赋值，使用value，指定文件的路径，使用classpath:表示文件的位置
	-->
		<property name="configLocation" value="classpath:Mybatis.xml"/>
	</bean>
	
	<!-- 创建dao对象，使用SqlSession的getMapper(StudentDao.class)
		 MapperScannerConfigurer:在内部调用getMapper()生成每个dao接口的代理对象
	 -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<!-- SqlSessionFactory对象的id -->
		<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
			<!-- 指定包名
				MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行
				一次getMapper方法，得到每个接口的dao对象
				创建好的dao对象放入到spring的容器中的。 dao对象的默认名称是 接口名首字母小写
			 -->
		<property name="basePackage" value="com.sdyu.dao"/><!-- ,进行分割多个包 可变的 -->
		
	</bean>
	<!-- 声明service -->
	<bean id="buyGoodsService" class="com.sdyu.service.Impl.BuyGoodsServiceImpl">
		<property name="saleDao" ref="saleDao"></property>
		<property name="goodsDao" ref="goodsDao"></property>
	</bean>
	
	<!-- spring事务处理 -->
	<!-- 1.声明事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 连接的数据库，指定数据源 -->
		<property name="dataSource" ref="mydataSource"></property>
	</bean>
	<!-- 2.开启事务注解驱动，告诉spring要使用注解管理事务 
		transaction-manager的值代表事务管理器对象的id
	-->
	<tx:annotation-driven transaction-manager="transactionManager" />

</beans>

第二种：

 <!-- 把数据库的配置信息，卸载一个独立的文件中，编译修改数据库的配置内容
	 	spring知道jdbc.properties文件的位置
	  -->
	<context:property-placeholder location="classpath:jdbc.properties"/>
	

​	<!-- 声明数据源DataSource,作用是连接数据库 -->
​	 <bean id="mydataSource" class="com.alibaba.druid.pool.DruidDataSource" 
​	 init-method="init" 
​	 destroy-method="close"> 
​	
​	 <!-- 使用set注入给DruidDataSrouce提供连接数据库信息 -->
​	 <property name="url" value="${jdbc.url}" />
​	 <property name="username" value="${jdbc.username}" />
​	 <property name="password" value="${jdbc.password}" />
​	 <property name="maxActive" value="${jdbc.maxActive}" />
​	 </bean>
​	
​	<!-- 声明的是mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory -->
​	
​	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
​	<!-- set注入，把数据连接池赋给了dataSource -->
​		<property name="dataSource" ref="mydataSource"/>
​	<!-- mybatis主配置文件 
​	
​		configLocationResource属性是Resource类型，读取配置文件
​		他的赋值，使用value，指定文件的路径，使用classpath:表示文件的位置
​	-->
​		<property name="configLocation" value="classpath:Mybatis.xml"/>
​	</bean>
​	
​	<!-- 创建dao对象，使用SqlSession的getMapper(StudentDao.class)
​		 MapperScannerConfigurer:在内部调用getMapper()生成每个dao接口的代理对象
​	 -->
​	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
​		<!-- SqlSessionFactory对象的id -->
​		<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
​			<!-- 指定包名
​				MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行
​				一次getMapper方法，得到每个接口的dao对象
​				创建好的dao对象放入到spring的容器中的。 dao对象的默认名称是 接口名首字母小写
​			 -->
​		<property name="basePackage" value="com.sdyu.dao"/><!-- ,进行分割多个包 可变的 -->
​		
​	</bean>
​	<!-- 声明service -->
​	<bean id="buyGoodsService" class="com.sdyu.service.Impl.BuyGoodsServiceImpl">
​		<property name="saleDao" ref="saleDao"></property>
​		<property name="goodsDao" ref="goodsDao"></property>
​	</bean>
​	
​	<!-- spring事务处理 -->
​	<!-- 1.声明事务管理器 -->
​	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
​		<!-- 连接的数据库，指定数据源 -->
​		<property name="dataSource" ref="mydataSource"></property>
​	</bean>
​	<!-- 2.声明业务方法它的事务属性(隔离级别，传播行为，超时时间)
​		id是一个自定义名称，表示<tx:advice>和</tx:advice>之间的配置内容的
​		transaction-manager：事务管理器对象的id
​	 -->
​	<tx:advice  id="myAdvice" transaction-manager="transactionManager">
​		<!-- 表示配置事务的属性  -->
​		<tx:attributes>
​		<!-- 给具体的方法配置事务属性  method的可以有多个
​			name为方法的名称 1）完整 的名称，不带有包和类。
​						2）方法可以使用通配符，*表示任意字符
​						propagation:传播行为，枚举值
​						isolation="DEFAULT":隔离级别
​						rollback-for=""：指定的异常类名，全限定类名 发生异常一定回滚
​		-->
​				<tx:method name="buy" propagation="REQUIRED"  isolation="DEFAULT" 
​							rollback-for="java.lang.NullPointerException,com.sdyu.excep.NotEnoughException"/>
​				<!-- 使用通配符 ，指定很多的方法 -->
​				<!-- 增加方法 -->
​				<tx:method name="add*" propagation="REQUIRES_NEW"/>
​				<!-- 修改方法 -->
​				<tx:method name="modify*" propagation="REQUIRED"/>
​				<!-- 删除方法 -->
​				<tx:method name="remove*" propagation="REQUIRED"/>
​				<!-- 查询方法  query search find-->
​				<tx:method name="*"  propagation="SUPPORTS" read-only="true"/>
​		</tx:attributes>
​	</tx:advice>
​	
​	<!-- 配置AOP -->
​	<aop:config>
​		<!-- 配置切入点表达式：指定哪些包中类，要使用事务
​			id：切入点表达式的名称，唯一值
​			expression:切入点表达式，指定哪些类要使用事务，aspectj会创建代理对象
​			
​			com.sdyu.service
​			com.crm.service
​			com.service
​		 -->
​		 <aop:pointcut expression="execution(* *..service..*.*(..))" id="servicePt"/>
​		 
​		 <!-- 配置增强器：关联advice和pointcut 
​		 	advice-ref:通知，上面tx：advice哪里的配置
​		 	pointcut-ref：切入点表达式的id
​		 -->
​		 <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt"/>
​	</aop:config>

</beans>

Web项目使用Spring的问题

1.做的是javase项目有main方法的，执行代码是执行main方法的，

在main里面对象创建的容器对象

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

2.web项目是在tomcat服务器上运行的，tomcat一启动，项目一直运行的。

<!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
    <version>2.3.3</version>
    <scope>provided</scope>
</dependency>





<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>

配置监听器

创建监听器ContextLoaderListener

监听器被创建对象后，会读取默认/WEB-INF/applicationContext.xml

放在这个目录下

修改默认目录

contextConfigLocation表示文件的路径

<context-param>

​	<param-name>contextConfigLocation</param-name>

​	<param-value>自定义路径</param-value>

</context-param>



<listener>  

<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>  

</listener>  

<listener>  

 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  

</listener>

不再使用ApplicationContext这个对象创建

使用

WebApplicationContext ctx =null;

获取ServletContext中的容器对象，创建好的容器对象，拿来就用。

String key = WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE;

Object  attr = getServletContext().getArribute(key);

if(attr  !=  null){

​	ctx = (WebApplicationContext)attr;

}

使用框架中的方法获取容器对象，

ServletContext sc =  getServletContext();

ctx  =  WebApplicationContextUtils.getRequiredWebApplicationContext(sc);

配置监听器:目的是创建容器对象，创建了容器对象，就能把spring.xml配置文件中的所有对象都创建好。

用户发起请求就可以直接使用对象。

标签：事务,Spring,数据库,使用,事务处理,小白,spring,方法
来源： https://blog.csdn.net/hjs_75187712/article/details/120453054