文章目录
1.事务的回顾
1)什么事务
事务:逻辑上的一-组操作,组成这组操作的各个单元,要么全都成功,要么全都失败。
2)事务的特性
原子性:事务不可分割
一致性: 事务执行前后数据完整性保持-致
隔离性:一个事务的执行不应该受到其他事务的干扰
持久性: - -旦事务结束,数据就持久化到数据库
3)如果不考虑隔离性引发安全性问题
读问题.
- 脏读:一个事务读到另一个事务未提交的数据
- 不可重复读:一个事务读到另一个事务已经提交的update的数据,导致一个事务中多次查询结果不一致
- 虚读、幻读:一个事务读到另一个事务已经提交的insert的数据,导致一个事务中多次查询结果不一致
写问题
丢失更新(锁机制:悲观锁、乐观锁)
4)解决读问题
设置事务的隔离级别
Read uncommitted ::未提交读,任何读问题解决不了。
Read committed :已提交读,解决脏读,但是不可重复读和虚读有可能发生。
Repeatable read:重复读,解决脏读和不可重复读,但是虚读有可能发生。(MySQL默认)
Serializable :解决所有读问题。
2.Spring的事务管理的API
PlatformTransactionManager:平台事务管理器
平台事务管理器:接口,是Spring用 于管理事务的真正的对象。
DataSourceTransacti onManager :底层使用JDBC管理事务
HibernateTransact ionManager :底层使用Hibernate管理事务
TransactionDefinition :事务定义信息
事务定义:用于定义事务的相关的信息,隔离级别、超时信息、传播行为、是否只读
I
TransactionStatus:事务的状态
I事务状态: 用于记录在事务管理过程中, 事务的状态的对象。
3.事务管理的API的关系
Spring进行事务管理的时候,首先平台事务管理器根据事务定义信息进行事务的管理,在事务管理过程中,产生各种状态,将这些状态的信息记录到事务状态的对象中。
4.Spring的事务的传播行为
Spring的传播行为
Spring中提供了七种事务的传播行为:
保证多个操作在同一个事务中
PROPAGATION REOUIRED :默认值,如果A中有事务,使用A中的事务,如果A没有,创建一个新的事务,将操作包含进来
PROPAGATION SUPPORTS :支持事务,如果A中有事务,使用A中的事务。如果A没有事务,不使用事务。
PROPAGATION MANDATORY :如果A中有事务,使用A中的事务。如果A没有事务,抛出异常。
保证多个操作不在同一个事务中,
PROPAGATION REOUIRES NEW :如果A中有事务,将A的事务挂起(暂停),创建新事务,只包含自身操作。如果A中没有事务,创建-一个新事务,包含自身操作。
PROPAGATION NOT SUPPORTED :如果A中有事务,将A的事务挂起。不使用事务管理。
PROPAGATION NEVER :如果A中有事务,报异常。
嵌套式事务
PROPAGATION NESTED :嵌套事务,如果A中有事务,按照A的事务执行,执行完成
后,设置一个保存点,执行B中的操作,如果没有异常,执行通过,如果有异常,可以
选择回滚到最初始位置,也可以回滚到保存点。
5.Spring的事务管理(银行转账演示)
场景:
A给B转账,需要A的账户,B的账户已经转账金额,当A账户扣钱成功且B账户加钱成功,说明转账成功,其余情况转账失败。只有成功的情况下才会将数据写入数据库。
public class UserServiceImpl implements UserService{
UserDao userDao = new UserDao();
@Override
public String aToB(String aname,String bname,int money) {
//参数校验
if(StringUtils.isEmpty(aname)||StringUtils.isEmpty((bname))){
return "转账用户不能为空";
}
if(money<=0){
return "转账金额不能小于0";
}
//转账
//1.a扣钱
int a = userDao.updateByUnameAndMoneySub(aname,money);
//2.b加钱
int b = userDao.updateByUnameAndMoneyAdd(bname,money);
return a>0&&b>0?"转账成功":"转账失败";
}
}
public class UserDao {
public int updateByUnameAndMoneySub(String uname,int money){
//创建spring核心容器
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
JdbcTemplate jdt = (JdbcTemplate) ac.getBean("jdbcTemplate");
//扣钱
String sql = "UPDATE users SET money=money-? WHERE name=? ";
int a = jdt.update(sql, money,uname);
return a;
}
public int updateByUnameAndMoneyAdd(String uname,int money){
//创建spring核心容器
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
JdbcTemplate jdt = (JdbcTemplate) ac.getBean("jdbcTemplate");
//加钱
String sql = "UPDATE users SET money=money+? WHERE name=? ";
int a = jdt.update(sql, money,uname);
return a;
}
}
6. Spring的事务管理:
一类:编程式事务(需要手动编写代码) -了解
引入新的约束:
package com.xhl.dao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
public class UserDao {
JdbcTemplate jdt;
public JdbcTemplate getJdt() {
return jdt;
}
public void setJdt(JdbcTemplate jdt) {
this.jdt = jdt;
}
public int updateByUnameAndMoneySub(String uname, int money){
//扣钱
String sql = "UPDATE users SET money=money-? WHERE name=? ";
int a = jdt.update(sql, money,uname);
return a;
}
public int updateByUnameAndMoneyAdd(String uname,int money){
//加钱
String sql = "UPDATE users SET money=money+? WHERE name=? ";
int a = jdt.update(sql, money,uname);
return a;
}
}
<?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:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.2.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">
<context:property-placeholder location="classpath:db.properties"/>
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 管理业务层-->
<bean id="userService" class="com.xhl.service.UserServiceImpl">
<property name="userDao" ref="userDao"/>
<property name="template" ref="transactionTemplate"/>
</bean>
<!-- 管理数据层-->
<bean id="userDao" class="com.xhl.dao.UserDao">
<property name="jdt" ref="jdbcTemplate"/>
</bean>
<!-- 平台事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置事务管理的模板-->
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
<property name="transactionManager" ref="transactionManager"/>
</bean>
</beans>
package com.xhl.service;
import com.xhl.dao.UserDao;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;
import org.springframework.util.StringUtils;
public class UserServiceImpl implements UserService{
private UserDao userDao;
public UserDao getUserDao() {
return userDao;
}
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
// 注入平台事务管理模板
private TransactionTemplate template;
public TransactionTemplate getTemplate() {
return template;
}
public void setTemplate(TransactionTemplate template) {
this.template = template;
}
static String msg = "";
@Override
public String aToB(String aname,String bname,int money) {
template.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
//参数校验
if(StringUtils.isEmpty(aname)||StringUtils.isEmpty((bname))){
msg= "转账用户不能为空";
}
if(money<=0){
msg="转账金额不能小于0";
}
//转账
//1.a扣钱
int a = userDao.updateByUnameAndMoneySub(aname,money);
// 人为异常(执行到这一步出现异常后会回滚之前的操作
int x = 1/0;
//2.b加钱
int b = userDao.updateByUnameAndMoneyAdd(bname,money);
msg= a>0&&b>0?"转账成功":"转账失败";
}
});
return msg;
}
}
@Test
public void test1(){
//创建spring核心容器
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
String aname = "a用户",bname = "b用户";
int money = 10;
UserService userService = ac.getBean("userService",UserServiceImpl.class);
String s = userService.aToB(aname,bname,money);
System.out.println(s);
}
7. Spring的事务管理:
二类:声明式事务管理(通过配置实现) _ AOP
XML方式的声明式事务管理
第一步:引入aop的开发包(用maven的工程,直接导入坐标)
第二步:恢复转账环境
第三步:配置事务管理器‘
<!-- 使用AOP的事务-->
<tx:advice id="interceptor" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="aToBByAOP" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!-- 配置AOP,这里相当于把事务增强的通知放入到切入点中,即给需要增强的类下的方法通知-->
<aop:config>
<aop:pointcut id="p1" expression="execution(* com.xhl.service.UserService.aToBByAOP(..))"/>
<aop:advisor advice-ref="interceptor" pointcut-ref="p1"/>
</aop:config>
// 声明式事务处理
@Override
public String aToBByAOP(String aname, String bname, int money) {
//参数校验
if(StringUtils.isEmpty(aname)||StringUtils.isEmpty((bname))){
return "转账用户不能为空";
}
if(money<=0){
return "转账金额不能小于0";
}
//转账
//1.a扣钱
int a = userDao.updateByUnameAndMoneySub(aname,money);
// 人为异常
int x = 1/0;
//2.b加钱
int b = userDao.updateByUnameAndMoneyAdd(bname,money);
return a>0&&b>0?"转账成功":"转账失败";
}
注解方式的声明式事务管理
第一步:引入aop的开发包
第二步:恢复转账环境
第三步:配置事务管理器