Spring的事务管理--声明式事务

最新推荐文章于 2022-04-10 20:27:20 发布
原创 最新推荐文章于 2022-04-10 20:27:20 发布 · 271 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #事务管理 #声明式事务

本文详细介绍了Spring中声明式事务的两种实现方式：XML配置和注解方式，包括环境搭建、转账示例、异常处理及测试流程。

Spring的事务管理–声明式事务

一、XML方式的声明式事务

  1. 搭建Spring的事务管理环境,演示转账
    • 创建maven项目引入pom
    • 创建数据库与表，初始化一些数据
    • 创建实体对象
    • 创建Service的接口和实现类
    • 创建Dao的接口和实现类
    • 配置Service和Dao，交给Spring，及其他
  • 创建数据库与表
CREATE TABLE `account` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `name` varchar(20) COLLATE utf8mb4_bin DEFAULT NULL,
      `money` double DEFAULT NULL,
      PRIMARY KEY (`id`)
    )
  • pom
 <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <spring.version>4.3.18.RELEASE</spring.version>
    <mysql.version>5.1.8</mysql.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>


    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</version>
    </dependency>


    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
      <scope>compile</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/log4j/log4j -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.2</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!--  druid相关pom-->
    <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.10</version>
    </dependency>


      <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-aop</artifactId>
          <version>${spring.version}</version>
      </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.2</version>
    </dependency>


  </dependencies>
  • service
public interface AccountService {
    /**
     * 转账
     * @param form 转出账号
     * @param to 转入账号
     * @param money 金额
     */
    void transfer(String form,String to,Double money);
}
  • serviceImpl
public class AccountServiceImpl implements AccountService {
    /**
     * 注入Dao
     */
    private AccountDao accountDao;

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


    @Override
    public void transfer(String form, String to, Double money) {
        accountDao.outMoney(form, money);
        // 人为异常，测试异常转账时打开
        int a = 5 / 0;
        accountDao.inMoney(to, money);
    }
}
  • dao
public interface AccountDao {
    /**
     * 转出
     * @param from
     * @param money
     */
    void outMoney(String from ,Double money);

    /**
     * 转入
     * @param to
     * @param money
     */
    void inMoney(String to ,Double money);
}
  • daoImpl
public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
    @Override
    public void outMoney(String from, Double money) {
        String sql = "update account set money = money - ? where name=?";
        this.getJdbcTemplate().update(sql,money,from);
    }

    @Override
    public void inMoney(String to, Double money) {
        String sql = "update account set money = money + ? where name=?";
        this.getJdbcTemplate().update(sql,money,to);
    }
}
  • 配置事务管理器
 <!--配置平台事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
  • 配置增强
<!-- 配置事务的增强-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="transfer" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
  • 配置AOP
 <!--配置AOP-->
    <aop:config>
        <aop:pointcut id="pointcut1" expression="execution(* edu.xufe.tx.service.impl.AccountServiceImpl.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
    </aop:config>
  • jdbc.properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///springdemo07
jdbc.username=root
jdbc.password=mysql
  • 完整的applicationContext.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: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/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 配置service-->
    <bean id="accountService" class="edu.xufe.tx.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>
    <!--配置Dao-->
    <bean id="accountDao" class="edu.xufe.tx.dao.impl.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--第二种方式 通过context标签引入-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--配置Druid连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!--配置平台事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 配置事务的增强-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="transfer" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    <!--配置AOP
    aop:advisor 单个切入点
    aop:aspect  多个切入点-->
    <aop:config>
        <aop:pointcut id="pointcut1" expression="execution(* edu.xufe.tx.service.impl.AccountServiceImpl.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
    </aop:config>
    <!-- 配置事务管理的模板类-->
    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
        <property name="transactionManager" ref="transactionManager"/>
    </bean>
</beans>
  1. 编写测试，演示正常转账和转账过程中出现异常的情况
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class AccountServiceTest {
    @Resource(name = "accountService")
    private AccountService accountService;

    @Test
    public void testTransfer() {
        accountService.transfer("如花", "如花1", 500d);
    }
}

二、注解方式的声明式事务

  1. 恢复环境取消在applicationContext.xml中的AOP配置与争抢
    取消后的applicationContext.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: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/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 配置service-->
    <bean id="accountService" class="edu.xufe.tx.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>
    <!--配置Dao-->
    <bean id="accountDao" class="edu.xufe.tx.dao.impl.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--第二种方式 通过context标签引入-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--配置Druid连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!--配置平台事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 配置事务的增强-->
    <!--<tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="transfer" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>-->
    <!--配置AOP
    aop:advisor 单个切入点
    aop:aspect  多个切入点-->
    <!--<aop:config>
        <aop:pointcut id="pointcut1" expression="execution(* edu.xufe.tx.service.impl.AccountServiceImpl.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
    </aop:config>-->

    <!--开启事务注解-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    <!-- 配置事务管理的模板类-->
    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
        <property name="transactionManager" ref="transactionManager"/>
    </bean>
</beans>
  1. 开启注解事务
<!--开启事务注解-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
  1. 在业务层添加事务管理的注解
    @Transactional(isolation = Isolation.DEFAULT,propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    4.编写测试，演示正常转账和转账过程中出现异常的情况
    源代码github：https://github.com/greatdistance/spring_project_demo/tree/master/springdemo09
Spring事务管理-积分功能实现
03-23
基于tx命名空间的声明式事务管理案例
精选资源
Spring声明式事务配置管理方法
03-02
发布于2013-5-6项目使用SSH架构，现在要添加Spring事务管理功能，针对当前环境，只需要添加Spring2.0AOP类库即可。添加方法：点击项目右键->BuildPath->Addlibrarys:打开AddLibraries对话框，然后选定...
Spring 事物管理
yong1828
06-18 230
来自：http://hi.baidu.com/fytcm/blog/item/074a82ed3821a54c78f0559e.html 通常建议采用声明式事务管理。声明式事务管理的优势非常明显：代码中无需关于关注事务逻辑，让Spring声明式事务管理负责事务逻辑，声明式事务管理无需与具体的事务逻辑耦合，可以方便地在不同事务逻辑之间切换。 声明式事务管理的配置方式，通常有如下三种： 1....
Spring事务：声明式事务管理
侠客行
12-30 257
一、背景        在Spring事务：编程式事务管理这一篇中简单的介绍了Spring中的编程式事务管理，本篇介绍下Spring中声明式事务管理。   二、声明式事务管理 1、Spring中声明式事务管理概述        Spring中的声明式事务管理在底层是建立在AOP的基础上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或加入一个事务，在执行完目标方法之后，根据...
Spring 声明式事务管理
weixin_33795093的博客
12-24 98
声明事务可以省去手动添加事务以及异常处理的麻烦。     注解方式：   &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-...
Spring 声明式事务管理
没长正
10-18 403
Spring 声明式事务管理 声明式事务管理方法允许你在配置的帮助下而不是源代码硬编程来管理事务。这意味着你可以将事务管理从事务代码中隔离出来。你可以只使用注释或基于配置的 XML 来管理事务。 bean 配置会指定事务型方法。这是与声明式事务相关的步骤： 我们使用 标签，它创建一个事务处理的建议，同时，我们定义一个匹配所有方法的切入点，我们希望这些方法是事务型的并且会引用事务
org.springframework.jdbc.datasource.DataSourceTransactionManager不回滚
angie
10-20 8884
先说一下我的目录结构 １、maven项目； ２、spring applicationContext.xml放在resources目录下 ３、transactionManager datasource定义在applicationContext.xml中,在web.xml中org.springframework.web.context.ContextLoaderListener加载 ４、spr...
spring-tx-5.0.0.0.RELEASE.jar_java开发_spring-tx-5.0.0_
09-30
声明式事务管理是Spring的一个强大特性，允许开发者通过简单的注解或XML配置来控制事务边界，从而极大地简化了事务处理代码。Spring TX 5.0.0.0.RELEASE.jar作为这个版本的发布，包含了所有必要的类和资源，使得...
使用Spring的声明式事务----AOP方式
08-06
在Spring框架中，声明式事务管理是通过AOP（面向切面编程）实现的，它为开发者提供了方便、高效且灵活的事务管理机制。本文将深入探讨如何利用Spring的声明式事务来处理业务操作中的数据一致性问题，以及相关源码...
精选资源
spring 自定义事务管理器，编程式事务，声明式事务@Transactional使用
07-13
本教程将深入探讨如何在Spring中实现自定义事务管理器、编程式事务处理以及声明式事务`@Transactional`的使用。 首先，让我们了解事务管理的基本概念。事务是一组数据库操作，这些操作要么全部执行，要么全部回滚，...
设置Spring Boot 单元测试自动提交事务(不回滚)
Dangerous
09-30 5022
在编写单元测试时，如下代码发现数据库更改没有成功 @SpringBootTest(webEnvironment= SpringBootTest.WebEnvironment.NONE) class UserMapperTest { @Autowired private UserMapper userMapper; @Test @Transactional void updateUser(){ User user = new User();
Spring多数据源TransactionManager冲突解决方案
苦行僧
04-10 9521
文章目录现象Spring 事务机制报错原因及解决方案 现象 近期做了一个业务需求，需要增加多数据源，同时对事务也进行了配置，待发布上线后出现使用 @Transactional 注解的方法抛出 NoUniqueBeanDefinitionException 异常：No qualifying bean of type ‘org.springframework.transaction.PlatformTransactionManager’ available: expected single matching b
spring 配置文件datasource.properties
okkeqin的专栏
08-29 2834
datasource.properties db.jdbcurl=jdbc:oracle:thin:@xxx.xxx.xx.xx:1521:orcl #db.jdbcurl=jdbc:mysql://xx.xx.xx.xx:3306/portalms #db.user=xxx #db.password=xxx db.driverclass=oracle.jdbc.driver.Ora
在搭建分布式事务txlcn-tm服务端时遇到坑及解决方案
tianlong1569的专栏
06-27 9788
接上文：https://blog.csdn.net/tianlong1569/article/details/91355263 二、在搭建过程中遇到的坑 1、在搭建txlcn-tm服务端时遇到的坑 由于我在搭建txlcn-tm服务端时直接引入了tm包，代码如下： <dependency> <groupId>com.codingapi.txlcn</...
springBoot配置
日常收获
10-31 534
springBoot配置 ＃---------------------------------------- ＃核心特性 ＃---------------------------------------- #BANNER banner.charset = UTF-8＃横幅文件编码。 banner.location = classpath：banner.txt＃横幅文件位置。 banner.imag...
Spring事务管理的两种方式
qq_43670845的博客
04-17 797
spring支持编程式事务管理和声明式事务管理两种方式。 1.编程式事务 编程式事务使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。 2.声明式事务 声明式事务是建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，...
spring boot系列之开启声明式事务
大佬请赐教
02-18 1086
spring boot开启事务只需要一个简单的注解@Transactional，它默认已经对jdbc、jpa、mybatis开启了事务，引入它们依赖的时候，事物就默认开启，如果是其它的orm框架如beetlsql，则需要自行配置事务管理器。这里基于xml来实现spring boot对mybatis的访问。 第一步：pom引入mybatis依赖、mysql依赖和druid连接池依赖 &lt;depe...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值