Spring事务

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的开发包
第二步:恢复转账环境
第三步:配置事务管理器