spring之为什么要使用事务？（一）

jdbc.user=root
jdbc.password=123456
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql:///spring
jdbc.initPoolSize=5
jdbc.maxPoolSize=10

<?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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    
    <!-- 导入资源文件 -->
    context:property-placeholder location="classpath:db.properties"/>
    
     配置 C3P0 数据源 bean id="dataSource"
        class="com.mchange.v2.c3p0.ComboPooledDataSource">
        property name="user" value="${jdbc.user}"></property="password"="${jdbc.password}"="jdbcUrl"="${jdbc.jdbcUrl}"="driverClass"="${jdbc.driverClass}">

        ="initialPoolSize"="${jdbc.initPoolSize}"="maxPoolSize"="${jdbc.maxPoolSize}">
    </bean>
    
    
beans>

context:component-scan base-package="com.gong.spring"context:component-scan>

     配置 Spirng 的 JdbcTemplate ="jdbcTemplate" 
        class="org.springframework.jdbc.core.JdbcTemplate" ref="dataSource">

package com.gong.spring.tx;

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

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

@Repository("bookShopDao")
class BookShopDaoImpl implements BookShopDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Override
     findBookPriceByIsbn(String isbn) {
        String sql = "SELECT price FROM book WHERE isbn = ?";
        return jdbcTemplate.queryForObject(sql,Integer.class,isbn);
    }

    @Override
     updateBookStock(String isbn) {
        String sql2 = "SELECT stock FROM book_stock WHERE isbn = ?"int stock = jdbcTemplate.queryForObject(sql2,isbn);
        检查书的库存是否足够，如果不够，就抛出异常
        if(stock == 0){
            throw new BookStockException("库存不足!");
        }
        
        String sql = "UPDATE book_stock SET stock = stock -1 WHERE isbn = ?";
        jdbcTemplate.update(sql,1)"> price) {
        String sql2 = "SELECT balance FROM account WHERE username = ?"int balance = jdbcTemplate.queryForObject(sql2,username);
        if(balance < price){
            new UserAccountException("余额不足!");
        }
        
        String sql = "UPDATE account SET balance = balance - ? WHERE username = ?"自己定义该抛出的异常。

BookStockException.java

class BookStockException extends RuntimeException{

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

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

     BookStockException(String message,Throwable cause,boolean enableSuppression,1)">boolean writableStackTrace) {
        (message,cause,enableSuppression,writableStackTrace);
         BookStockException(String message) {
        (message);
         BookStockException(Throwable cause) {
        (cause);
            }

    
}

UserAccountException.java

class UserAccountException  UserAccountException() {
         UserAccountException(String message,1)"> UserAccountException(String message) {
         UserAccountException(Throwable cause) {
            }

    
    
}

要定义自己异常的名称，需要让其继承RuntimeException，并实现构造方法。
然后是服务层的代码：
BookShopService.java

 BookShopService {
    
     purchase(String username,String isbn);
    
}

只有一个方法体，就是购买的操作。
BookShopServiceImpl.java　　

 org.springframework.stereotype.Service;


@Service("bookShopService"class BookShopServiceImpl  BookShopService {

    @Autowired
     BookShopDao bookShopDao;
    
    @Override
    1. 获取书的单价
        int price = bookShopDao.findBookPriceByIsbn(isbn);
        
        2. 更新库存
        bookShopDao.updateBookStock(isbn);
        
        3. 更新余额
        bookShopDao.updateUserAccount(username,price);
    }

}

最后，我们建立一个JUnit Test Case的文件进行测试：
SpringTransactionImpl.java

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

 SpringTransactionTest {

    private ApplicationContext ctx = null;
    private BookShopDao bookShopDao = private BookShopService bookShopService = ;
    {
        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        bookShopDao = ctx.getBean(BookShopDao.);
        bookShopService = ctx.getBean(BookShopService.);
    }
    
    
    @Test
     testBookShopService(){
        bookShopService.purchase("AA","1001");
    }
    
    @Test
     testBookShopDaoUpdateUserAccount(){
        bookShopDao.updateUserAccount("AA",10 testBookShopDaoUpdateBookStock(){
        bookShopDao.updateBookStock("1001" testBookShopDaoFindPriceByIsbn() {
        System.out.println(bookShopDao.findBookPriceByIsbn("1001"));
    }

}

这里面当然也可以测试操作数据库的Dao的代码。我们现在就只关注testBookShopService方法，即购买操作是否存在问题。
右键点击testBookShopService，选择run as JUnit-Test。执行成功后我们看数据库中的数据：

成功的买一本书号为1001 的书了。

账户余额减掉了100.
我们再执行一次testBookShopService方法：报错：余额不足，显然60不够买100的书。

但是呢，我们先执行的是库存减一操作，此时库存：

明明没有买成功，但库存减了一，这就存在问题了。
有人也许会问，那我们先判断金额，再进行库存操作不就可以了么？
这也存在问题：假设金额足够，但是库存为零。先执行金额减掉书的价值操作，但是会报库存不足。相当于我钱付了，没买到书，这不就尴尬了。
这种情况下，我们就需要用到事务处理。
本章太长了，放在下节写吧。。。
                        
（编辑：李大同）
【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!