Spring AOP的应用

最新推荐文章于 2024-07-21 11:45:00 发布
最新推荐文章于 2024-07-21 11:45:00 发布
阅读量825 收藏
点赞数
分类专栏： Spring Framework 文章标签： aop 声明式事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZXY_9264_ANG/article/details/93912770
版权

文章目录

声明式事务

XML配置方式

配置事务管理器

<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

配置AOP通知（advice)

简单示例：
<!-- 示例演示给所有get、find、query开头的方法添加只读事务，其他方法是默认事务(可读可写) -->
<tx:advice id="txAdvice" transaction-manager="txManager">
   <tx:attributes>
       <tx:method name="get*" read-only="true" />
       <tx:method name="find*" read-only="true" />
       <tx:method name="query*" read-only="true" /> 
       <tx:method name="*"/>
   </tx:attributes>
</tx:advice>
< tx:advice / >默认配置如下：
  • 传播行为(propagation)是REQUIRED
  • 隔离级别(isolation level)是DEFAULT
  • 事务默认可读写(read-write)
  • 事务超时时间是数据库默认事务超时时间
  • unchecked异常RuntimeException异常触发事务回滚，checked异常Exception不会触发回滚
< tx:method / > 设置项:
属性是否必须默认值描述
nameYes与事务属性关联的方法名称。支持通配符(如, get, handle*, on*Event等
propagationNoREQUIRED事务传播行为
isolationNoDEFAULT事务隔离级别 仅当传播行为设置为 REQUIRED 或者 REQUIRES_NEW时有效.
timeoutNo-1事务超时时间(单位：秒). 仅当传播行为设置为 REQUIRED 或者 REQUIRES_NEW时有效.
read-onlyNofalse设置读写事务或者只读事务. 仅当传播行为设置为 REQUIRED 或者 REQUIRES_NEW时有效.
rollback-forNo设置多个可以触发事务回滚的异常(多个用英文逗号隔开). 如,com.foo.MyBusinessException,ServletException.
no-rollback-forNo设置多个禁止触发事务回滚的异常(多个用英文逗号隔开).如，com.foo.MyBusinessException,ServletException.

示例

tx_transaction.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop.xsd
            http://www.springframework.org/schema/tx
            http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 通过xml方式配置spring声明式事务 配置开始 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource" />
    </bean>

    <bean id="studentDao" class="com.lanou3g.spring.transaction.xml.dao.StudentDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate" />
    </bean>
    
    <!-- 第一步:配置数据源 -->
    <context:property-placeholder location="classpath:jdbc.properties" />
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="url" value="${jdbc.url}" />
        <property name="driverClassName" value="${jdbc.driver}" />
        <property name="username" value="${jdbc.user}" />
        <property name="password" value="${jdbc.password}" />
        <property name="connectionProperties" value="${jdbc.characterEncoding}" />
    </bean>

    <!-- 第二步:初始化事务管理器 -->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>

    <!-- 第三步:配置事务AOP通知 -->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="insert*" rollback-for="Exception"/>
            <tx:method name="query*" read-only="true" />
        </tx:attributes>
    </tx:advice>

    <!-- 第四步:定义AOP配置(将上面的通知和表达式组装到一起) -->
    <aop:config>
        <aop:pointcut id="all_dao_method" expression="execution(* com.lanou3g.spring.transaction.xml.dao.*.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="all_dao_method" />
    </aop:config>

    <!-- 通过xml方式配置spring声明式事务 配置结束 -->

</beans>

jdbc.properties数据源

jdbc.url=jdbc:mysql://localhost:3306/zzj0301
jdbc.driver=com.mysql.jdbc.Driver
jdbc.user=root
jdbc.password=root
jdbc.characterEncoding=UTF-8

数据库对应的java类

@Getter
@Setter
public class Student {
    private int id;
    private String sname;
    private int age;
    private String gender;
    private String nickname;
}

对数据库进行操作的java类

@Setter
@Getter
public class StudentDaoImpl {

    private JdbcTemplate jdbcTemplate;

    /**
     * 插入一条student数据
     * @param map
     * @return 返回影响行数
     */
    public int insertStudent(Map map){
        Object[] args = new Object[]{
                map.get("sname"),
                map.get("age"),
                map.get("gender"),
                map.get("nickname")
        };
        int row = jdbcTemplate.update("insert into student (sname,age,gender,nickname) values (?,?,?,?)",args);

        //模拟事务异常,使程序回滚
        //int a = 2 / 0;
		
		//返回影响行数
        return row;
    }

}

程序运行入口

public class AppXML {

    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("tx_transaction.xml");
 		Map<String,Object> map = new HashMap<>();
        map.put("sname","王五");
        map.put("age",42);
        map.put("gender","男");
        map.put("nickname","小五");
        int row = ctx.getBean(StudentDaoImpl.class).insertStudent(map);
        System.out.println("影响了" + row + "行");
    }
    
}

注解配置方式

开启事务注解支持

XML中开启：

<!-- 开启事务注解扫描 -->
<!-- 如果定义的事务管理器名称就叫transactionManager，则此属性可以省略 -->
<tx:annotation-driven transaction-manager="txManager" />

注解方式开启：

@Configuration
@EnableTransactionManagement
public class MyTransactionConf {
}

配置事务管理器

/**
 * 通过注解的方式配置Spring声明式事务
 * 也可以将事务管理器定义到xml中，注解事务会按类型自动找到xml中配置的事务管理器
  */
@Configuration
public class MyTransactionConf {
 /**
 * 定义TransactionManager bean
 * @param dataSource
 * @return
   */
    @Bean
    public PlatformTransactionManager txManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

在需要事物的方法上添加事务注解

// 给批量插入方法添加事务控制
@Transactional
@Override
public int[] batchInsertStudent(List<Student> studentList) {
     // 具体操作....
}

// 给查询方法添加只读事务
@Transactional(readOnly = true)
public List<Student> queryStudents() {
    // 具体操作
}

@Transactional属性说明

  • value: 指定特定的事务管理器，默认是transactionManager
  • 其他属性和xml中的的属性类似

示例

jdbc.properties数据源

jdbc.url=jdbc:mysql://localhost:3306/zzj0301
jdbc.driver=com.mysql.jdbc.Driver
jdbc.user=root
jdbc.password=root
jdbc.characterEncoding=UTF-8

配置数据源

@PropertySource("classpath:jdbc.properties")
@Component
public class MyDataSource extends DriverManagerDataSource {
    public MyDataSource(@Value("${jdbc.driver}") String driver,@Value("${jdbc.url}") String url,@Value("${jdbc.user}") String username,@Value("${jdbc.password}") String password,@Value("${jdbc.characterEncoding}") String characterEncoding) {
        super.setDriverClassName(driver);
        super.setUrl(url);
        super.setUsername(username);
        super.setPassword(password);
        Properties properties = new Properties();
        properties.setProperty("characterEncoding",characterEncoding);
        super.setConnectionProperties(properties);
    }
}

数据库对应的java类

@Getter
@Setter
public class Student {
    private int id;
    private String sname;
    private int age;
    private String gender;
    private String nickname;
}

对数据库进行操作的java类

@Setter
@Getter
@Component
public class StudentDaoImpl {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 插入一条student数据
     * @param map
     * @return 影响的行数
     */
    @Transactional(rollbackFor = {Exception.class})
    public int insertStudent(Map map){
        Object[] args = new Object[]{
                map.get("sname"),
                map.get("age"),
                map.get("gender"),
                map.get("nickname")
        };
        int row = jdbcTemplate.update("insert into student (sname,age,gender,nickname) values (?,?,?,?)",args);

        //模拟事务异常,使程序回滚
        //int a = 2 / 0;

        return row;
    }

}

代码运行入口

@Configuration
@ComponentScan(basePackages = "com.lanou3g.spring.transaction.annotation")
@EnableTransactionManagement    //开启事务相关注解支持
public class App {

    /**
     * 定义JdbcTemplate对象，Spring给我们封装了所有的JDBC操作
     * @param dataSource
     * @return
     *
     * 相当于xml配置中的
     * <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
     *      <property name="dataSource" ref="dataSource" />
     * </bean>
     */
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource){
        return new JdbcTemplate(dataSource);
    }

    /**
     *定义事务管理器
     * @param dataSource
     * @return
     *
     * 相当于xml配置中的
     * <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     *      <property name="dataSource" ref="dataSource" />
     * </bean>
     */
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){    //DataSourceTransactionManager是PlatformTransactionManager的一个实现类
        return new DataSourceTransactionManager(dataSource);
    }

    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(App.class);
		Map<String,Object> map = new HashMap<>();
        map.put("sname","欧阳锋");
        map.put("age",42);
        map.put("gender","男");
        map.put("nickname","西毒");
        int row = ctx.getBean(StudentDaoImpl.class).insertStudent(map);
        System.out.println("影响了" + row + "行");
    }

}

回滚事务

回滚特定异常(rollback-for)
<tx:advice id="txAdvice" transaction-manager="txManager">
   <tx:attributes>
      <tx:method name="get*" read-only="true" rollback-for="NoProductInStockException"/>
      <tx:method name="*"/>
   </tx:attributes>
</tx:advice>
不回滚特定异常(no-rollback-for)
<tx:advice id="txAdvice">
    <tx:attributes>
        <tx:method name="updateStock" no-rollback-for="InstrumentNotFoundException"/>
        <tx:method name="*"/>
    </tx:attributes>
</tx:advice>

spring事务的隔离级别和传播行为

七种传播行为

1. PROPAGATION_REQUIRED – 支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

2. PROPAGATION_SUPPORTS – 支持当前事务，如果当前没有事务，就以非事务方式执行。

3. PROPAGATION_MANDATORY – 支持当前事务，如果当前没有事务，就抛出异常。

4. PROPAGATION_REQUIRES_NEW – 新建事务，如果当前存在事务，把当前事务挂起。

5. PROPAGATION_NOT_SUPPORTED – 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

6. PROPAGATION_NEVER – 以非事务方式执行，如果当前存在事务，则抛出异常。

7. PROPAGATION_NESTED – 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。

备注：常用的两个事务传播属性是1和4，即PROPAGATIONREQUIRED PROPAGATIONREQUIRES_NEW

五种隔离级别

隔离级别说明
ISOLATION_DEFAULT这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.
ISOLATIONREADUNCOMMITTED这是事务最低的隔离级别，它允许另外一个事务可以看到这个事务未提交的数据。 这种隔离级别会产生脏读，不可重复读和幻像读。
ISOLATIONREADCOMMITTED保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。 这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像读。
ISOLATIONREPEATABLEREAD这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。 它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。
ISOLATION_SERIALIZABLE这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。 除了防止脏读，不可重复读外，还避免了幻像读。
关键词：
幻读（虚读）

事务1读取记录时事务2增加了记录并提交，事务1再次读取时可以看到事务2新增的记录；
通俗的说，幻读就是指在一个事务内读取了别的事务插入的数据，导致前后读取不一致(insert)

不可重复读取

事务1读取记录时，事务2更新了记录并提交，事务1再次读取时可以看到事务2修改后的记录；
在一个事务内读取表中的某一行数据,多次读取结果不同.一个事务读取到了另一个事务提交后的数据.

脏读

事务1更新了记录，但没有提交，事务2读取了更新后的行，然后事务T1回滚，现在T2读取无效。
通俗的说，脏读就是指一个事务读取了一个未提交事务的数据

其他业务场景

统一异常处理、日志记录

逐墨飞扬
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring AOP应用
06-30
主要是利用Spring AOP实现动态数据源，和数据缓存操作。
Spring AOP应用Demo
05-07
**Spring AOP应用Demo** Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架中的一个重要模块，它提供了一种在不修改源代码的情况下，对程序进行功能增强的技术。这个Demo是针对Spring AOP的...
Spring AOP详解
最新发布
2302_77758423的博客
07-21 1253
AOP英文全称：Aspect Oriented Programming（面向切面编程、面向方面编程），其实说白了，面向切面编程就是面向特定方法编程。使用场景（记录操作日志、权限控制、事务管理）。AOP的优势：减少重复代码、提高开发效率、维护方便、代码无侵入。案例某部分功能运行较慢，定位执行耗时较长的业务方法，此时需要统计每一个业务的执行耗时。我们可以在方法开始前，获取方法开始时间，方法结束后获取结束时间，由此计算执行耗时。这个思路是正确的，但是过于繁琐。动态代理是面向切面编程最主流的实现。
Spring AOP 应用
随时随地记录每一刻发生的事情
06-20 925
AOP本质：在不改变原有业务逻辑的情况下增强横切逻辑，横切逻辑代码往往应用在权限校验、日志、事务控制、性能监控中。
Spring-AOP应用
bianezhuang8827的博客
12-06 813
上一篇 讲到aop基于代理对原有方法进行增强，Spring很多注解的都是使用了AOP的动态代理去实现。 例如： 事务管理 （调用方法前开启事务， 调用方法后提交关闭事务 ） 缓存优化 （第一次调用查询数据库，将查询结果放入内存对象， 第二次调用， 直接从内存对象返回，不需要查询数据库 ）权限控制（security框架hasAuthority(),hasRole()等） 有时的业务场景需要我们自定义去实现一个切面进行处理。比如记录指定接口的请求响应数据，其实拦截器也可以做到，但是拦截器针对某个接口
Spring aop应用
m0_59209367的博客
02-16 73
这里我们暂且把程序设计比喻为房子的布置，一间房子的布局中，需要各种功能的家具和洁具（类似方法），如马桶、浴缸、天然气灶，床、桌子等，对于面向过程的程序设计更注重的是功能的实现(即功能方法的实现)，效果符合预期就好，因此面向过程的程序设计会更倾向图1设置结构，各种功能都已实现，房子也就可以正常居住了。但对于面向对象的程序设计则是无法忍受的，这样的设置使房子内的各种家具和洁具间摆放散乱并且相互暴露的机率大大增加，各种气味相互参杂，显然是很糟糕的，于是为了更优雅地设置房屋的布局，面向对象的程序设计便采用了图2的布
Java进阶之SpringAOP应用共16页.pdf.zi
11-20
本资料"Java进阶之SpringAOP应用共16页.pdf"深入探讨了Spring AOP在实际开发中的应用和实现原理，旨在提升Java开发者的技能水平。 首先，理解AOP的基本概念至关重要。AOP是一种编程范式，它将关注点分离为不同的...
Spring AOP应用开源架构源码2021.pdf
04-27
Spring框架是目前Java开发中使用最广泛的应用程序框架之一，它为开发企业级应用提供了全面的基础支持。其中，AOP（面向切面编程）是Spring框架的一个核心特性，它允许开发者将横切关注点（cross-cutting concerns）...
spring 应用aop 实例
07-10
通过上述步骤，你可以创建一个简单的Spring AOP应用，实现对特定方法的调用进行日志记录。当然，AOP的潜力远不止于此，你可以根据实际场景扩展通知类型，或者创建更复杂的切入点表达式，以实现更细粒度的控制。 在...
Spring AOP原理及简单应用
dawuafang
08-14 212
相信只要使用过Spring框架的，大家对于AOP都不陌生，尤其提起它就能立刻随口说出，一般用在日志处理、异常处理、权限验证等方面。但刚开始接触难免会有各种各样的疑惑，今天抽时间，按照之前的理解整理了一份关于Spring AOP的简单教程，希望能够帮助大家尽快的了解它的实现过程及原理。首先来明确几个概念： JointPoint 系统在运行之前，AOP的功能模块需要织入到OOP的功能模块中。要进行这...
Spring AOP及其应用
weixin_39939986的博客
09-28 254
AOP（Aspect Oriented Programming）面向切面编程。
SpringAOP的应用
weixin_40598838的博客
01-12 101
概述 有这样一个需求，在请求中带有缓存字段（比如http://…&cached=true)，我们则尝试从缓存中获取数据返回，用代理模式或AOP来做 demo cache类: public interface Cache { Result getCacheData(String userName); } 实现类: @Component public class CacheProxy implements Cache{ @Autowired private Redis
Spring AOP （二）
安卓学吧
10-09 378
工作中所遇见的比较常用的 Spring AOP 的使用场景。一、HTTP 接口鉴权 二、方法调用日志 三、方法耗时统计
SpringAOP在项目中的简单应用
04-03 8594
 SpringAOP在项目中的简单应用 一、前言 项目背景 由于公司的机房到期，需要做应用迁移（包括数据库），割接到云平台。但是又不能进行一次性割接，需要分三个阶段：第一阶段割接2个地市，第二阶段再割接9个地市，第三阶段做全盘割接。在第一、第二阶段是要保证云平台与现网平台的应用能够正常并行运行。所以，要保证两边数据访问的正常，需要对某些功能进行改造。比如，某个子功能在并行阶
Spring AOP实际应用一例
溪居
03-29 975
在WEB开发中，用户对网页的访问权限检查是一个重要的环节。以STRUST为例，我们需要在Action的excute方法中编写相关的代码（一般是调用基类的函数），也很显然，在每个Action中这是一种重复劳动。如果我们在excute运行之前，能够自动去调用基类的权限检查函数，这无疑是个好的解决办法。AOP就为我们提供了这样一种解决方法。    下面以一个简化的实例介绍实现的办法。    首先我们做一
AOP及其在Spring中的应用（一）
hesan的专栏
12-01 1547
AOP简介OOP思想对现代编程产生了深远的影响，但在某些方面，OOP也有其不足之处。比如在logging（日志）、transaction（事务）等方面，应用OOP将这些内容封装为对象的行为则会产生大量的代码重复，虽然通过一些设计模式可以减少这种重复，但我们还有更好的解决办法，那就是AOP(Aspect Oriented Programming)。AOP是最近兴起的一种编程思想，它是OOP思想的
第六部分 Spring AOP 应用
虚心若愚
05-10 371
第六部分 Spring AOP 应用 AOP本质：在不改变原有业务逻辑的情况下增强横切逻辑，横切逻辑代码往往是权限校验代码，日志代码，事务控制代码，性能监控代码。 第一节 AOP 相关术语 1.1 业务主线 在讲解AOP术语之前，我们先来看一下下面这两张图，它们就是第三部分案例需求的扩展（针对这些扩展的需求，我们只进行分析，在此基础上去进一步回顾AOP，不进行实现） 上图描述的就是未采⽤AOP思想设计的程序，当我们红⾊框中圈定的⽅法时，会带来⼤量的重复劳动。 程序中充斥着⼤量的重复代码，使我
springaop应用
08-23
Spring AOP是Spring框架中应用AOP（面向切面编程）思想的一种方式。它使用动态代理技术来实现。默认情况下，Spring会根据被代理对象是否实现接口来选择使用JDK动态代理还是CGLIB动态代理。当被代理对象没有实现任何接口时，Spring会选择CGLIB。当被代理对象实现了接口，Spring会选择JDK官方的代理技术。但是我们也可以通过配置的方式，让Spring强制使用CGLIB动态代理。 Spring AOP的配置方式有多种，包括XML模式、XML注解模式和纯注解模式。通过这些配置方式，我们可以将AOP的切面逻辑织入到我们的业务代码中，实现各种功能，比如事务管理等。 在Spring中，事务管理是AOP的一种常见应用。Spring提供了多种事务管理器的实现，例如DataSourceTransactionManager和HibernateTransactionManager等。这些事务管理器实现了Spring的事务管理器核心接口，负责提供具体的事务实现策略。我们可以根据需要选择合适的事务管理器来管理数据库操作或其他事务。同时，Spring也提供了基于注解的声明式事务配置，通过在代码中使用注解来实现事务管理。 总之，Spring AOP可以应用在各种场景中，包括但不限于事务管理。通过AOP的切面编程思想，我们可以将一些横切逻辑代码（比如事务管理、日志记录等）与业务代码解耦，提高代码的可维护性和可扩展性。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [Spring AOP 应用](https://blog.csdn.net/weixin_44152160/article/details/125360176)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值