Spring 声明式事务管理讲解：为什么用，及怎么用

最新推荐文章于 2020-08-05 14:01:02 发布
最新推荐文章于 2020-08-05 14:01:02 发布
阅读量839 收藏 3
点赞数
分类专栏： spring

原文地址：https://www.cnblogs.com/caoyc/p/5632198.html

案例分析

本案例是图书管理系统精简部分，在数据库中有3张表。分别保存图书库存、图书信息和用户信息。下面是建表SQL语句

DROP TABLE IF EXISTS store;
DROP TABLE IF EXISTS book ;
DROP TABLE IF EXISTS user;

-- 图书表
CREATE TABLE book(
    sn  VARCHAR(20) PRIMARY KEY ,  -- 图书编码
    name VARCHAR(20) NOT NULL,     -- 图书名称
    price NUMERIC(9,2) NOT NULL    -- 图书价格
);

-- 仓库表
CREATE TABLE store(
    sn VARCHAR(20),         -- 图书编码
    stock INT(9) NOT NULL,   -- 图书库存
    CONSTRAINT fk_sn FOREIGN KEY (sn)  REFERENCES book(sn)
);

-- 用户表
CREATE TABLE user(
    id INT(11) PRIMARY KEY AUTO_INCREMENT,              -- id
    name VARCHAR(20) NOT NULL,        -- 姓名
    balance NUMERIC(9,2) NOT NULL DEFAULT 0 -- 余额
);

INSERT INTO book VALUES ('1001','Java从入门到精通',100);
INSERT INTO book VALUES ('1002','Spring从入门到精通',90);
INSERT INTO book VALUES ('1003','J2EE核心框架',80);

INSERT INTO store VALUES ('1001',50);
INSERT INTO store VALUES ('1002',20);
INSERT INTO store VALUES ('1003',10);

INSERT INTO user (name,balance) VALUES ('caoyc',150);

实体类

Book.java

package com.proc.bean;

public class Book {

    private String sn;
    private String name;
    private Double price;

    public String getSn() {
        return sn;
    }

    public void setSn(String sn) {
        this.sn = sn;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    public String toString() {
        return "Book [sn=" + sn + ", name=" + name + ", price=" + price + "]";
    }
    
}

Store.java

package com.proc.bean;

/**仓库类*/
public class Store {

    private String sn;
    private Integer stock;
    public String getSn() {
        return sn;
    }
    public void setSn(String sn) {
        this.sn = sn;
    }
    public Integer getStock() {
        return stock;
    }
    public void setStock(Integer stock) {
        this.stock = stock;
    }
    @Override
    public String toString() {
        return "Store [sn=" + sn + ", stock=" + stock + "]";
    }
    
    
}

User.java

package com.proc.bean;

/**
 * @author caoyc
 *
 */
public class User {

    private Integer id;
    private String name;
    private Double balance;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Double getBalance() {
        return balance;
    }
    public void setBalance(Double balance) {
        this.balance = balance;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", balance=" + balance
                + "]";
    }
    
    
}

Spring配置信息

使用db.properties记录数据库配置信息，这样便于后期维护

1 jdbc.user=root
2 jdbc.password=123456
3 jdbc.driverClass=com.mysql.jdbc.Driver
4 jdbc.jdbcUrl=jdbc\:mysql\:///test

配置applicationContext.xml信息

<!-- 配置自动扫描策略 -->
    <context:component-scan base-package="com.proc"/>
    
    <!-- 读取db.properties配置信息 -->
    <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="driverClass" value="${jdbc.driverClass}"/>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"/>
    </bean>
    
    <!-- 配置一个JdbcTemplate，用来操作数据库 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

这里我们使用自动扫描策略，使用的是C3P0连接池。同时使用了Spring内置的jdbc封装类JdbcTemplate

数据访问层

Java代码：BookDao.java

package com.proc.dao;

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

import com.proc.bean.Book;

/**图书Dao*/
@Repository
public class BookDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    /**通过图书编号获取图书信息*/
    public Book get(String sn){
        
        String sql="SELECT * FROM book WHERE sn=?";
        RowMapper<Book> rowMapper=new BeanPropertyRowMapper<Book>(Book.class);
        Book book=jdbcTemplate.queryForObject(sql, rowMapper,sn);
        return book;
    }
}

StoreDao

package com.proc.dao;

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

import com.proc.bean.Store;

/**图书仓库Dao*/
@Repository
public class StoreDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    /**通过图书编号获取图书库存信息*/
    public Store get(String sn){
        String sql="SELECT * FROM store WHERE sn=?";
        RowMapper<Store> rowMapper=new BeanPropertyRowMapper<Store>(Store.class);
        Store store=jdbcTemplate.queryForObject(sql, rowMapper,sn);
        return store;
    }
    
    /**通过图书编号，修改图书库存  库存=当前库存-1*/
    public void update(String sn){
        String sql="UPDATE store SET stock=stock-1 WHERE sn=?";
        jdbcTemplate.update(sql, sn);
    }
}

UserDao.java

package com.proc.dao;

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

import com.proc.bean.User;

/**用户Dao*/
@Repository
public class UserDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    /**通过用户ID获取用户信息*/
    public User get(Integer id){
        String sql="SELECT * FROM user WHERE id=?";
        RowMapper<User> rowMapper=new BeanPropertyRowMapper<User>(User.class);
        User user=jdbcTemplate.queryForObject(sql, rowMapper,id);
        return user;
    }
    
    /**修改用户余额*/
    public void update(Integer id,Double price){
        String sql="UPDATE user SET balance=balance-? WHERE id=?";
        jdbcTemplate.update(sql, new Object[]{price,id});
    }
}

这里为每个Dao都注入了一个JdbcTemplate的实例，可以使用JDBC方式操作数据库

异常处理

考虑到有可能会出现用户余额或图书库存不足的情况，这里我们自定义了两个异常

 1、库存不足异常类：

package com.proc.exception;

public class BookStockException extends RuntimeException{
    public BookStockException(String msg) {
        super(msg);
    }
}

2、余额不足异常类

package com.proc.exception;

public class UserBalanceException extends RuntimeException {
    public UserBalanceException(String msg) {
        super(msg);
    }
}

 逻辑业务层

1、定义一个接口

package com.proc.service;

public interface BookShopService {

    /**
     * 购买图书
     * @param userId 购买用户ID
     * @param sn 图书编号
     */
    void purchase(Integer userId,String sn);
}

2、定义一个BookShopService借口实现类

package com.proc.service;

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

import com.proc.bean.Book;
import com.proc.bean.Store;
import com.proc.bean.User;
import com.proc.dao.BookDao;
import com.proc.dao.StoreDao;
import com.proc.dao.UserDao;
import com.proc.exception.BookStockException;
import com.proc.exception.UserBalanceException;

@Service("bookShopService")
public class BookShopServiceJdbcImps implements BookShopService{

    @Autowired
    private UserDao userDao;
    @Autowired
    private BookDao bookDao;
    @Autowired
    private StoreDao storeDao;
    
    
    /**购买图书方法*/
    public void purchase(Integer userId, String sn) {
        
        //1:查收出图库存信息
        Store store= storeDao.get(sn);
        if(store.getStock()<=0){
            throw new BookStockException("图书库存不足："+store);
        }
        
        //2:查询图书信息
        Book book=bookDao.get(sn);
        
        
        //3:查询用户信息
        User user=userDao.get(userId);
        if(user.getBalance()<book.getPrice()){
            throw new UserBalanceException("用户余额不足："+user);
        }
        
        //4:修改库存
        storeDao.update(sn);
        
        //5:修改余额
        userDao.update(userId, book.getPrice());
    }

}

测试代码：

package com.proc.test;

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

import com.proc.service.BookShopService;

public class TestShopBook {

    private ApplicationContext ctx;
    private BookShopService bookShopService;
    {
        ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        bookShopService=(BookShopService) ctx.getBean("bookShopService");
    }
    
    @Test
    public void purchase(){
        
        bookShopService.purchase(1, "1001");
    }
}

第一次执行：

可以成功的看到数据是符合要求的

第二次执行：

　　我们看到会抛出异常。由于余额50元以不够买价格为100元的1001编号书籍。所有抛出异常。我们看看数据库中结果怎么样

看起来数据是正确的。由于余额不足，那么购买不成功，所有库存和金额都不会变好。那是不是使用了事务呢？

　　答案是：没有。这里没有使用事务。只是因为我们先判断了图书库和用户余额是否足够，然后再执行的修改信息。如果要测试代码。我们将我们逻辑业务层代码中第4步放到第2步前面执行

//1:查收出图库存信息
Store store= storeDao.get(sn);
if(store.getStock()<=0){
    throw new BookStockException("图书库存不足："+store);
}

//4:修改库存
storeDao.update(sn);

//2:查询图书信息
Book book=bookDao.get(sn);


//3:查询用户信息
User user=userDao.get(userId);
if(user.getBalance()<book.getPrice()){
    throw new UserBalanceException("用户余额不足："+user);
}

再次执行代码：

虽然在此时还是或抛出余额不足的异常。但是库存却改变了。余额没有改变。所有不满足事务的要求。

那么要怎么办呢？

1、在spring配置文件中配置事务管理器

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>

<!-- 使得事务注解生效 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

事务管理器需要注入一个DataSource接口类型的数据源

2、在需要使用事务管理的方法前加上@Transactional注解

@Transactional
    /**购买图书方法*/
    public void purchase(Integer userId, String sn) {
        
        //1:查收出图库存信息
        Store store= storeDao.get(sn);
        if(store.getStock()<=0){
            throw new BookStockException("图书库存不足："+store);
        }
        
        //4:修改库存
        storeDao.update(sn);
        
        //2:查询图书信息
        Book book=bookDao.get(sn);
        
        
        //3:查询用户信息
        User user=userDao.get(userId);
        if(user.getBalance()<book.getPrice()){
            throw new UserBalanceException("用户余额不足："+user);
        }
        
        //5:修改余额
        userDao.update(userId, book.getPrice());
    }

再次执行代码：

虽然还是抛出了异常。但是库存和余额都没有发生变化。这里证明是使用了事务

【总结】：基于声明式的事务就是上面用的这种方法

第一步：在spring配置中配置事务管理器

第二步：在需要使用事务的方法前面加上@Transactional注解

别把BUG不当代码
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用Spring的声明式事务----Annotation注解方式
08-06
NULL 博文链接：https://tonl.iteye.com/blog/2093289
Spring编程式和声明式事务实例讲解小结
08-25
* 基于TransactionInterceptor的声明式事务：Spring声明式事务的基础，通常也不建议使用这种方式。 * 基于TransactionProxyFactoryBean的声明式事务：第一种方式的改进版本，简化了配置文件的书写。 * 基于和命名...
spring 声明式事务使用方式
chuncui2576的博客
08-02 92
ProxyFactoryBean + XML 早期使用方式（2.0） 比较流行的目前： tx:advice+aop 命名空间 一次配置永久生效 （比较流行，多人使用的,这样容易在实际的项目中遗忘一些问题） 注解： @Transactional 注解控制 （推荐使用，，这样对以...
spring事务管理之四：声明式事务管理：使用事务注解的方式
feinifi的博客
12-21 391
事务注解的方式，相对xml的方式来说，有优点，无需配置需要事务的业务方法的切点和事务属性。但是也有缺点，就是需要在每个需要事务的业务方法上加上一个注解@Transaction，否则事务不会生效。 这里沿用之前spring事务管理的代码： pom.xml依赖部分： &lt;dependencies&gt; &lt;dependency&gt; &lt;groupId&g...
spring注解 声明式事务
闲_风的博客
11-13 1341
       在spring注解中，使用声明式事务，需要用到两个核心的注解：@Transactional注解和@EnableTransactionManagement注解。将@Transactional注解加在方法上，@EnableTransactionManagement注解加在配置类上，除此之外，还有一个核心要点是，向容器中注册PlatformTransactionManager组件，用于进行...
Spring声明式事务控制（学习笔记）
weixin_43642556的博客
08-05 210
1. Spring 基于 XML 的声明式事务控制 1.1 什么是声明式事务控制 Spring 的声明式事务顾名思义就是采用声明的方式来处理事务。这里所说的声明，就是指在配置文件中声明，用在 Spring 配置文件中声明式的处理事务来代替代码式的处理事务。 声明式事务处理的作用 事务管理不侵入开发的组件。具体来说，业务逻辑对象就不会意识到正在事务管理之中，事实上也应该如此，因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策划的话，也只需要在定义文件中重新配置即可 在不需要
完美解决Spring声明式事务不回滚的问题
08-30
完美解决Spring声明式事务不回滚的问题 在实际应用中，Spring声明式事务管理是非常常见的，但是有...解决Spring声明式事务不回滚的问题需要我们了解事务管理的机制和原理，并避免在业务逻辑中使用try...catch异常。
基于java的企业级应用开发：声明式事务管理.ppt
06-21
使用@Transactional注解时，可以通过参数配置事务详情： 5.2.2 基于Annotation方式的声明式事务 * * * * * * * * 声明式事务管理 如何实现Spring的声明式事务管理？ 5.2 声明式事务管理 Spring的声明式事务管理可以...
全面分析Spring的编程式事务管理与声明式事务管理.doc
09-24
本文将从 Spring 的事务管理入手，深入讲解编程式事务管理和声明式事务管理的实现机制和原理。通过本文的学习，您将能够理解 Spring 事务管理的本质，并灵活运用之。 一、事务管理的重要性 事务管理对于企业应用至...
Spring使用XML配置声明式事务
05-19
在Spring框架中，声明式事务管理是实现事务处理...在博文"Spring使用XML配置声明式事务"中，作者详细讲解了每个步骤，并可能通过示例代码展示了如何实际应用这些配置，帮助读者更好地理解和掌握Spring声明式事务管理。
Spring的声明式事务处理的使用看一遍就会
独孤一剑
07-03 158
Spring的声明式事务处理的使用看一遍就会 xml配置文件方式： 第一步引入坐标依赖： <dependency> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> &l...
spring声明式事务管理详情解析
weixin_30443747的博客
10-24 102
前沿：通过对spring事务管理有了比较深入学习，本文将不做实例，而是指定具体的类和配置文件进行讲解。 本文内容： 　　1、了解什么是声明式事务？ 　　2、声明式事务管理分别有哪几种？ 　　3、这几种事务管理之间的区别是什么？ 一、什么是声明式事务？ 　　声明式事务(declarative transaction management)是spring提供的对程序事务管理的方式之一...
spring常用注解（四）事务
w_t_y_y的博客
03-22 335
1、@RequestParam： @RequestParam是传递参数的. @RequestParam用于将请求参数区数据映射到功能处理方法的参数上。 public String queryUserName(@RequestParam String userName) 在url中输入:localhost:8080/**/?userName=zhangsan 请求中包含userna...
Spring声明式事务管理简介
lilei的博客
03-08 354
Spring声明式事务管理 （一）介绍 事务概念: 事务是一组最小逻辑执行单元，组成这个单元的每一个操作，要么同时执行成功，有一个执行失败就全部失败。 有四大特性:原子性,一致性,隔离性,持久性 Spring声明式事务控制 Spring已经提供了事务管理、事务控制的具体实现，我们只需要按照规则使用即可。 如果要用Spring声明式事务，需要引入spring-tx包， spring-jdbc...
Spring 事务管理(1)数据源配置
sukyle的专栏
05-25 762
Spring框架引人注目的重要因素之一是它全面的事务支持。Spring框架提供了一致的事务管理抽象。但是在使用Spring 事务管理之前，一定要注意对数据源(DataSource)的配置，否则有可能带来你不想看到的结果。 1. 对iBATIS SQL Maps 2.x的配置：            除了上面的配置，在编写代码时，采用SqlMapClientTemplate 和
配置声明式事务
weixin_33744141的博客
12-20 131
一、编程式事务 　　使用原生的JDBC API进行事务管理 　　 [1]获取数据库连接Connection对象 　　 [2]取消事务的自动提交 　　[3]执行操作 　　 [4]正常完成操作时手动提交事务 　　 [5]执行失败时回滚事务 　　 [6]关闭相关资源 1 　　1.编程式事务 2 　　　　//1.获取C...
Srping——Spring中的声明式事务配置
qq_43411550的博客
08-12 203
Srping——Spring中的声明式事务 一、声明式事务 在Spring中支持两种事务处理机制： 编程式事务：把事务的代码都写在业务中 声明式事务：使用AOP横切进去（一般会使用声明式事务） 我们要开启Spring的声明式事务处理功能，在Spring配置文件种创建一个DataSourceTransactionManager对象，事务管理器是需要一个数据源dataSource的 <bea...
深入理解 Spring 事务原理【转】
weixin_30679823的博客
07-01 740
本文转自码农网– 吴极心原创 连接地址：http://www.codeceo.com/article/spring-transactions.html 一、事务的基本原理 Spring事务的本质其实就是数据库对事务的支持，没有数据库的事务支持，spring是无法提供事务功能的。对于纯JDBC操作数据库，想要用到事务，可以按照以下步骤进行： 获取连接 Connection con ...
Spring事务控制--Spring中的事务处理
热门推荐
方圆几里
11-07 4万+
事务回顾 什么是事务？ 事务是逻辑上的一组操作，组成这组操作的各个逻辑单元，要么一起成功，要么一起失败。 事务的特性 原子性：强调事务的不可分割 一致性：事务执行的前后数据的完整性要保持一致 隔离性：一个事务的执行过程中不应该受到其他事务的干扰 持久性：事务一旦结束，数据就持久化到数据库 如果不考虑隔离性会引发安全性问题 脏读：一个事务读到了另一个事务的未提交的数据 不可重复读：一个事务读...
jdbctemplate 事务_Spring编程式和声明式事务实例讲解
最新发布
05-17
在 Spring 中，我们可以通过编程式事务和声明式事务来处理数据库事务。下面我来分别介绍一下这两种事务的实现。 ## 编程式事务 编程式事务是通过代码实现事务控制，需要手动创建和提交事务。Spring 提供了一个名为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值