事务基本概念

这几天看了一下事务，总结了一下东西：
事务：正确执行一系列操作，使得数据库从一种状态转换为另一种状态，要么全部成功，要么全部失败。
原子性（Atomicity）：不可分割，要么全部执行，要么全部不执行。
一致性(Consistency)：事务得执行使得数据库从一种状态转换为另一种状态。
隔离性(Isolation)：在正确事务提交之前，它可能得结果不显示给任何其他事务。
持久性(Durability)：事务提交以后，其结果永久保存在数据库中。

1.Java事务
Java事务产生：
程序操作数据库得需要。在Java编写得程序中，实现ACID得操作。
Java事务实现范围：
通过jdbc相应得方法间接来实现数据库得增删改查，把事务转移到Java代码中进行控制。
确保事务要么全部执行成功，要么撤销不执行。
总结：Java操着数据库得ACID实例。
java事务得实现：
通过Java代码来实现对数据库得事务性操作。
Java事务类型

三种事务：
JDBC事务：用Connection对象控制，包括手动模式和自动模式。
JTA事务：与实现无关，与协议无关得API。
容器事务：应用服务器提供得，且大多是基于JTA完成。
差异：
JDBC事务：控制得局限性在一个数据库连接内，但是是简单使用
JTA事务：功能强大，课跨越多个数据库或者多DAO，使用比较复杂。
容器事务：主要是指J2EE应用服务器提供得事务管理，局限于EJB（企业JavaBean）
2.spring事务核心

Spring事务属性
1.传播行为、隔离规则、是否只读、事务超时、回滚规则

数据读取类型说明
1.脏读：
main(){
Connection con = null;
Savepoint savepoint = null;
try{
con = getConnection();
con.setAutoCommit(false);
doSomeThingA();
savepoint = con2.setSavepoint();
try{
methodB();
} catch(RuntimeException ex) {
con.rollback(savepoint);
} finally {
//释放资源
}
doSomeThingB();
con.commit();
} catch(RuntimeException ex) {
con.rollback();
} finally {
//释放资源
}
}

不可重复读与幻读的区别
不可重复读的重点是修改:
同样的条件, 你读取过的数据, 再次读取出来发现值不一样了
例如：在事务1中，Mary 读取了自己的工资为1000,操作并没有完成
con1 = getConnection();
select salary from employee empId =“Mary”;
1
2
在事务2中，这时财务人员修改了Mary的工资为2000,并提交了事务.
con2 = getConnection();
update employee set salary = 2000;
con2.commit();
1
2
3
在事务1中，Mary 再次读取自己的工资时，工资变为了2000
//con1
select salary from employee empId =“Mary”;
1
2
在一个事务中前后两次读取的结果并不一致，导致了不可重复读。
幻读的重点在于新增或者删除：
同样的条件, 第1次和第2次读出来的记录数不一样
例如：目前工资为1000的员工有10人。事务1,读取所有工资为1000的员工。
con1 = getConnection();
Select * from employee where salary =1000;
1
2
共读取10条记录
这时另一个事务向employee表插入了一条员工记录，工资也为1000
con2 = getConnection();
Insert into employee(empId,salary) values(“Lili”,1000);
con2.commit();
1
2
3
事务1再次读取所有工资为1000的员工
//con1
select * from employee where salary =1000;
1
2
共读取到了11条记录，这就产生了幻像读。
从总的结果来看, 似乎不可重复读和幻读都表现为两次读取的结果不一致。但如果你从控制的角度来看, 两者的区别就比较大。
对于前者, 只需要锁住满足条件的记录。
对于后者, 要锁住满足条件及其相近的记录。

事务没提交，提前读取；
2.不可重复读：
一个事物两次读取得数据不一样；

3.幻读：
事务不是独立执行时发生得一种非预期现象

事务隔离级别
隔离级别定义了一个事务可能受其他并发事务影响程度。

未授权读取
也称为读未提交（Read Uncommitted）：允许脏读取，但不允许更新丢失。如果一个事务已经开始写数据，则另外一个事务则不允许同时进行写操作，但允许其他事务读此行数据。该隔离级别可以通过“排他写锁”实现。
授权读取
也称为读提交（Read Committed）：允许不可重复读取，但不允许脏读取。这可以通过“瞬间共享读锁”和“排他写锁”实现。读取数据的事务允许其他事务继续访问该行数据，但是未提交的写事务将会禁止其他事务访问该行。
可重复读取（Repeatable Read）
可重复读取（Repeatable Read）：禁止不可重复读取和脏读取，但是有时可能出现幻读数据。这可以通过“共享读锁”和“排他写锁”实现。读取数据的事务将会禁止写事务（但允许读事务），写事务则禁止任何其他事务。
序列化（Serializable）
序列化（Serializable）：提供严格的事务隔离。它要求事务序列化执行，事务只能一个接着一个地执行，不能并发执行。仅仅通过“行级锁”是无法实现事务序列化的，必须通过其他机制保证新插入的数据不会被刚执行查询操作的事务访问到。
隔离级别越高，越能保证数据的完整性和一致性，但是对并发性能的影响也越大。对于多数应用程序，可以优先考虑把数据库系统的隔离级别设为Read Committed。它能够避免脏读取，而且具有较好的并发性能。尽管它会导致不可重复读、幻读和第二类丢失更新这些并发问题，在可能出现这类问题的个别场合，可以由应用程序采用悲观锁或乐观锁来控制。

事务传播行为
当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。
事务传播行为类型 说明
PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。
PROPAGATION_SUPPORTS 支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY 使用当前的事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW 新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER 以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。
事务是否只读属性：
利用数据库事务得“只读”属性，进行特定得优化处理。
设置"只读属性"注意：
事务得是否“只读”属性，不同得数据库厂商支持不同。
通常而言：只读属性得应用要参考厂商得具体说明，
Orcle得“readOnly” 不起作用，不影响其增删改查；
Mysql得“readOnly”为true只能查，增删改则出异常。

事务超时：
事务超时就是事务得一个定时器，在特定时间内事务如果没有执行完，那么就会自动回滚，而不是一直等待回滚。

设计事务时注意点：
为了使应用程序很好得运行，事务不能运行太长时间，因为事务可能涉及对后端数据库得锁定，所以长时间得事务会占用不必要得资源。

事务回滚：
默认情况下，事务只有运行期异常回滚，而遇检查期不会回滚。
自定义回滚策略：
声明事务在遇到特定得检查型异常时像遇到运行期异常那样回滚；
声明事务遇到特定得异常不回滚，即使这些异常时运行期异常；

Spring事务状态
事务接口：

通过事务管理器获取TransactionStatus实例；
控制事务在回滚或提交得时候需要用相应得得事务状态；
Spring事务接口：

3.编程式事务管理
编程式事务实现方式：
事务管理器（PlatformTransationManager）方式：
类似应用JTA UserTransation API方式，但异常处理更加简洁；
核心类：Spring事务管理得三个接口类以及jdbcTemplate
模板事务（TransationTemplate）方式：
为此Spring官方推荐
用工具jdbcTemplate

事务管理器案例：
-步骤:获取事务管理器;创建事务属性对象;
获取事务状态对象;创建JDBC模板对象;业务数据操作处理。

（实例来自https://www.cnblogs.com/yixianyixian/p/8372832.html）
DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager(); //定义一个某个框架平台的TransactionManager，如JDBC、Hibernate
dataSourceTransactionManager.setDataSource(this.getJdbcTemplate().getDataSource()); // 设置数据源
DefaultTransactionDefinition transDef = new DefaultTransactionDefinition(); // 定义事务属性
transDef.setPropagationBehavior(DefaultTransactionDefinition.PROPAGATION_REQUIRED); // 设置传播行为属性
TransactionStatus status = dataSourceTransactionManager.getTransaction(transDef); // 获得事务状态
try {
// 数据库操作
dataSourceTransactionManager.commit(status);// 提交
} catch (Exception e) {
dataSourceTransactionManager.rollback(status);// 回滚

4.声明式事务管理
配置类型：
5种类型

<?xml version="1.0" encoding="UTF-8"?>

<bean id="sessionFactory" 
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
    <property name="configLocation" value="classpath:hibernate.cfg.xml" /> 
    <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
</bean> 

<!-- 定义事务管理器（声明式的事务） --> 
<bean id="transactionManager"
    class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory" />
</bean>

<!-- 配置DAO -->
<bean id="userDaoTarget" class="com.bluesky.spring.dao.UserDaoImpl">
    <property name="sessionFactory" ref="sessionFactory" />
</bean>

<bean id="userDao" 
    class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> 
       <!-- 配置事务管理器 --> 
       <property name="transactionManager" ref="transactionManager" />    
    <property name="target" ref="userDaoTarget" /> 
     <property name="proxyInterfaces" value="com.bluesky.spring.dao.GeneratorDao" />
    <!-- 配置事务属性 --> 
    <property name="transactionAttributes"> 
        <props> 
            <prop key="*">PROPAGATION_REQUIRED</prop>
        </props> 
    </property> 
</bean> 

（2）所有Bean共享一个代理基类

<?xml version="1.0" encoding="UTF-8"?>

<bean id="sessionFactory" 
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
    <property name="configLocation" value="classpath:hibernate.cfg.xml" /> 
    <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
</bean> 

<!-- 定义事务管理器（声明式的事务） --> 
<bean id="transactionManager"
    class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory" />
</bean>

<bean id="transactionBase" 
        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" 
        lazy-init="true" abstract="true"> 
    <!-- 配置事务管理器 --> 
    <property name="transactionManager" ref="transactionManager" /> 
    <!-- 配置事务属性 --> 
    <property name="transactionAttributes"> 
        <props> 
            <prop key="*">PROPAGATION_REQUIRED</prop> 
        </props> 
    </property> 
</bean>   

<!-- 配置DAO -->
<bean id="userDaoTarget" class="com.bluesky.spring.dao.UserDaoImpl">
    <property name="sessionFactory" ref="sessionFactory" />
</bean>

<bean id="userDao" parent="transactionBase" > 
    <property name="target" ref="userDaoTarget" />  
</bean>

（3）使用拦截器

<?xml version="1.0" encoding="UTF-8"?>

<bean id="sessionFactory" 
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
    <property name="configLocation" value="classpath:hibernate.cfg.xml" /> 
    <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
</bean> 

<!-- 定义事务管理器（声明式的事务） --> 
<bean id="transactionManager"
    class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory" />
</bean> 

<bean id="transactionInterceptor" 
    class="org.springframework.transaction.interceptor.TransactionInterceptor"> 
    <property name="transactionManager" ref="transactionManager" /> 
    <!-- 配置事务属性 --> 
    <property name="transactionAttributes"> 
        <props> 
            <prop key="*">PROPAGATION_REQUIRED</prop> 
        </props> 
    </property> 
</bean>

<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> 
    <property name="beanNames"> 
        <list> 
            <value>*Dao</value>
        </list> 
    </property> 
    <property name="interceptorNames"> 
        <list> 
            <value>transactionInterceptor</value> 
        </list> 
    </property> 
</bean> 

<!-- 配置DAO -->
<bean id="userDao" class="com.bluesky.spring.dao.UserDaoImpl">
    <property name="sessionFactory" ref="sessionFactory" />
</bean>

使用tx标签配置的拦截器

<?xml version="1.0" encoding="UTF-8"?>

<context:annotation-config />
<context:component-scan base-package="com.bluesky" />

<bean id="sessionFactory" 
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
    <property name="configLocation" value="classpath:hibernate.cfg.xml" /> 
    <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
</bean> 

<!-- 定义事务管理器（声明式的事务） --> 
<bean id="transactionManager"
    class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory" />
</bean>

<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="*" propagation="REQUIRED" />
    </tx:attributes>
</tx:advice>

<aop:config>
    <aop:pointcut id="interceptorPointCuts"
        expression="execution(* com.bluesky.spring.dao.*.*(..))" />
    <aop:advisor advice-ref="txAdvice"
        pointcut-ref="interceptorPointCuts" />       
</aop:config>     

（5）全注解

<?xml version="1.0" encoding="UTF-8"?>

<context:annotation-config />
<context:component-scan base-package="com.bluesky" />

<tx:annotation-driven transaction-manager="transactionManager"/>

<bean id="sessionFactory" 
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
    <property name="configLocation" value="classpath:hibernate.cfg.xml" /> 
    <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
</bean> 

<!-- 定义事务管理器（声明式的事务） --> 
<bean id="transactionManager"
    class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory" />
</bean>

此时在DAO上需加上@Transactional注解，如下：
package com.bluesky.spring.dao;

import java.util.List;

import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Component;

import com.bluesky.spring.domain.User;

@Transactional
@Component(“userDao”)
public class UserDaoImpl extends HibernateDaoSupport implements UserDao {

public List<User> listUsers() {
    return this.getSession().createQuery("from User").list();
}  

}

5.事务最佳实践

首先是数据库表
book(isbn, book_name, price)
account(username, balance)
book_stock(isbn, stock)
然后是XML配置

<import resource="applicationContext-db.xml" />

<context:component-scan
    base-package="com.springinaction.transaction">
</context:component-scan>

<tx:annotation-driven transaction-manager="txManager"/>

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

使用的类
BookShopDao
package com.springinaction.transaction;

public interface BookShopDao {
// 根据书号获取书的单价
public int findBookPriceByIsbn(String isbn);
// 更新书的库存，使书号对应的库存-1
public void updateBookStock(String isbn);
// 更新用户的账户余额：account的balance-price
public void updateUserAccount(String username, int price);
}

BookShopDaoImpl
package com.springinaction.transaction;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository(“bookShopDao”)
public class BookShopDaoImpl implements BookShopDao {

@Autowired
private JdbcTemplate JdbcTemplate;

@Override
public int findBookPriceByIsbn(String isbn) {
    String sql = "SELECT price FROM book WHERE isbn = ?";

    return JdbcTemplate.queryForObject(sql, Integer.class, isbn);
}

@Override
public void updateBookStock(String isbn) {
    //检查书的库存是否足够，若不够，则抛出异常
    String sql2 = "SELECT stock FROM book_stock WHERE isbn = ?";
    int stock = JdbcTemplate.queryForObject(sql2, Integer.class, isbn);
    if (stock == 0) {
        throw new BookStockException("库存不足！");
    }
    String sql = "UPDATE book_stock SET stock = stock - 1 WHERE isbn = ?";
    JdbcTemplate.update(sql, isbn);
}

@Override
public void updateUserAccount(String username, int price) {
    //检查余额是否不足，若不足，则抛出异常
    String sql2 = "SELECT balance FROM account WHERE username = ?";
    int balance = JdbcTemplate.queryForObject(sql2, Integer.class, username);
    if (balance < price) {
        throw new UserAccountException("余额不足！");
    }       
    String sql = "UPDATE account SET balance = balance - ? WHERE username = ?";
    JdbcTemplate.update(sql, price, username);
}

}

BookShopService
package com.springinaction.transaction;
public interface BookShopService {
public void purchase(String username, String isbn);
}

BookShopServiceImpl
package com.springinaction.transaction;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service(“bookShopService”)
public class BookShopServiceImpl implements BookShopService {

@Autowired
private BookShopDao bookShopDao;

/**
 * 1.添加事务注解
 * 使用propagation 指定事务的传播行为，即当前的事务方法被另外一个事务方法调用时如何使用事务。
 * 默认取值为REQUIRED，即使用调用方法的事务
 * REQUIRES_NEW：使用自己的事务，调用的事务方法的事务被挂起。
 *
 * 2.使用isolation 指定事务的隔离级别，最常用的取值为READ_COMMITTED
 * 3.默认情况下 Spring 的声明式事务对所有的运行时异常进行回滚，也可以通过对应的属性进行设置。通常情况下，默认值即可。
 * 4.使用readOnly 指定事务是否为只读。 表示这个事务只读取数据但不更新数据，这样可以帮助数据库引擎优化事务。若真的是一个只读取数据库值得方法，应设置readOnly=true
 * 5.使用timeOut 指定强制回滚之前事务可以占用的时间。
 */
@Transactional(propagation=Propagation.REQUIRES_NEW,
        isolation=Isolation.READ_COMMITTED,
        noRollbackFor={UserAccountException.class},
        readOnly=true, timeout=3)
@Override
public void purchase(String username, String isbn) {
    //1.获取书的单价
    int price = bookShopDao.findBookPriceByIsbn(isbn);
    //2.更新书的库存
    bookShopDao.updateBookStock(isbn);
    //3.更新用户余额
    bookShopDao.updateUserAccount(username, price);
}

Cashier
package com.springinaction.transaction;
import java.util.List;
public interface Cashier {
public void checkout(String username, Listisbns);
}

CashierImpl：CashierImpl.checkout和bookShopService.purchase联合测试了事务的传播行为
package com.springinaction.transaction;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service(“cashier”)
public class CashierImpl implements Cashier {
@Autowired
private BookShopService bookShopService;

@Transactional
@Override
public void checkout(String username, List<String> isbns) {
    for(String isbn : isbns) {
        bookShopService.purchase(username, isbn);
    }
}

}

BookStockException

package com.springinaction.transaction;
public class BookStockException extends RuntimeException {

private static final long serialVersionUID = 1L;

public BookStockException() {
    super();
    // TODO Auto-generated constructor stub
}

public BookStockException(String arg0, Throwable arg1, boolean arg2,
        boolean arg3) {
    super(arg0, arg1, arg2, arg3);
    // TODO Auto-generated constructor stub
}

public BookStockException(String arg0, Throwable arg1) {
    super(arg0, arg1);
    // TODO Auto-generated constructor stub
}

public BookStockException(String arg0) {
    super(arg0);
    // TODO Auto-generated constructor stub
}

public BookStockException(Throwable arg0) {
    super(arg0);
    // TODO Auto-generated constructor stub
}

}

UserAccountException
package com.springinaction.transaction;
public class UserAccountException extends RuntimeException {

private static final long serialVersionUID = 1L;

public UserAccountException() {
    super();
    // TODO Auto-generated constructor stub
}

public UserAccountException(String arg0, Throwable arg1, boolean arg2,
        boolean arg3) {
    super(arg0, arg1, arg2, arg3);
    // TODO Auto-generated constructor stub
}

public UserAccountException(String arg0, Throwable arg1) {
    super(arg0, arg1);
    // TODO Auto-generated constructor stub
}

public UserAccountException(String arg0) {
    super(arg0);
    // TODO Auto-generated constructor stub
}

public UserAccountException(Throwable arg0) {
    super(arg0);
    // TODO Auto-generated constructor stub
}

}

测试类
package com.springinaction.transaction;

import java.util.Arrays;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTransitionTest {

private ApplicationContext ctx = null;
private BookShopDao bookShopDao = null;
private BookShopService bookShopService = null;
private Cashier cashier = null;
{
    ctx = new ClassPathXmlApplicationContext("config/transaction.xml");
    bookShopDao = ctx.getBean(BookShopDao.class);
    bookShopService = ctx.getBean(BookShopService.class);
    cashier = ctx.getBean(Cashier.class);
}

@Test
public void testBookShopDaoFindPriceByIsbn() {
    System.out.println(bookShopDao.findBookPriceByIsbn("1001"));
}

@Test
public void testBookShopDaoUpdateBookStock(){
    bookShopDao.updateBookStock("1001");
}

@Test
public void testBookShopDaoUpdateUserAccount(){
    bookShopDao.updateUserAccount("AA", 100);
}
@Test
public void testBookShopService(){
    bookShopService.purchase("AA", "1001");
}

@Test
public void testTransactionPropagation(){
    cashier.checkout("AA", Arrays.asList("1001", "1002"));
}

}

完整请见（实例来自https://www.cnblogs.com/yixianyixian/p/8372832.html）
注：
代码我是参考以上大佬的