其他分享
首页 > 其他分享> > 小白学习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