一、事务
 
事务就是一件事情。
 
1、事务是一个整体，要么做完，要么一点不做，即具有原子性。
 
2、事务执行的结果是从一个一致性状态变为另一一致性状态。事务执行完成后，事务处于一个一致性状态，若执行中途发生故障，事务被迫中断，这时称数据库处于不一致状态。
 
3、一个事务的执行不能被其他事务打扰。事务隔离级别（Transaction Isolation Level）如下：
 
 
 
    READ_UNCOMMITTED;
 
 
    READ_COMMITTED;
 
 
    REPEATABLE_READ;
 
 
    SERIALIZABLE;
 
 
        
 
4、持续性也称持久性，即一个事务提交后对数据库的改变是永久性的，后面的其他操作不应对其执行结果产生影响，比如事务A对数据库进行了操作，然后事务B做了其他操作，事务B的结果只能影响数据库，而不应该影响事务A的结果，不能因为B而使A的结果产生变化。
 
原子性是基础，隔离性是手段，持久性是目的。
 
 
 
二、数据在高并发下的问题
 
1、Dirty Read
 
事务A读取了事务B未提交的数据，并在其基础上又做了其他操作。
 
2、Unrepeatable Read
 
事务A读取了事务B已提交的更改数据。
 
3、Phantom Read
 
事务A读取了事务B已提交的新增数据。
                                                    
转载于:https://my.oschina.net/LinuxDaxingxing/blog/727547

数据库中的事务：

要么都成功，要么都失败

ACID原则

原子性:要么全部完成，要么都不完成

-致性:总数不变

隔离性:多个进程互不干扰

持久性: -旦提交不可逆，持久化到数据库了



隔离性的问题:

脏读: -个事务读取了另一个没有提交的事务

不可重复读:在同一个事务内，重复读取表中的数据，表数据发生了改变

虚读(幻读) :在一个事务内，读取到了别人插入的数据，导致前后读出来结果不一致

代码实现

1.开启事务 connection. setAutocommit(false);//关闭数据库的自动提交，自动开启事务。

2. 一组业务执行完毕，提交事务

3.可以在catch 语句中显示的定义回滚语句，但默认失败就会回滚

**四大特性：**原子性、一致性、隔离性、持久性；

隔离性的隔离级别：

读未提交（read uncommitted）：

读未提交是指，一个事务还没提交时，它做的变更就能被别的事务看到。
读提交（read committed）：

读提交是指，一个事务提交之后，它做的变更才会被其他事务看到。
可重复读（repeatable read）：

可重复读是指，一个事务执行过程中看到的数据，总是跟这个事务在启动时看到的数据是一 致的。当然在可重复读隔离级别下，未提交变更对其他事务也是不可见的。
串行化（serializable ）：

串行化，顾名思义是对于同一行记录，“写”会加“写锁”，“读”会加“读锁”。当出现读写锁冲突 的时候，后访问的事务必须等前一个事务执行完成，才能继续执行。

以下举个例子方便理解这几种隔离级别：

假设数据表T中 只有一列，其中一行的值为1，下面是按照时间顺序执行两个事务的行为。

mysql> create table T(c int) engine=InnoDB;
 insert into T(c) values(1);



看看在不同的隔离级别下，事务A会有哪些不同的返回结果，也就是图里面V1、V2、V3 的返回值分别是什么。


若隔离级别是“读未提交”， 则V1的值就是2。这时候事务B虽然还没有提交，但是结果已经被 A看到了。因此，V2、V3也都是2。


若隔离级别是“读提交”，则V1是1，V2的值是2。事务B的更新在提交后才能被A看到。所以， V3的值也是2。


若隔离级别是“可重复读”，则V1、V2是1，V3是2。之所以V2还是1，遵循的就是这个要求： 事务在执行期间看到的数据前后必须是一致的。


若隔离级别是“串行化”，则在事务B执行“将1改成2”的时候，会被锁住。直到事务A提交后， 事务B才可以继续执行。所以从A的角度看， V1、V2值是1，V3的值是2。
由于Oracle数据库的默认隔离级别其 实就是“读提交”，因此对于一些从Oracle迁移到MySQL的应用，为保证数据库隔离级别的一致， 你一定要记得将MySQL的隔离级别设置为“读提交”。

查看mysql数据库当前的隔离级别：


mysql> show variables like 'transaction_isolation';

文章目录
1.事务的回顾
1)什么事务
2)事务的特性
3)如果不考虑隔离性引发安全性问题
4)解决读问题
2.Spring的事务管理的API
3.事务管理的API的关系
4.Spring的事务的传播行为
5.Spring的事务管理(银行转账演示)
6. Spring的事务管理:
7. 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的开发包

第二步:恢复转账环境

第三步:配置事务管理器