Spring AOP—声明式事务(介绍+案例)

最新推荐文章于 2023-05-19 20:32:16 发布
最新推荐文章于 2023-05-19 20:32:16 发布
阅读量1.2k 收藏 4
点赞数
分类专栏： SSM 文章标签： spring mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45112292/article/details/114963980
版权

Spring AOP声明式事务(详细+案例)

文章目录

1、事务一般分为两类：

编程式事务：在代码中直接加入处理事务的逻辑，可能需要在代码中显式调用beginTransaction()、commit()、rollback()等事务管理相关的方法

声明式事务：在方法的外部添加注解或者直接在配置文件中定义，将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。spring的AOP恰好可以完成此功能：事务管理代码的固定模式作为一种横切关注点，通过AOP方法模块化，进而实现声明式事务。

2、声明式事务的简单配置

​ Spring从不同的事务管理API中抽象出了一整套事务管理机制，让事务管理代码从特定的事务技术中独立出来。开发人员通过配置的方式进行事务管理，而不必了解其底层是如何实现的。

​ Spring的核心事务管理抽象是PlatformTransactionManager。它为事务管理封装了一组独立于技术的方法。无论使用Spring的哪种事务管理策略(编程式或声明式)，事务管理器都是必须的。

  1. 导入坐标（直接导入即可）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>org.example</groupId>
    <artifactId>mashibing_spring_oap_02</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>

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

        <!-- https://mvnrepository.com/artifact/aopalliance/aopalliance -->
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

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

        <!--springioc的配置-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>

        <!--添加数据库连接池-->
        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.1</version>
        </dependency>

        <!--添加数据库支持-->
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <!--添加JdbcTemplate支持-->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-orm -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>


    </dependencies>

</project>

  2. 添加配置文件（最重要的是添加事务管理器）applictionContext.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">

    <!--开启注解扫描包-->
    <context:component-scan base-package="com.aop"></context:component-scan>
    <!--开启加载properties配置文件-->
    <context:property-placeholder location="dbconfig.properties"></context:property-placeholder>
    <!--开启基于注解的事务控制模式，依赖tx名称空间-->
    <tx:annotation-driven transaction-manager="TransactionManager"></tx:annotation-driven>
    
    <!--注入数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${password}"></property>
        <property name="url" value="${url}"></property>
        <property name="driverClassName" value="${driverClassName}"></property>
    </bean>

    <!--配置JdbcTemplate-->
    <bean id="template" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>


    <!--添加事务管理-->
    <bean id="TransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

</beans>

  3. 添加properties文件，存放数据库登录信息。

    作用：数据库登录信息不用在appliction.xml中直写死，增加灵活性。

    jdbc.username=root
password=root
url=jdbc:mysql://localhost:3306/hm
driverClassName=com.mysql.jdbc
3、环境准备（模拟转账）
  • 类目录

类目录

  1. 数据库准备

    创建account数据库

在类目录

  1. 创建实体类对象（Account,java实体类）

    package com.aop.bean;

public class Account {
    private String name;
    private int money;

    public String getName() {
        return name;
    }

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

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "AccountDaoImpl{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

  2. 创建持久层接口（accountDao.java）

    package com.aop.dao;
public interface accountDao {

    //查询余额
    public Integer selectBalance(String name);
    //账户加钱
    public void addmoney(String name,int money);
    //账户减钱
    public void lessmoney(String name,int money);
    
}

  3. 实现持久层接口（AccountDaoImpl.java）

    package com.aop.dao.Impl;
import com.aop.dao.accountDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class AccountDaoImpl implements accountDao {

    @Autowired
    JdbcTemplate template;

    //查询账户余额
    @Override
    public Integer selectBalance(String name) {
        String sql = "SELECT money FROM account WHERE NAME=?";
        Integer integer = template.queryForObject(sql, Integer.class, name);
        return integer;
    }

    //账户加钱
    @Override
    public void addmoney(String name, int money) {
        String sql = "UPDATE account SET money=money+? WHERE NAME=?";
        template.update(sql, money, name);
    }

    //账户减钱
    @Override
    public void lessmoney(String name, int money) {
        String sql = "UPDATE account SET money=money-? WHERE NAME=?";
        template.update(sql, money, name);
    }
}

  4. 创建业务层（accountservice.java）

    package com.aop.service;

import com.aop.dao.Impl.AccountDaoImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class accountservice {

    @Autowired
    AccountDaoImpl dao;
    //模拟转账
    public void Transfer(String addname,String lessname,int money){
        //账户加钱
        dao.lessmoney(lessname,money);
        //账户加钱
        dao.addmoney(addname,money);
    }
}

  5. 进行测试（测试成功）

4、事务配置的属性

@Transactional：

​ isolation：设置事务的隔离级别

​ propagation：事务的传播行为

​ noRollbackFor：那些异常事务可以不回滚

​ noRollbackForClassName：填写的参数是全类名

​ rollbackFor：哪些异常事务需要回滚

​ rollbackForClassName：填写的参数是全类名

​ readOnly：设置事务是否为只读事务

​ timeout：事务超出指定执行时长后自动终止并回滚,单位是秒

5、测试超时属性：
  • @Transactional(timeout = 3)

accountservice.java

package com.aop.service;

import com.aop.dao.Impl.AccountDaoImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class accountservice {

    @Autowired
    AccountDaoImpl dao;

    //方法执行超过3秒则回滚
    @Transactional(timeout = 3)
    public void Transfer(String addname,String lessname,int money) throws InterruptedException {
        //账户减钱
        dao.lessmoney(lessname,money);
     //等待3秒
        Thread.sleep(3000);
          //账户加钱
        dao.addmoney(addname,money);
    }
}

执行结果为账户余额都不改变，因为方法执行时间超过3秒，事务回滚。

6、设置事只读：
  • @Transactional(readOnly= true)

如果你一次执行单条查询语句，则没有必要启用事务支持，数据库默认支持SQL执行期间的读一致性；

​ 如果你一次执行多条查询语句，例如统计查询，报表查询，在这种场景下，多条查询SQL必须保证整体的读一致性，否则，在前条SQL查询之后，后条SQL查询之前，数据被其他用户改变，则该次整体的统计查询将会出现读数据不一致的状态，此时，应该启用事务支持。

​ 对于只读查询，可以指定事务类型为readonly，即只读事务。由于只读事务不存在数据的修改，因此数据库将会为只读事务提供一些优化手段

**测试：**accountservice.java

package com.aop.service;

import com.aop.dao.Impl.AccountDaoImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class accountservice {

    @Autowired
    AccountDaoImpl dao;

    //方法执行超过3秒则回滚
    @Transactional(readOnly= true)
    public void Transfer(String addname,String lessname,int money) throws InterruptedException {
        //账户减钱
        dao.lessmoney(lessname,money);
          //账户加钱
        dao.addmoney(addname,money);
    }
}
7、设置哪些异常不回滚

  • noRollbackFor：哪些异常事务可以不回滚

  • noRollbac出现orClassName：填写的参数是全类名

    当方法中发现异常，要求即使方法中出现异常也不要回滚

    **测试：**accountservice.java

package com.aop.service;

import com.aop.dao.Impl.AccountDaoImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class accountservice {

    @Autowired
    AccountDaoImpl dao;

    //方法执行超过3秒则回滚
    @Transactional(noRollbackFor = {ArithmeticException.class, NullPointerException.class})
    public void Transfer(String addname, String lessname, int money) throws InterruptedException {
        //账户减钱
        dao.lessmoney(lessname, money);
        //账户加钱
        dao.addmoney(addname, money);
        int i = 9 / 0;
    }
}

---
    package com.aop.service;

import com.aop.dao.Impl.AccountDaoImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class accountservice {

    @Autowired
    AccountDaoImpl dao;

    //方法执行超过3秒则回滚
    @Transactional(noRollbackForClassName = {"java.lang.ArithmeticException")
    public void Transfer(String addname, String lessname, int money) throws InterruptedException {
        //账户减钱
        dao.lessmoney(lessname, money);
        //账户加钱
        dao.addmoney(addname, money);
        int i = 9 / 0;
    }
}
  • 注意：
    1. 不会回滚指的是走到异常的语句后，发现异常，提交事务，并不会继续往下执行语句，比如将异常放在dao.lessmoney(lessname, money);和 dao.addmoney(addname, money);中间，上方会执行，而下面不会方法执行
    2. 若把异常捕获，则两个方法都可以执行
8、设置异常回滚

  • rollbackFor：哪些异常事务需要回滚

  • rollbackForClassName：填写的参数是全类名

    **测试：**accountservice.java

    package com.aop.service;

import com.aop.dao.Impl.AccountDaoImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.FileNotFoundException;

@Service
public class accountservice {

    @Autowired
    AccountDaoImpl dao;

    //方法执行超过3秒则回滚
    @Transactional(rollbackFor = {FileNotFoundException.class})
    public void Transfer(String addname, String lessname, int money) throws InterruptedException {
        //账户减钱
        dao.lessmoney(lessname, money);
        //账户加钱
        dao.addmoney(addname, money);
            int i = 9 / 0;
    }
}
    9、设置隔离级别
    10、设置传播特性

隔离级别和传播特性比较复杂需要讲的比较详细，在下一篇进行详细总结！

总结：

  1. 事务分为两类：编程式事务和声明式事务

  2. 事务的属性

    ​ isolation：设置事务的隔离级别

    ​ propagation：事务的传播行为

    ​ noRollbackFor：那些异常事务可以不回滚

    ​ noRollbackForClassName：填写的参数是全类名

    ​ rollbackFor：哪些异常事务需要回滚

    ​ rollbackForClassName：填写的参数是全类名

    ​ readOnly：设置事务是否为只读事务

    ​ timeout：事务超出指定执行时长后自动终止并回滚,单位是秒

  3. 对事务的属性进行测试，利用转账案例进行测试。

Spring-声明式事务实例（有详细注释）
m0_61160520的博客
03-23 1297
基本注解的声明式事务： 事务控制 事务只读 超时时间 事务异常 事务隔离级别 事务传播行为
Spring 之声明式事务和 Spring Junit 案例应用详解
最新发布
zp8126的专栏
03-20 634
在前面测试中，每次从spring 容器中获取 bean 都需要实例化 ApplicationContext ，相对麻烦，可以考虑使用 Spring-test 完成测试Spring Test 是 Spring Framework 提供的一系列测试支持工具，它为开发者提供了在单元测试和集成测试中模拟 Spring 上下文、依赖注入（DI）和事务管理的能力。
[Spring]AOP应用及简单案例——声明式事务
啦啦啦
09-10 575
既然事务控制的代码有规律可循，代码的结构基本是确定的，所以框架就可以将固定模式的代码抽取出来，进行相关的封装。
Spring 声明式事务实例
春风化雨
01-06 359
1、测试类 package com.tx.sm; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.jdbc.core.JdbcTemplate; import java.util.List; import java.util.Map; public class TestTransaction3 { public stat
Spring声明式事务管理，通过Spring AOP实现
tezhan120的专栏
04-10 3130
Spring声明式事务管理，通过Spring AOP实现声明式事务管理:  引自：http://www.javaeye.com/post/343748  Spring也提供了声明式事务管理。这是通过Spring AOP实现的。  Spring中进行事务管理的通常方式是利用AOP（面向切片编程）的方式，为普通java类封装事务控制，它是通过动态代理实现的，由于接口是延迟实例化的，spring在这段时
SpringAOP声明式事务基础
Herbal_的博客
06-20 367
文章目录SpringAOP声明式事务基础事务管理器声明式事务配置的两种基本方式:XML配置方式注解配置方式Spring事务的传播行为和隔离级别:七种传播行为：五种隔离级别：关键词：回滚事务：回滚特定异常不回滚特定异常 SpringAOP声明式事务基础 事务管理器 Spring在jdbc中提供了一个事务管理组件： PlatformTransactionManager DataSourceTran...
Java框架技术 Spring 学习案例 Spring AOP案例和Spring事务处理案例
03-20
在"转账业务追加日志"案例中，我们可以使用声明式事务管理，通过在服务方法上添加@Transactional注解来开启事务。如果转账过程中出现任何异常，事务会自动回滚，确保数据的一致性。同时，我们还可以通过AOP记录转账...
Spring AOP实现声明式事务配置实践教程
本文详细介绍了Spring AOP声明式事务配置的核心概念和实现方式，并通过实例加深了读者对声明式事务在实际开发中的应用理解。通过掌握这些知识点，开发者可以更好地利用Spring框架提供的高级特性，提高代码的质量和...
Spring编程式和声明式事务实例讲解小结
08-25
Spring编程式和声明式事务实例讲解小结 本文主要介绍了Spring...本文详细介绍了Spring编程式和声明式事务实例讲解小结，涵盖了Spring事务管理的两种方式，并提供了一个案例来演示如何使用不同的方式来实现转账业务。
Spring.NET声明式事务管理案例详解
2. **AOP（面向切面编程）**：Spring.NET通过AOP实现了声明式事务管理，允许开发者将与业务逻辑分离的关注点（如事务管理、日志等）集中处理，极大地提高了代码的重用性和模块化。 3. **事务属性**：在声明式事务...
声明式事务-示例
wodeshouji6的博客
02-18 226
一、配置环境 1.向pom.xml中添加数据库驱动、数据源、spring-jdbc模块依赖。 具体向pom.xml添加如下依赖如下： &lt;!--数据库驱动--&gt; &lt;dependency&gt; &lt;groupId&gt;mysql&lt;/groupId&gt; &lt;artifactId&gt;mysql-connector-java&lt;/art...
Spring的AOP中的声明式事务
樱吹雪
07-15 274
一、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:context="http...
Spring AOP--声明式事务
dianjishamaoxian的博客
06-21 270
1.Spring支持两种事务的声明方式 a.编程式事务管理：通过Transaction Template手动管理事务，实际应用中很少使用。 b.使用xml配置声明式事务：实际中用的很多因为代码侵入性最小，而且是通过AOP实现的。 （这里我们讲解一下声明式事务） 2.实现声明式事务管理的方式 a.基于< tx> 和< aop>命名空间的声明式事务管理：其与Spring AOP...
Spring aop实现声明式事务
m_q_x的博客
09-08 861
1.  声明式事务 事务分为：编程式事务，声明式事务 编程式事务:程序员通过自己写的代码来控制事务机制 声明式事务：是基于spring aop来实现的，通知！ 案例驱动：添加的同时，删除一条数据。 @Override    public int addUser(User user) {       int res = userMapper.addUser(us
Spring中的AOP及声明式事务详解
PiggyOne123的博客
05-03 613
AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。既然事务控制的代码有规律可循，代码的结构基本是确定的，所以框架就可以将固定模式的代码抽取出来，进行相关的封装，通过配置让框架实现功能。封装起来后，我们只需要在配置文件中进行简单的配置即可完成操作。好处1：提高开发效率好处2：消除了冗余的代码。
Spring学习8-Spring事务管理（AOP/声明式式事务管理）
salonzhou的专栏
12-25 1982
一、基础知识普及 声明式事务的事务属性： 一：传播行为 二：隔离级别 三：只读提示 四：事务超时间隔 五:异常：指定除去RuntimeException其他回滚异常。  传播行为： 所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。 spring的事务传播规则： 传播行为
Spring声明式事务（AOP的tx方式）
西楚小羽的专栏
04-05 1554
类似于上一篇，这里使用tx的方式来配置。 服务类StudentService.java代码如下： package com.mysrc.service; import java.sql.Date; import java.util.List; import com.mysrc.dao.StudentDao; import com.mysrc.entity.Student; public
声明式事务管理带例子
cpy1356140308的博客
05-19 133
在上述配置中，"com.example.*"表示需要进行事务管理的包路径，"transferMoney"和"updateAccount"表示需要进行事务管理的方法名，"propagation"和"isolation"是事务的传播行为和隔离级别。它与底层的数据源进行交互，确保事务的一致性和持久性。5. 事务通知：在目标方法执行前后，AOP拦截器会调用事务通知，根据配置的事务属性和事务管理器来控制事务的行为。- 简化事务管理：通过配置事务属性，可以灵活地定义事务的行为，而不需要手动控制事务的开始、提交或回滚。
Spring 声明式事务管理
weixin_34001430的博客
07-01 118
案例分析 　　本案例是图书管理系统精简部分，在数据库中有3张表。分别保存图书库存、图书信息和用户信息。下面是建表SQL语句 1 DROP TABLE IF EXISTS store; 2 DROP TABLE IF EXISTS book ; 3 DROP TABLE IF EXISTS user; 4 5 -- 图书表 6 CREATE TABLE book( ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值