标签：事务 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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。