【Spring】spring中基于事务控制的API：PlatformTransactionManager的案例

最新推荐文章于 2021-02-23 19:34:12 发布
最新推荐文章于 2021-02-23 19:34:12 发布
阅读量863 收藏
点赞数
分类专栏： 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JJ_Notebook/article/details/106108507
版权

目录


Spring的事务管理都是基于AOP，它可以通过编程实现，也可以通过配置的方法实现。
Spring为我们提供了一套用于事务控制的API。 

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.2.6.RELEASE</version>
</dependency>
  • 为我们提供的PlatformTransactionmanager接口包含了常用的操作事务的方法，比如：获取事务、提交事务、回滚事务。

基于xml的声明式事务控制案例

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mj</groupId>
    <artifactId>day03_01account</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!--spring整合junit jar包x
            需配合junit4.12以上的版本-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.19</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
        <!-- AspectJ -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
    </dependencies>
 </project>

持久层代码

package com.mj.dao;

import com.mj.domain.Account;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import java.util.List;

public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {


    @Override
    public void insertAccount(Account account) {
        super.getJdbcTemplate().update("insert into account(name,money) values (?,?)",account.getName(),account.getMoney());
    }

    @Override
    public void updateAccount(Account account ) {
        super.getJdbcTemplate().update("update account set name=? ,money=? where id =?",account.getName(),account.getMoney(),account.getId());
    }

    @Override
    public List<Account> findAllAccount() {
        List<Account> accounts=super.getJdbcTemplate().query("select * from account",new BeanPropertyRowMapper<Account>(Account.class));
        return accounts;
    }

    @Override
    public Account findAccountByName(String name) {
        List<Account> accounts=super.getJdbcTemplate().query("select * from account where name=?",new BeanPropertyRowMapper<Account>(Account.class),name);
        return accounts.get(0);
    }
}

服务层代码

package com.mj.service;

import com.mj.dao.IAccountDao;
import com.mj.domain.Account;

import java.util.List;

public class AccountService {

    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public List<Account> findAllAccount(){
          return accountDao.findAllAccount();

    }

    public Account findAccountByName(String name){

     return accountDao.findAccountByName(name);

    };


    public void transfer(String sourceName, String targetName, Integer tMoney) {

        Account sourceA = accountDao.findAccountByName(sourceName);
        Account targetA = accountDao.findAccountByName(targetName);
        sourceA.setMoney(sourceA.getMoney() - tMoney);
        targetA.setMoney(targetA.getMoney() + tMoney);
        int i=1/0;//异常
        accountDao.updateAccount(sourceA);
        accountDao.updateAccount(targetA);
    }
}

xml配置文件

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 配置服务层对象 -->
    <bean id="accountService" class="com.mj.service.AccountService">
        <property name="accountDao" ref="accountDao"></property>
    </bean>
    <!-- 配置持久层对象 -->
    <bean id="accountDao" class="com.mj.dao.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--配置数据源
      set方法注入-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!-- AbstractComboPooledDataSource类中的set方法-->
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mytest?serverTimezone=GMT"/>
        <property name="username" value="root"/>
        <property name="password" value="1234567890"/>
    </bean>
    <!-- spring中基于xml的声明式事务控制配置步骤
       1. 配置事务管理器
       2. 配置事务的通知
          用标签tx:advice
                属性：id：事务的通知的唯一标志
                      transaction-manager:给事务通知提供一个事务管理器引用
       3.配置AOP的切入点表达式
       4.配置切入点表达式与通知的对应关系

                      -->
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--配置事务的通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--配置事务的属性
        isolation=用于指定事务的隔离级别，默认值是DEFAULT，表示使用数据库默认的隔离级别
        rollback-for=用于指定一个异常，遇到该异常时回滚，其他异常不回滚，默认表示任何异常都回滚
        no-rollback-for=用于指定一个异常，遇到该异常时不回滚，其他异常回滚，默认表示任何异常都不回滚
        propagation=表示指定事务的传播行为，默认值是REQUIRED,表示一定会有事务，适用于增删改，查询可以选择SUPPORTS
        read-only=指定事务是否只读，只有查询方法才能设置为true。默认为false，表示读写。
        timeout=表示事务的超时时间，默认为-1，表示无超时时间。单位为秒
 -->
        <tx:attributes>
            <!--  配置属性-->
            <!--所有方法-->
            <tx:method name="*"  propagation="REQUIRED" read-only="false" />
            <!--以find开头的方法开启只读-->
            <tx:method name="find*"  propagation="SUPPORTS" read-only="true" />
        </tx:attributes>
    </tx:advice>

    <!--配置AOP-->
    <aop:config >
        <aop:pointcut id="pt" expression="execution(* com.mj.service.*.*(..))"></aop:pointcut>
        <!-- 配置切入点表达式与通知的对应关系-->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt" ></aop:advisor>
    </aop:config>
</beans>

测试案例

import com.mj.dao.AccountDaoImpl;
import com.mj.domain.Account;
import com.mj.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {
    @Autowired
    public AccountService as;
    @Test
    public void transfer() {
   //从鬼鬼的账户中向里里的账户存入一笔钱
      ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
      AccountService as=ac.getBean("accountService",AccountService.class);
      System.out.println(as.findAccountByName("里里"));
       as.transfer("里里","鬼鬼",100);
    }
}

基于注解的案例修改

持久层

package com.mj.dao;

import com.mj.domain.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import org.springframework.stereotype.Repository;

import java.util.List;
@Repository("accountdao")
public class AccountDaoImpl  implements IAccountDao {
    @Autowired
    JdbcTemplate jt;

    @Override
    public void insertAccount(Account account) {
        jt.update("insert into account(name,money) values (?,?)",account.getName(),account.getMoney());
    }

    @Override
    public void updateAccount(Account account ) {
      jt.update("update account set name=? ,money=? where id =?",account.getName(),account.getMoney(),account.getId());
    }

    @Override
    public List<Account> findAllAccount() {
        List<Account> accounts=jt.query("select * from account",new BeanPropertyRowMapper<Account>(Account.class));
        return accounts;
    }

    @Override
    public Account findAccountByName(String name) {
        List<Account> accounts=jt.query("select * from account where name=?",new BeanPropertyRowMapper<Account>(Account.class),name);
        return accounts.get(0);
    }
}

配置类

Jdbc配置

package Configuration;

import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

import javax.sql.DataSource;

public class JdbcConfig {

    @Bean(name = "JdbcTemplate")
    public JdbcTemplate createJdbcTemplate(DataSource dataSource){
        return new JdbcTemplate(dataSource);
    }
    @Bean("dataSource")
    public DataSource createDataSource() {
        DriverManagerDataSource ds = new DriverManagerDataSource();
        ds.setDriverClassName("com.mysql.cj.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/mytest?serverTimezone=GMT");
        ds.setUsername("root");
        ds.setPassword("1234567890");
        return ds;
    }
    
}

事务控制类配置

package Configuration;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;

public class TxConfig {

    @Bean(name = "txManager")
    public PlatformTransactionManager createTx(@Qualifier("dataSource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }
}

总配置

package Configuration;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration//声明当前类为配置类
@ComponentScan(basePackages="com.mj")//指明创建容器时扫描的包
@Import({JdbcConfig.class,TxConfig.class})//导入其他配置文件
@EnableTransactionManagement//开启事务支持
public class SpringTxConfiguration {

}

服务层

将要使用事务控制的方法标上@Transactional注解
观察以下源码可以发现@Transactional注解包含了隔离级别、超时、只读、回滚等的事务管理。

public @interface Transactional {
    @AliasFor("transactionManager")
    String value() default "";

    @AliasFor("value")
    String transactionManager() default "";

    Propagation propagation() default Propagation.REQUIRED;

    Isolation isolation() default Isolation.DEFAULT;

    int timeout() default -1;

    boolean readOnly() default false;

    Class<? extends Throwable>[] rollbackFor() default {};

    String[] rollbackForClassName() default {};

    Class<? extends Throwable>[] noRollbackFor() default {};

    String[] noRollbackForClassName() default {};
}
package com.mj.service;
import com.mj.dao.IAccountDao;
import com.mj.domain.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
@Service("accountService")
@Transactional(propagation =Propagation.SUPPORTS ,readOnly = true)
public class AccountService {
    @Autowired
    private IAccountDao accountDao;

    public List<Account> findAllAccount(){
          return accountDao.findAllAccount();

    }
    public Account findAccountByName(String name){

     return accountDao.findAccountByName(name);
    };

  @Transactional(propagation = Propagation.REQUIRED ,readOnly = false)
    public void transfer(String sourceName, String targetName, Integer tMoney) {

    Account sourceA = accountDao.findAccountByName(sourceName);
    Account targetA = accountDao.findAccountByName(targetName);
        sourceA.setMoney(sourceA.getMoney() - tMoney);
        targetA.setMoney(targetA.getMoney() + tMoney);
        accountDao.updateAccount(sourceA);
    int i=1/0;//设置异常
        accountDao.updateAccount(targetA);
}
}

测试代码

import Configuration.SpringTxConfiguration;
import com.mj.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringTxConfiguration.class)
public class AnnotationTest {
    @Autowired
    public AccountService as;
    @Test
    public void test(){
        System.out.println(as.findAccountByName("里里"));
        as.transfer("里里","鬼鬼",100);
    }
}
JJ_Notebook
关注
专栏目录
【Spring笔记08】Spring中的事务（编程式、声明式）
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
06-01 452
这篇文章，主要介绍Spring中的两种事务，编程式事务和基于XML方式的声明式事务。 目录 一、Spring中事务 1.1、什么是事务 1.2、Spring两种事务 （1）数据源配置 1.3、编程式事务 1.4、声明式事务 （1）XML中添加【tx】命名空间 （2）配置事务管理器 （3）配置事务通知 （4）配置事务切面 （5）编写事务处理类方法 （6）编写测试类 一、Spring中事务 1.1、什么是事务 事务，是指将很多件事情看成一个整体，这些事情要么全部执行成功，要么.
深入理解 Spring 事务的钩子函数
最新发布
fudaihb的博客
06-14 1015
在现代企业级应用开发中，事务管理是一个至关重要的概念。它确保了一系列操作要么全部成功，要么全部失败，从而保持系统数据的一致性和完整性。Spring Framework 提供了强大的事务管理功能，其中事务钩子函数（Transaction Hook）是一个重要但常被忽视的特性。本篇博客将详细探讨 Spring 事务的钩子函数，帮助开发者更好地理解和利用这一特性。
分布式事务系列（1.1）Spring事务管理器PlatformTransactionManager
weixin_34032779的博客
05-15 905
2019独角兽企业重金招聘Python工程师标准>>> ...
spring事务管理之PlatformTransactionManager
shdxl的博客
09-24 515
1.  PlatformTransactionManager 平台事务管理器,它是事务的核心接口,主要方法如下:          * void commit(TransactionStatus status)  提交事务          * TransactionStatus getTransaction(TransactionDefinition definition)     ...
零基础SSM入门教程(38)–基于PlatformTransactionManager的编程式事务管理
程序员大阳
02-02 3070
编程式事务管理 所谓编程式事务管理，就是使用普通的程序代码来管理事务，像上一篇原生JDBC事务实现就是编程式的。 与编程式事务相对应的就是声明式事务管理，通过对方法或类添加注解的方式，声明该方法或类开启事务。很明显声明式事务代码量更少更加简单，更加高级，平时用的也更多，但是我们还是从最基础的编程式事务开始讲起。 具体实现 PlatformTransactionManager是Spring封装好接口...
Spring 5.x 源码之旅六十八深入AOP事务原理五
王伟王胖胖的博客
04-06 464
Spring 5.x 源码之旅六十八深入AOP事务原理五传播机制图AbstractPlatformTransactionManager的processRollback处理回滚AbstractTransactionStatus的rollbackToHeldSavepoint回滚到保存点JdbcTransactionObjectSupport的rollbackToSavepoint回滚到保存点Data...
Spring事务管理
starryheavens的专栏
05-17 436
1         初步理解 事务有四个特性：ACID   原子性（Atomicity）：事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用。 一致性（Consistency）：一旦事务完成（不管成功还是失败），系统必须确保它所建模的业务处于一致的状态，而不会是部分完成部分失败。在现实中的数据不应该被破坏。 隔离性（Isolation）：可能有许多事
spring 事务
JAVA开发者@邢先生
02-23 249
- 事务特征（ACID） - 原子性（Atomicity）指事务是一个不可分割的整体，其中的操作要么全执行或全不执行 - 一致性（Consistency）事务前后数据的完整性必须保持一致 - 隔离性（Isolation）事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离 - 持久性（Durability）持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响
4.Spring中的JdbcTemplate,Spring中的的事务，
11-15
#### Spring事务控制的基础概念 Spring框架支持两种类型的事务管理：编程式事务管理和声明式事务管理。 - **编程式事务管理**：通过编码的方式来管理事务，适用于需要细粒度控制的情况。 - **声明式事务管理**：...
spring案例.zip|spring案例.zip
12-01
在本案例中，我们将深入探讨Spring的核心特性，包括事务管理、数据访问、以及配置方式。 首先，让我们来看看Spring的事务管理。事务管理是确保业务操作原子性、一致性、隔离性和持久性的关键部分。Spring提供了两种...
Spring事务管理（详解+实例）
热门推荐
Trigl的博客
03-25 8万+
写这篇博客之前我首先读了《Spring in action》，之后在网上看了很多关于Spring事务管理的文章，具体参考文章如下： 1、将相应的接口依赖图理清出 2、将每个类的具体配置弄明白 3、将具体的配置给出来 4、给出具体的例子（一个声明式的一个编程式的）
创建基于uflo工作流引擎的maven项目的方法
hsg77的专栏
02-10 741
创建基于uflo工作流引擎的maven项目的方法 一、先看运行后的效果 二、创建一个maven工程的一个容器工程pg-plugin 工程名称：pg-plugin 采用Intellij IDEA开发环境 先创建一个父容器工程pg-plugin 点击菜单 File/New/Project 在新弹出窗体New Project中选择Maven项右边不选Create from archetype项， 直接点击Next按钮 GroupId:com.puri ArtifactId:pg-plugin Version:1
Spring Boot 使用事务PlatformTransactionManager
maicose的专栏
03-19 1万+
Spring Boot 使用事务非常简单，首先使用注解 @EnableTransactionManagement 开启事务支持后，然后在访问数据库的Service方法上添加注解 @Transactional 便可。 关于事务管理器，不管是JPA还是JDBC等都实现自接口 PlatformTransactionManager 如果你添加的是 spring-boot-starter-jdbc 依赖，...
Springboot使用PlatformTransactionManager接口的事务处理
HiterCoder
11-25 3104
1、SpringBoot中可以使用PlatformTransactionManager接口来实现事务的统一控制，而进行控制的时候也可以采用注解或者AOP切面配置形式来完成，建议进行Aop切面进行事务管理，但是要写好注释，不然一些人后期找代码逻辑很容易看懵逼的。 在业务层的方法上启用事务控制，可以加到方法上，也可以加到该业务类上，根据自己的需求来进行。 1 package com.de...
spring 编程式事务管理—PlatformTransactionManager
shendeguang的专栏
11-06 3489
JDBC的事务管理在Spring2.0下有两种编程式的实现 PlatformTransactionManager TransactionTemplate 对于PlatformTransctionManager，通常，不直接使用它，而是使用它的实现类DataSourceTransactionManager。具体用法如下： 1. 实例化的时候，需要用个数据源作参数 2. 建立事务的定
搞懂Spring提供的事务管理接口PlatformTransactionManager
多凡的博客
07-28 4781
spring框架为我们提供了一组事务控制的接口，这组接口是在 spring-tx-5.0.2.RELEASE.jar 中。 PlatformTransactionManager此接口是 spring 的事务管理器 开发中我们都是使用它的实现类， 真正管理事务的对象 org.springframework.jdbc.datasource.DataSourceTransactionManager 使...
事务PlatformTransactionManager
让我做你的眼睛
01-29 2万+
1.事务三大接口 PlatformTransactionManager 事务管理器 TransactionDefinition 事务的一些基础信息，如超时时间、隔离级别、传播属性等 TransactionStatus 事务的一些状态信息，如是否一个新的事务、是否已被标记为回滚 2.PlatformTransactionManager public interface PlatformTr...
Spring学习04:事务控制(TransactionManager)
ncepu_Chen的博客
07-06 1万+
Spring学习04:事务控制[TransactionManager]Spring事务控制Spring中事务控制的API使用Spring进行事务控制Spring配置式事务控制项目准备使用xml配置事务控制使用半注解配置事务控制使用纯注解式事务配置Spring编程式事务控制 Spring事务控制 JavaEE 体系进行分层开发,事务处理位于业务层,Spring提供了分层设计业务层的事务处理解决方 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值