Spring框架学习六：Spring对JDBC的支持

JdbcTemplate简介

为了使JDBC更加易于使用，Spring 在 JDBC API 上定义了一个抽象层，以此建立一个 JDBC 存取框架

作为 Spring JDBC 框架的核心，JDBC 模板的设计目的是为不同类型的 JDBC 操作提供模板方法。每个模板方法都能控制整个过程，并允许覆盖过程中的特定任务。通过这种方式，可以在尽可能保留灵活性的情况下，将数据库存取工作量降到最低。

 

在test Schema下创建一张名为 user 的表，表结构如下

 

#添加c3p0数据库连接池
jdbc.user=root
jdbc.password=000
jdbc.jdbcUrl=jdbc:mysql:///test
jdbc.driverClass=com.mysql.jdbc.Driver

jdbc.initPoolSize=5
jdbc.maxPoolSize=10

    <!-- 导入资源文件 -->
    <context:property-placeholder location="classpath:db.properties"/>
    
    <!-- 配置 c3p0 数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"/>
        <property name="driverClass" value="${jdbc.driverClass}"/>
        
        <property name="initialPoolSize" value="${jdbc.initPoolSize}"/>
        <property name="maxPoolSize" value="${jdbc.maxPoolSize}"/>
    </bean>
    
    <!-- 配置 Spring 的 jdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>    
    </bean>
    
    <!-- 还可以配置 NamedParameterJdbcTemplate，该对象可以使用具名参数，其没有无参构造器，所以必须为其构造器指定参数 -->
    <bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
        <constructor-arg ref="dataSource"></constructor-arg>
    </bean>

package com.bupt.springtest.jdbc;

public class User
{
    private int uid;
    private String name;
    private int age;
    public int getUid()
    {
        return uid;
    }
    public void setUid(int uid)
    {
        this.uid = uid;
    }
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    @Override
    public String toString()
    {
        return "User [uid=" + uid + ", name=" + name + ", age=" + age + "]";
    }
}

package com.bupt.springtest.jdbc;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;

public class JDBCTest
{
    ApplicationContext ctx = new ClassPathXmlApplicationContext("ApplicationContext.xml");
    JdbcTemplate jdbcTemplate = (JdbcTemplate) ctx.getBean("jdbcTemplate");
    
    //在jdbcTemplate中使用具名参数
    NamedParameterJdbcTemplate namedParameterJdbcTemplate = ctx.getBean(NamedParameterJdbcTemplate.class);
    
    /*
     * 执行INSERT, UPDATE, DELETE
     */
    public void testUpdate() throws SQLException
    {
        String sql = "UPDATE user SET name = ? WHERE uid = ?";
        jdbcTemplate.update(sql, "jimmy", 6);
    }
    
    /*
     * 执行批量更新：批量的INSERT, UPDATE, DELETE
     * 最后一个参数是 Object[]的 List 类型：因为修改一条记录需要一个Object数组，多条即需要多个Object数组
     */
    public void testBatchUpdate()
    {
        String sql = "INSERT INTO user(uid, name, age) VALUES(?,?,?)";
        
        List<Object[]> batchArgs = new ArrayList<>();
        
        batchArgs.add(new Object[]{7, "A", 28});
        batchArgs.add(new Object[]{8, "B", 20});
        batchArgs.add(new Object[]{9, "C", 30});
        
        jdbcTemplate.batchUpdate(sql, batchArgs);
    }
    
    /*
     * 从数据库获取一条记录，实际得到对应的一个对象
     * 类跟表对应，对象跟记录对应
     * 调用queryForObject(String sql, RowMapper<User> rowMapper, Object... args)方法
     * 1. 其中的RowMapper指定如何映射结果集的行，常用实现类为 BeanPropertyRowMapper
     * 2. 使用SQL中列的别名完成列名和类的属性名完成映射
     * 如：若表中定义的name为 user_name，而在User类中定义为name，则sql语句应写为
     * "SELECT uid, user_name name, age FROM user WHERE uid = ?"
     * 3. 不支持级联属性，即表中关联元素不能查询到其他表中的数据
     */
    public void testQuery4Object()
    {
        String sql = "SELECT * FROM user WHERE uid = ?";
        
        RowMapper<User> rowMapper = new BeanPropertyRowMapper<>(User.class);
        User user = jdbcTemplate.queryForObject(sql, rowMapper, 1);
        
        System.out.println(user);
    }

    /*
     * 查询实体类的集合
     * 注意调用的不是 queryForList 方法
     */
    public void testQuery4List()
    {
        String sql = "SELECT uid, name, age FROM user WHERE uid > ?";
        RowMapper<User> rowMapper = new BeanPropertyRowMapper<>(User.class);
        List<User> users = jdbcTemplate.query(sql, rowMapper, 5);
        
        System.out.println(users);
    }
    
    /*
     * 获取单个列的值或做统计查询
     */
    public void testQueryForObject()
    {
        String sql = "SELECT count(uid) FROM user";
//        String sql = "SELECT name FROM user WHERE uid = ?";
//        String name = jdbcTemplate.queryForObject(sql, String.class, 2);
        long count = jdbcTemplate.queryForObject(sql, Long.class);
        
        System.out.println(count);
    }
    
    /*
     * 在经典的JDBC用法中， SQL参数是用占位符 ? 表示，并且受到位置的限制。定位参数的问题在于，一旦参数的顺序发生变化，就必须改变参数绑定
     * 在Spring JDBC 框架中，绑定 SQL 参数的另一种选择是使用具名参数(named parameter)，它可以为参数起名字
     * 具名参数：SQL按名字(以冒号开头)而不是按位置进行指定。具名参数更易于维护，也提升了可读性。具名参数由框架类在运行时用占位符取代
     * 具名参数只在NamedParameterJdbcTemplate中得到支持
     * 1. 好处：若有多个参数，则不用去对应位置，直接对应参数名，便于维护
     * 2. 缺点：较为麻烦
     */
    public void testNamedParameterJdbcTemplate()
    {
        String sql = "INSERT INTO user VALUES(:id, :nm, :age)";
        
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("id", 10);
        paramMap.put("nm", "elle");
        paramMap.put("age", 30);
        
        namedParameterJdbcTemplate.update(sql, paramMap);
    }
    
    /*
     * 使用具名参数时，可以使用update(String sql, SqlParameterSource paramSource)方法进行更新操作
     * 1. SQL语句中的参数和类的属性一致
     * 2. 使用 SqlParameterSource的 BeanPropertySqlParameterSource 实现类作为参数
     */
    @Test
    public void testNamedParameterJdbcTemplate1()
    {
        String sql = "INSERT INTO user VALUES(:uid, :name, :age)";
        
        User user = new User();
        user.setUid(11);
        user.setName("lock");
        user.setAge(28);
        
        SqlParameterSource parameterSource = new BeanPropertySqlParameterSource(user);
        namedParameterJdbcTemplate.update(sql, parameterSource);
    }
}

 

---

 

Spring 的事务管理

作为企业级应用程序框架，Spring 在不同的事务管理 API 之上定义了一个抽象层。而应用程序开发人员不必了解底层的事务管理 API，就可以使用 Spring 的事务管理机制。

Spring 既支持编程式事务管理，也支持声明式事务管理。

编程式事务管理：将事务管理代码嵌入到业务方法中来控制事务的提交和回滚。在编程式管理事务时，必须在每个事物操作中包含额外的事务管理代码。

声明式事务管理：大多数情况下比编程式事务管理更好用。它将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。事务管理作为一种横切关注点，可以通过 AOP 方法模块化。Spring 通过 Spring AOP 框架支持声明式事务。

Spring 从不同的事务管理 API 中抽象了一整套的事务机制。开发人员不必了解底层事务 API，就可以利用这些事务机制。有了这些事务机制，事务管理代码就能独立于特定的事务技术了。Spring 的核心事务管理抽象是 org.springframework.transaction.PlatformTransactionManager，它为事务管理封装了一组独立于技术的方法。无论使用 Spring 的哪种事务管理策略(编程式或声明式)，事务管理器都是必须的。

通过代码来说明Spring 对事务的支持，也学习下 JdbcTemplate 正真在实际中如何使用，我们先在test数据库中新建三张表

　　 account表　　　　　　　　　　　　　 book表　　　　　　　　　　book_stock表

　　　　

    <context:component-scan base-package="com.bupt.springtest.tx"></context:component-scan>

    <!-- 导入资源文件 -->
    <context:property-placeholder location="classpath:db.properties"/>
    
    <!-- 配置c3p0数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"/>
        <property name="driverClass" value="${jdbc.driverClass}"/>
    </bean>
    
    <!-- 配置Spring的 jdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>    
    </bean>

package com.bupt.springtest.tx;

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

package com.bupt.springtest.tx;

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

@Repository("bookShopDao")
public class BookShopDaoImp 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 sql1 = "SELECT stock FROM book_stock WHERE isbn = ?";
        int stock = jdbcTemplate.queryForObject(sql1, Integer.class, isbn);
        if(stock <= 0)
        {
            throw new RuntimeException("库存不足！");
        }
        String sql = "UPDATE book_stock SET stock = stock - 1 WHERE isbn = ?";
        jdbcTemplate.update(sql, isbn);
    }

    @Override
    public void updateUserAccount(String username, int price)
    {
        //验证余额是否足够，若不够，则抛出异常
        String sql1 = "SELECT balance FROM account WHERE username = ?";
        int balance = jdbcTemplate.queryForObject(sql1, Integer.class, username);
        if(balance < price)
        {
            throw new RuntimeException("余额不足！");
        }

        String sql = "UPDATE account SET balance = balance - ? WHERE username = ?";
        jdbcTemplate.update(sql, price, username);
    }
}

package com.bupt.springtest.tx;

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

//对单个操作事务的测试
public class SpringTransactionTest
{
    ApplicationContext ctx = new ClassPathXmlApplicationContext("ApplicationContext.xml");
    BookShopDao bookShopDao = ctx.getBean(BookShopDao.class);
    
    @Test
    public void testBookShopDaoUpdateBookStock()
    {
        bookShopDao.updateBookStock("1001");
    }
    
    public void testBookShopDaoFindPriceByIsbn()
    {
        System.out.println(bookShopDao.findBookPriceByIsbn("1001"));
    }
    
    public void testBookShopDaoUpdateUserAccount(){
        bookShopDao.updateUserAccount("Tom", 100);
    }
}

上面代码分别测试了单个操作事务，现在我们把上面的操作组成一个完整的事务过程，即买书 —> 更新书库存 —> 更新账户余额

package com.bupt.springtest.tx;

public interface BookShopService
{
    //买书事务
    public void purchase(String username, String isbn);
}

package com.bupt.springtest.tx;

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

@Service("bookShopService")
public class BookShopServiceImp implements BookShopService
{
    @Autowired
    private BookShopDao bookShopDao;
    
    @Override
    public void purchase(String username, String isbn)
    {
        //获取书的单价
        int price = bookShopDao.findBookPriceByIsbn(isbn);
        //更新书的库存
        bookShopDao.updateBookStock(isbn);
        //更新用户余额
        bookShopDao.updateUserAccount(username, price);
    }
}

package com.bupt.springtest.tx;

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

public class SpringTransactionTest
{
    ApplicationContext ctx = new ClassPathXmlApplicationContext("ApplicationContext.xml");
    BookShopService bookShopService = ctx.getBean(BookShopService.class);
    
    @Test
    public void testBookShopService()
    {
　　　　 //执行此代码前，先将account表中的balance改为60，即使用户余额不足以购买该书
        bookShopService.purchase("Tom", "1001");
    }
}

执行测试之后我们可以看到，这个操作并不满足事务的要求，因为书的库存更新了但账户里的钱没有变，及违背了原子性。这种情况下，我们就需要 Spring 的事务管理来帮我们解决。

 

 

用事务通知声明式地管理事务

Spring 允许简单地使用 @Transactional 注解来标注事务方法。为了将 方法定义为支持事务处理，可以为方法添加 @Transactional 注解，根据 Spring AOP 基于代理机制，只能标注公有方法。可以在方法或者类级别上添加 @Transactional 注解，当把这个注解应用到类上时，这个类中的所有公有方法都会被定义为支持事务处理。

在 bean 配置时，只需要在配置文件中启用 <tx:annotation-driven> 元素，并为之指定事务管理器就可以了。如果事务处理器名称是 transactionManager，就可以在 <tx:annotation-driven> 元素中省略 transaction-manager 属性。这个元素会自动检测该名称的事务处理器。

 

默认情况下，如果被注解的数据库操作方法发生了 Unchecked Exception 或 Error，所有的数据库操作将回滚；如果发生的是 Checked Exception，默认情况下数据库操作还是会提交的。

 

我们也可以来改变默认的规则：

1. 让 Checked Exception 也回滚：在整个方法前加上 @Transactional(rollbackFor=Exception.class)

2. 让 Unchecked Exception 不回滚：@Transactional(noRollbackFor=RuntimeException.class)

3. 不需要事务管理(只查询)的方法：@Transactional(propagation=Propagation.NOT_SUPPORTED)

注意：如果异常被 try-catch块捕获了，事物就不会回滚了，若想让事务回滚必须再往外抛异常，即在catch模块中继续往外抛 Unchecked Exception。

 

下面用代码来具体介绍用法

在ApplicationContext.xml文件中增加下面几行代码

    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
     
     <!-- 启动注解事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

在 BookShopServiceImp 的 purchase() 方法上增加注解 @Transactional

package com.bupt.springtest.tx;

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

@Service("bookShopService")
public class BookShopServiceImp implements BookShopService
{
    @Autowired
    private BookShopDao bookShopDao;
    
    //添加事务注解
    @Transactional
    @Override
    public void purchase(String username, String isbn)
    {
        //获取书的单价
        int price = bookShopDao.findBookPriceByIsbn(isbn);
        //更新书的库存
        bookShopDao.updateBookStock(isbn);
        //更新用户余额
        bookShopDao.updateUserAccount(username, price);
    }
}

package com.bupt.springtest.tx;

import java.util.Arrays;

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

//测试类
public class SpringTransactionTest
{
    ApplicationContext ctx = new ClassPathXmlApplicationContext("ApplicationContext.xml");
    BookShopService bookShopService = ctx.getBean(BookShopService.class);

    @Test
    public void testBookShopService()
    {
        bookShopService.purchase("Tom", "1001");
    }

由结果可以看出，此时 purchase() 方法满足事务的要求。

 

除了使用上述声明事务的方法， Spring 还可以通过 tx Schema 中定义的 <tx:advice>  元素声明事务通知。

事务管理其实是一种横切关注点，声明了事务通知后，就需要把它与切入点关联起来。由于事务通知是在 <aop:config> 元素外部声明的，所以它无法直接与切入点产生关联。所以必须在 <aop:config> 元素中声明一个增强器通知与切入点关联起来。只有公有方法才能通过 Spring AOP 进行事务管理。

 

下面我们来看配置方法，将前面配置在xml文件中的 <tx:annotation-driven transaction-manager="transactionManager"/> 删掉，增加如下配置代码

     <!-- 声明事务通知，让所有方法都拥有事务 -->
     <tx:advice id="bookShopTxAdvice" transaction-manager="transactionManager">
         <tx:attributes>
             <tx:method name="*"/>
　　　　　　　 <tx:method name="get*" read-only="true"/>
         </tx:attributes>
     </tx:advice>
     
     <!-- 声明事务通知需要通知方法(即需要进行管理的方法) -->
     <aop:config>
　　　　　<!-- 配置事务切点，把事务切入点和事务属性关联起来 -->
         <aop:pointcut id="bookShopOperation" expression="execution(* com.bupt.springtest.tx.BookShopServiceImp.*(..))"/>
         <aop:advisor advice-ref="bookShopTxAdvice" pointcut-ref="bookShopOperation"/>
     </aop:config>

删除 BookShopServiceImp.purchase() 方法上标注的 @Transactional 注解，测试后也能正常执行事务。

 

关于 <tx:method/> 属性的说明

属性	说明
name	方法名的匹配模式，通知根据该模式寻找匹配的方法。该属性可以使用通配符(*)。也可以声明为 (xxx*)，即代表以xxx开头的所有方法，表示符合此命名规则的方法作为一个事务(此属性是必须要有的)
propagation	设定事务定义所用的传播级别(默认值为REQUIRED)
isolation	设定事务的隔离级别(默认值为DEFAULT)
timeout	指定事务的超时(单位为秒)，默认值为-1
read-only	指定事务是否只读，若为true指示事务是只读的(一般来讲，对于只执行查询的事务你会将该属性设为true，如果出现了更新、插入或是删除语句时只读事务就会失败)，默认值为 false
no-rollback-for	以逗号分隔的异常类的列表，目标方法可以抛出这些异常而不会导致通知执行回滚，如：NullPointException，ArithmeticException...
rollback-for	以逗号分隔的异常类列表，当目标方法抛出这些异常时会导致通知执行回滚。默认情况下，该列表为空，因此不在 no-rollback-for列表中的任何运行时异常都会导致回滚

 

 

 

Spring 中事务的传播特性

当一个事务被另外一个事务调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事物，并在自己的事务中运行

事务的传播行为可以由传播属性来指定，Spring 定义了七种类型的传播行为

传播属性	描述
REQUIRED	如果有事务在运行，当前的方法就在这个事务内运行，否则，就启动一个新的事务，并在自己的事务内运行
REQUIRES_NEW	当前的方法必须启动新的事务，并在它自己的事务内运行。如果有事务正在运行，应该将它挂起来
SUPPORTS	如果有事务在运行，当前的方法就在这个事务内运行，否则它可以不运行在事务中
NOT_SUPPORTED	当前方法不应该运行在事务中，如果有运行的事务，将它挂起来
MANDATORY	当前方法必须运行在事务内部，如果没有正在运行的事务，就抛出异常
NEVER	当前的方法不应该运行在事务中，如果有运行的事务，就抛出异常
NESTED	如果有事务在运行，当前的方法就应该在这个事务的嵌套事务内运行。否则，就启动一个新的事务，并在它自己的事务内运行

 

下面通过代码来介绍传播特性的用法

配置文件改回 <tx:annotation-driven transaction-manager="transactionManager"/>

package com.bupt.springtest.tx;

import java.util.List;

//新定义一个接口，表示用户结算操作
public interface Cashier
{
    public void checkout(String name, List<String> isbn);
}

package com.bupt.springtest.tx;

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 CashierImp implements Cashier
{
    @Autowired
    private BookShopService bookShopService;
    
    //定义一个事物为 checkout
    @Transactional
    @Override
    public void checkout(String username, List<String> isbns)
    {
        for(String isbn : isbns)
        {
            bookShopService.purchase(username, isbn);
        }
    }
}

为 BookShopServiceImp.purchase 方法上的 @Transactional 注解添加属性：propagation=Propagation.REQUIRED

@Service("bookShopService")
public class BookShopServiceImp implements BookShopService
{
    @Autowired
    private BookShopDao bookShopDao;
    
    //使用propagation指定事务的传播行为，即当前事务方法被另外一个事物方法调用时
    //如何进行事务，默认取值为REQUIRED
    //添加事务注解
    @Transactional(propagation=Propagation.REQUIRED)
    @Override
    public void purchase(String username, String isbn)
    {
        //获取书的单价
        int price = bookShopDao.findBookPriceByIsbn(isbn);
        //更新书的库存
        bookShopDao.updateBookStock(isbn);
        //更新用户余额
        bookShopDao.updateUserAccount(username, price);
    }
}

//测试代码
public class SpringTransactionTest
{
    ApplicationContext ctx = new ClassPathXmlApplicationContext("ApplicationContext.xml");
    Cashier cashier = ctx.getBean(Cashier.class);
    
    @Test
    public void testTransactionPropogation()
    {
        cashier.checkout("Tom", Arrays.asList("1001", "1002"));
    }
}

当 bookService 的 purchase() 方法被另外一个事务方法 checkout() 调用时，它默认会在现有事务内运行。这个默认的传播行为就是 REQUIRED。因此从 checkout() 方法的开始到结束这个事务过程中，只有一个事务在执行。这个事务只在 checkout() 方法结束的时候被提交，若此时账户余额不够支付两本书的价格，就导致用户一本书都买不了。这个流程可以用图表示为：

 

 

 

另一种常见的传播行为是 REQUIRES_NEW ，它表示该方法必须要启动一个新事物，并在自己的事务内运行。如果有事务在运行，就应该先把它挂起。相应的代码修改，只需修改 @Transactional 的属性

    @Transactional(propagation=Propagation.REQUIRES_NEW)
    @Override
    public void purchase(String username, String isbn){

 

此时的事务流程可以表示为如下图，此时若账户金钱能买一本但不够两本时，会执行能购买的行为，而对不能购买的行为不执行

 

 

同样在xml配置文件中，我们也可以来设置传播属性

     <tx:advice id="bookShopTxAdvice" transaction-manager="transactionManager">
         <tx:attributes>
             <tx:method name="purchase" 
             propagation="REQUIRES_NEW"/>
         </tx:attributes>
     </tx:advice>

 

 

事务的隔离级别

Spring 支持的事务隔离别如下表所示

 

隔离级别	描述
DEFAULT	使用地城数据库的默认隔离级别，对大多数数据库来说，默认的隔离级别都是 READ_COMMITED
READ_UNCOMMITTED	允许事务读取未被其他事务提交的变更。脏读、不可重复读和幻读的问题都会出现
READ_COMMITTED	只允许事务读取已经被其他事务提交的变更。可以避免脏读，但不可重复读和幻读问题仍然可能出现
REPEATABLE_READ	确保事务可以多次从一个字段中读取相同的值，在这个事务持续期间，禁止其他事务对这个字段进行更新。可以避免脏读和不可重复读，但幻读的问题仍然存在
SERIALIZABLE	确保事务可以冲一个表中读取相同的行。在这个事务持续期间，禁止其他事务对该表执行插入、更新和删除操作。所有并发问题都可以避免，但性能低下

Oracle 支持 2 种事务隔离级别：READ_COMMITED，SERIALIZABLE

MySql 支持 4 种

 

用法如下代码所示

    @Transactional(propagation=Propagation.REQUIRES_NEW,
            isolation=Isolation.READ_COMMITTED)
    public void purchase(String username, String isbn){

     <tx:advice id="bookShopTxAdvice" transaction-manager="transactionManager">
         <tx:attributes>
             <tx:method name="purchase" 
             propagation="REQUIRES_NEW" 
             isolation="READ_COMMITTED""/>
         </tx:attributes>
     </tx:advice>

 

 

设置回滚事务属性

默认情况下只有未检查异常( RuntimeException 和 Error 类型的异常)会导致事务回滚。而受检查异常则不会。(通常情况下我们都是取默认值即可)

事务的回滚规则可以通过 @Transactional 注解的 rollbackFor 和 norollbackFor 属性来定义。这两个属性被声明为 Class[] 类型的，因此可以为这两个属性指定多个异常类，也可以使用属性 rollbackFor=ClassName 和 norollbackFor=ClassName 通过异常类的名字直接指定。

    @Transactional(propagation=Propagation.REQUIRES_NEW,
            isolation=Isolation.READ_COMMITTED,
            rollbackFor={IOException.class, SQLException.class},
            noRollbackFor=ArithmeticException.class)
    public void purchase(String username, String isbn){

我们还可以在 <tx:method/> 元素中指定回滚规则，此时属性值要填类全名

     <tx:advice id="bookShopTxAdvice" transaction-manager="transactionManager">
         <tx:attributes>
             <tx:method name="purchase" 
             propagation="REQUIRED" 
             isolation="DEFAULT"
             rollback-for="java.io.IOException, java.sql.SQLExcpetion"
             no-rollback-for="java.lang.ArithmeticExcpeion"/>
         </tx:attributes>
     </tx:advice>

 

 

超时和只读属性

超时事务属性：表示事务在强制回滚之前可以保持多久，这样可以防止长期运行的事务占用资源。由于事务可以在行和表上获得锁，因此长事务会占用资源，对整体性能产生影响。

只读事务属性：表示这个事务只读取数据但不更新数据，这样可以帮助数据库引擎优化事务。

超时和只读属性可以在 @Transactional 注解中定义。超时属性以秒为单位计算。

    @Transactional(propagation=Propagation.REQUIRES_NEW,
            isolation=Isolation.READ_COMMITTED,
            rollbackFor={IOException.class, SQLException.class},
            noRollbackFor=ArithmeticException.class,
            readOnly=true,
            timeout=30)
    public void purchase(String username, String isbn){

也可以在 <tx:method/>元素中进行指定

     <tx:advice id="bookShopTxAdvice" transaction-manager="transactionManager">
         <tx:attributes>
             <tx:method name="purchase" 
             propagation="REQUIRES_NEW" 
             isolation="READ_COMMITTED"
             rollback-for="java.io.IOException, java.sql.SQLExcpetion"
             no-rollback-for="java.lang.ArithmeticExcpeion"
             timeout="30"
             read-only="false"/>
         </tx:attributes>
     </tx:advice>