开始时间：2022-01-13
课程链接：动力节点Spring框架教程
spring的事务处理
回答问题
什么是事务
事务是指一组sql语句的集合， 参考博客集合中有多条sql语句 可能是insert ， update ，select ，delete， 我们希望这些多个sql语句都能成功， 或者都失败， 这些sql语句的执行是一致的，作为一个整体执行。
在什么时候想到使用事务
当操作涉及得到多个表（典型为转账），或者是多个sql语句的insert，update，delete。需要保证这些语句都是成功才能完成我的功能，或者都失败，保证操作是符合要求的。
在java代码中写程序，控制事务，此时事务应该放在那里呢？ service类的业务方法上，也就是我们写的StudentServiceImpl里面
因为业务方法会调用多个dao方法，执行多个sql语句
JDBC访问数据库和mybatis访问数据库处理事务
jdbc访问数据库，处理事务
Connection conn ; conn.commit(); conn.rollback();
mybatis访问数据库，处理事务，
SqlSession.commit(); SqlSession.rollback();
JDBC、Mybatis问题中事务的处理方式，有什么不足
-
不同的数据库访问技术，处理事务的对象，方法不同， 需要了解不同数据库访问技术使用事务的原理
-
掌握多种数据库中事务的处理逻辑。什么时候提交事务，什么时候回顾事务
-
处理事务的多种方法。
总结： 就是多种数据库的访问技术，有不同的事务处理的机制，对象，方法。
解决不足
- spring提供一种处理事务的统一模型， 能使用统一步骤，方式完成多种不同数据库访问技术的事务处理。
- 使用spring的事务处理机制，可以完成mybatis访问数据库的事务处理
处理事务，需要怎么做，做什么
spring处理事务的模型，使用的步骤都是固定的。把事务使用的信息提供给spring就可以了
1）事务内部提交，回滚事务，使用的事务管理器对象，代替你完成commit，rollback
事务管理器是一个接口和他的众多实现类。
接口：PlatformTransactionManager ，定义了事务重要方法 commit ，rollback
实现类：spring把每一种数据库访问技术对应的事务处理类都创建好了。
mybatis访问数据库—spring创建好的是DataSourceTransactionManager
声明数据库访问技术对于的事务管理器实现类， 在spring的配置文件中使用声明就可以了
例如，你要使用mybatis访问数据库，你应该在xml配置文件中
<bean id=“xxx" class="...DataSourceTransactionManager">
你的业务方法需要什么样的事务，说明需要事务的类型。
说明方法需要的事务：
1）事务的隔离级别：有4个值。参考博客
DEFAULT：采用 DB 默认的事务隔离级别。MySql 的默认为 REPEATABLE_READ； Oracle默认为 READ_COMMITTED。
➢ READ_UNCOMMITTED：读未提交。未解决任何并发问题。
➢ READ_COMMITTED：读已提交。解决脏读，存在不可重复读与幻读。
➢ REPEATABLE_READ：可重复读。解决脏读、不可重复读，存在幻读
（MySQL一般是这个）
➢ SERIALIZABLE：串行化。不存在并发问题。
2) 事务的超时时间： 表示一个方法最长的执行时间，如果方法执行时超过了时间，事务就回滚。
单位是秒， 整数值， 默认是 -1.
3）事务的传播行为 ：== 控制业务方法是不是有事务的==， 是什么样的事务的。
7个传播行为，表示你的业务方法调用时，事务在方法之间是如果使用的。
PROPAGATION_REQUIRED
PROPAGATION_REQUIRES_NEW
PROPAGATION_SUPPORTS
以上三个需要掌握的
PROPAGATION_MANDATORY
PROPAGATION_NESTED
PROPAGATION_NEVER
PROPAGATION_NOT_SUPPORTED
- PROPAGATION_REQUIRED
- 指定的方法必须在事务内执行。若当前存在事务（热点），就加入到当前事务中；若当前没有事务，则创建一个新事务（自己开4G）。这种传播行为是最常见的选择，也是 Spring 默认的事务传播行为。
如该传播行为加在 doOther()方法上。若 doSome()方法在调用 doOther()方法时就是在事
务内运行的，则 doOther()方法的执行也加入到该事务内执行。若 doSome()方法在调用
doOther()方法时没有在事务内执行，则 doOther()方法会创建一个事务，并在其中执行。 - PROPAGATION_SUPPORTS
指定的方法支持当前事务，但若当前没有事务，也可以以非事务方式执行。（玩单机） - PROPAGATION_REQUIRES_NEW
总是新建一个事务，若当前存在事务，就将当前事务挂起，直到新事务执行完毕。（有热点都不用，用自己的4G）
总结一下就是：
1.有我就先拿着用，没有我就自己建
2.有我就先拿着用，没有就没有我不用
3.管你有没有，我自己建用自己的
事务提交事务，回滚事务的时机
复习一下事务
1）当你的业务方法，执行成功，没有异常抛出，当方法执行完毕，spring在方法执行后提交事务。事务管理器commit
2）当你的业务方法抛出运行时异常或ERROR， spring执行回滚，调用事务管理器的rollback
运行时异常的定义： RuntimeException 和他的子类都是运行时异常， 例如NullPointException , NumberFormatException
3) 当你的业务方法抛出非运行时异常， 主要是受查异常时，提交事务
受查异常：在你写代码中，必须处理的异常。例如IOException, SQLException
总结spring的事务
- 管理事务的是 事务管理和他的实现类
- spring的事务是一个统一模型
1）指定要使用的事务管理器实现类，使用
2）指定哪些类，哪些方法需要加入事务的功能
3）指定方法需要的隔离级别，传播行为，超时
你需要告诉spring，你的项目中类信息，方法的名称，方法的事务传播行为。
实例过程
步骤如下
ch08-spring-transaction：spring完成事务
1.新建maven项目（同之前）
2.加入maven的依赖（同之前）
1）spring依赖
2）mybatis依赖
3）mysql驱动
4）spring的事务的依赖
5）mybatis和spring集成的依赖： mybatis官方提供的，用来在spring项目中创建mybatis的SqlSessionFactory，dao对象的
3.创建实体类
Sale Goods
4.创建dao接口和mapper文件
SaleDao接口 GoodsDao接口
SaleDao.xml GoodsDao.xml
5.创建mybatis主配置文件（同之前）
6.创建Service接口和实现类，属性是saledao和goodsDao。
7.创建spring的配置文件：声明mybatis的对象交给spring创建
1）数据源DataSource（同之前）
2）SqlSessionFactory（同之前）
3) Dao对象（同之前）
4）声明自定义的service
8.创建测试类，获取Service对象，通过service调用dao完成数据库的访问
创建实体类
package BUPT.entity;
import java.math.BigDecimal;
public class Goods {
private Integer id;
private String name;
private Integer amount;
private BigDecimal price;
//后面get和set方法略
}
package BUPT.entity;
public class Sale {
private Integer id;
private Integer gid;
private Integer nums;
//get和set方法略
}
创建dao接口和mapper文件
GoodsDao接口
package BUPT.dao;
import BUPT.entity.Goods;
public interface GoodsDao {
//更新库存
//goods表示本次用户购买的商品信息， id， 购买数量
int updateGoods(Goods goods);
//查询商品的信息
Goods selectGoods(Integer id);
}
GoodsDao.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="BUPT.dao.GoodsDao">
<select id="selectGoods" resultType="BUPT.entity.Goods">
select id,name,amount,price from goods where id=#{gid}
</select>
<update id="updateGoods">
update goods set amount = amount - #{amount} where id=#{id}
</update>
</mapper>
SaleDao接口
package BUPT.dao;
import BUPT.entity.Sale;
public interface SaleDao {
//增加销售记录
int insertSale(Sale sale);
}
SaleDao.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="BUPT.dao.SaleDao">
<insert id="insertSale">
insert into sale(gid,nums) values(#{gid},#{nums})
</insert>
</mapper>
创建Service接口和实现类
package BUPT.service;
public interface BuyGoodsService {
//购买商品的方法， goodsId：购买商品的编号， nums：购买的数量
void buy(Integer goodsId, Integer nums);
}
重点
package BUPT.service;
import ...;
public class BuyGoodsServiceImpl implements BuyGoodsService {
private SaleDao saleDao;
private GoodsDao goodsDao;
@Override
public void buy(Integer goodsId, Integer nums) {
System.out.println("=====buy方法的开始====");
//记录销售信息，向sale表添加记录
Sale sale = new Sale();
sale.setGid(goodsId);
sale.setNums(nums);
saleDao.insertSale(sale);
//更新Goods表数据
//更新库存
Goods goods = goodsDao.selectGoods(goodsId);
if( goods == null){
//商品不存在
throw new NullPointerException("编号是："+goodsId+",商品不存在");
} else if( goods.getAmount() < nums){
//商品库存不足
throw new NotEnoughException("编号是："+goodsId+",商品库存不足");
}
//修改库存了
Goods buyGoods = new Goods();
buyGoods.setId( goodsId);
buyGoods.setAmount(nums);
goodsDao.updateGoods(buyGoods);
System.out.println("=====buy方法的完成====");
}
public void setSaleDao(SaleDao saleDao) {
this.saleDao = saleDao;
}
public void setGoodsDao(GoodsDao goodsDao) {
this.goodsDao = goodsDao;
}
}
4）声明自定义的service
<!--声明service-->
<bean id="buyService" class="BUPT.service.BuyGoodsServiceImpl">
<property name="goodsDao" ref="goodsDao" />
<property name="saleDao" ref="saleDao" />
</bean>
测试类
package BUPT;
import static org.junit.Assert.assertTrue;
import ...;
public class AppTest
{
@Test
public void test01(){
String config="applicationContext.xml";
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
//从容器获取service
BuyGoodsService service = (BuyGoodsService) ctx.getBean("buyService");
//调用方法
service.buy(1001,2);
}
}
另外需要补充一个异常类
package BUPT.excep;
//自定义的运行时异常
public class NotEnoughException extends RuntimeException {
public NotEnoughException() {
super();
}
public NotEnoughException(String message) {
super(message);
}
}
我们观察一下BuyGoodsServiceImpl
可以发现我们在测试类中调用buy方法，会让其先执行saleDao.insertSale(sale);中结果的更新，也就是添加了销售记录
然后判断是否有异常
异常有两种情况，一个是商品不存在，另一个是库存不足
如果没有异常，皆大欢喜，再后面对库存进行修改进行
但如果有异常，我们insert销售记录还是执行了，而库存是没有执行的。
当然，我们可以把insert放到判断异常的后面，但我们想的是他俩一荣俱荣，一损俱损，能否不改变位置，让他们做到这一点呢？
可以使用我们的事务来实现他。
spring框架中提供的事务处理方案
1.适合中小项目使用的， 注解方案。
spring框架自己用aop实现给业务方法增加事务的功能， 使用@Transactional注解增加事务。
@Transactional注解是spring框架自己注解，放在public方法的上面，表示当前方法具有事务。
可以给注解的属性赋值，表示具体的隔离级别，传播行为，异常信息等等
使用@Transactional的步骤
1.需要声明事务管理器对象
<bean id="xx" class="DataSourceTransactionManager">
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--连接的数据库， 指定数据源-->
<property name="dataSource" ref="myDataSource" />
</bean>
2.开启事务注解驱动， 告诉spring框架，我要使用注解的方式管理事务。
spring使用aop机制，创建@Transactional所在的类代理对象，给方法加入事务的功能。
spring给业务方法加入事务：
在你的业务方法执行之前，先开启事务，在业务方法之后提交或回滚事务，
就像捕获异常的try catch
使用aop的环绕通知
@Around("你要增加的事务功能的业务方法名称")
Object myAround(){
开启事务，spring给你开启
try{
buy(1001,10);
spring的事务管理器.commit();
}catch(Exception e){
spring的事务管理器.rollback();
}
}
环绕通知由spring内部完成，所以我们没有手动写这一段
<!--2. 开启事务注解驱动，告诉spring使用注解管理事务，创建代理对象
transaction-manager:事务管理器对象的id
tx:annotation选择这一个包
http://www.springframework.org/schema/tx/spring-tx.xsd
-->
<tx:annotation-driven transaction-manager="transactionManager" />
3.在方法的上面加入@Trancational
所以我们在BuyGoodsServiceImpl中添加
@Transactional(
propagation = Propagation.REQUIRED,
//隔离级别选默认
isolation = Isolation.DEFAULT,
//不是只读
readOnly= false,
//发生指定异常回滚
rollbackFor = {
NullPointerException.class,
NotEnoughException.class
}
)
//这里也可以简单写@Transactional 因为默认的就是上面所选择的这几个
@Override
public void buy(Integer goodsId, Integer nums) {
...
}
此时我们测试，没异常正常更新，有异常事务涉及的两个表都不更新
但并不是说没有痕迹，只是先添加了销售表记录，后由于报异常，撤销了刚才的操作
2.使用aspectj框架功能，在spring配置文件中
适合大型项目，有很多的类，方法，需要大量的配置事务，
声明类，方法需要的事务。这种方式业务方法和事务配置完全分离。
实现步骤： 都是在xml配置文件中实现。
1)要使用的是aspectj框架，需要加入依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
2）声明事务管理器对象
(这一步和注解方式一样)
<!-- 声明事务管理器对象-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="myDataSource"/>
</bean>
- 声明方法需要的事务类型（配置方法的事务属性【隔离级别，传播行为，超时】）
<!--2.声明业务方法它的事务属性（隔离级别，传播行为，超时时间）
id:自定义名称，表示 <tx:advice> 和 </tx:advice>之间的配置内容的
transaction-manager:事务管理器对象的id
-->
<tx:advice id="myAdvice" transaction-manager="transactionManager">
<!--tx:attributes：配置事务属性-->
<tx:attributes>
<!--tx:method：给具体的方法配置事务属性，method可以有多个，分别给不同的方法设置事务属性
name:方法名称，1）完整的方法名称，不带有包和类。
2）方法可以使用通配符,* 表示任意字符
propagation：传播行为，枚举值
isolation：隔离级别
rollback-for：你指定的异常类名，全限定类名。 发生异常一定回滚
完全匹配优先于部分匹配优先于全通配符
-->
<!--如何确定这个buy是哪个buy，是通过配置aop来决定的-->
<tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT"
rollback-for="java.lang.NullPointerException,BUPT.excep.NotEnoughException"/>
<!--下面几个方法我没有写但是作为示例-->
<!--使用通配符，指定很多的方法-->
<tx:method name="add*" propagation="REQUIRES_NEW"/>
<!--指定修改方法-->
<tx:method name="modify*"/>
<!--删除方法-->
<tx:method name="remove*"/>
<!--查询方法，query，search，find-->
<tx:method name="*" propagation="SUPPORTS" read-only="true"/>
</tx:attributes>
</tx:advice>
- 配置aop：指定哪些哪类要创建代理。
<!--配置aop-->
<aop:config>
<!--配置切入点表达式：指定哪些包中类，要使用事务
id:切入点表达式的名称，唯一值
expression：切入点表达式，指定哪些类要使用事务，aspectj会创建代理对象
-->
<aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>
<!--配置增强器：关联adivce和pointcut
advice-ref:通知，上面tx:advice那里的配置
pointcut-ref：切入点表达式的id
建立起了对应关系
-->
<aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt"/>
</aop:config>
效果和上面用注解是一模一样的
结束时间：2022-01-15
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
