面试官:如何控制Spring事务拦截器的顺序?| Spring系列第50篇

1、前言

咱们知道 Spring 事务是通过aop的方式添加了一个事务拦截器,事务拦截器会拦截目标方法的执行,在方法执行前后添加了事务控制。

那么spring事务拦截器的顺序如何控制呢,若我们自己也添加了一些拦截器,此时事务拦截器和自定义拦截器共存的时候,他们的顺序是怎么执行的?如何手动来控制他们的顺序??

可能有些朋友会问,控制他们的顺序,这个功能有什么用呢?为什么要学这个

学会了这些,你可以实现很多牛逼的功能,比如

1、读写分离

2、通用幂等框架

3、分布式事务框架

对这些有兴趣么?那么咱们继续。

2、事务拦截器顺序设置

@EnableTransactionManagement 注解有个 order属性,默认值是Integer.MAX_VALUE,用来指定事务拦截器的顺序,值越小,拦截器的优先级越高,如:

@EnableTransactionManagement(order = 2)

下面来看案例。

3、案例

我们自定义2个拦截器:一个放在事务拦截器之前执行,一个放在事务拦截器之后执行

拦截器顺序
TransactionInterceptorBefore1
@EnableTransactionManagement 事务拦截器2
TransactionInterceptorAfter3

3.1、准备sql

DROP DATABASE IF EXISTS javacode2018;
CREATE DATABASE if NOT EXISTS javacode2018;

USE javacode2018;
DROP TABLE IF EXISTS t_user;
CREATE TABLE t_user(
  id int PRIMARY KEY AUTO_INCREMENT,
  name varchar(256) NOT NULL DEFAULT '' COMMENT '姓名'
);

3.2、Spring配置类MainConfig10

@1:开启了事务管理功能,并且设置了事务拦截器的顺序是2,spring事务拦截器完整类名是

org.springframework.transaction.interceptor.TransactionInterceptor

@2:开启aop功能

package com.javacode2018.tx.demo10;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@Configuration //说明当前类是一个配置类
@ComponentScan //开启bean自动扫描注册功能
@EnableTransactionManagement(order = 2) //@1:设置事务拦截器的顺序是2
@EnableAspectJAutoProxy // @2:开启@Aspect Aop功能
public class MainConfig10 {
    @Bean
    public DataSource dataSource() {
        org.apache.tomcat.jdbc.pool.DataSource dataSource = new org.apache.tomcat.jdbc.pool.DataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/javacode2018?characterEncoding=UTF-8");
        dataSource.setUsername("root");
        dataSource.setPassword("root123");
        dataSource.setInitialSize(5);
        return dataSource;
    }

    //定义一个jdbcTemplate
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    //定义事务管理器transactionManager
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

3.3、定义一个有事务的Service类

addUser方法上面添加了@Transactional注解,表示使用spring来管理事务,方法内部向db中插入了一条数据,为了方便分析结果,方法内部输出了2行日志

package com.javacode2018.tx.demo10;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

@Component
public class UserService {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Transactional
    public void addUser() {
        System.out.println("--------UserService.addUser start");
        this.jdbcTemplate.update("insert into t_user(name) VALUES (?)", "张三");
        System.out.println("--------UserService.addUser end");
    }
}

3.4、自定义第1个拦截器,放在事务拦截器之前执行

下面通过Aspect的方式定义了一个拦截器,顺序通过@Order(1)设置的是1,那么这个拦截器会在事务拦截器之前执行。

package com.javacode2018.tx.demo10;

import org.aopalliance.intercept.Joinpoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Aspect
@Order(1) //@1
public class TransactionInterceptorBefore {

    @Pointcut("execution(* com.javacode2018.tx.demo10.UserService.*(..))")
    public void pointcut() {
    }

    @Around("pointcut()")
    public Object tsBefore(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("--------before start!!!");
        Object result = joinPoint.proceed();
        System.out.println("--------before end!!!");
        return result;
    }
}

3.4、自定义第2个拦截器,放在事务拦截器后面执行

这个拦截器的order是3,会在事务拦截器后面执行。

package com.javacode2018.tx.demo10;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Aspect
@Order(2)
public class TransactionInterceptorAfter {

    @Pointcut("execution(* com.javacode2018.tx.demo10.UserService.*(..))")
    public void pointcut() {
    }

    @Around("pointcut()")
    public Object tsAfter(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("--------after start!!!");
        Object result = joinPoint.proceed();
        System.out.println("--------after end!!!");
        return result;
    }
}

3.5、添加测试类

package com.javacode2018.tx.demo10;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

public class Demo10Test {

    private UserService userService;

    private JdbcTemplate jdbcTemplate;

    @Before
    public void before() {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig10.class);
        userService = context.getBean(UserService.class);
        this.jdbcTemplate = context.getBean("jdbcTemplate", JdbcTemplate.class);
        jdbcTemplate.update("truncate table t_user");
    }

    @Test
    public void test1() {
        this.userService.addUser();
    }
}
3.6、分析test1方法代码执行顺序

咱们先不执行,下分析一下test1方法执行顺序,test1方法内部会调用userService的addUser方法,这个方法会被3个拦截器拦截。

自定义的2个拦截器和事务拦截器TransactionInterceptor拦截,执行顺序如下:

下面来运行一下,看看结果和我们分析的是否一致。

3.7、运行test1输出

--------before start!!!
--------after start!!!
--------UserService.addUser start
--------UserService.addUser end
--------after end!!!
--------before end!!!

结果和上图中一致,大家可以在3个拦截器中设置一下断点,调试一下可以看到更详细的信息,可加深理解。

4、总结

今天的内容算是比较简单的,重点要掌握如何设置事务拦截器的顺序,@EnableTransactionManagement 有个 order属性,默认值是Integer.MAX_VALUE,用来指定事务拦截器的顺序,值越小,拦截器的优先级越高。

后面我们会通过这个功能实现读写分离,通用幂等性的功能。

5、案例源码

git地址:
https://gitee.com/javacode2018/spring-series

本文案例对应源码:
    spring-series\lesson-002-tx\src\main\java\com\javacode2018\tx\demo10

路人甲java所有案例代码以后都会放到这个上面,大家watch一下,可以持续关注动态。

6、Spring系列

  1. Spring系列第1篇:为何要学spring?

  2. Spring系列第2篇:控制反转(IoC)与依赖注入(DI)

  3. Spring系列第3篇:Spring容器基本使用及原理

  4. Spring系列第4篇:xml中bean定义详解(-)

  5. Spring系列第5篇:创建bean实例这些方式你们都知道?

  6. Spring系列第6篇:玩转bean scope,避免跳坑里!

  7. Spring系列第7篇:依赖注入之手动注入

  8. Spring系列第8篇:自动注入(autowire)详解,高手在于坚持

  9. Spring系列第9篇:depend-on到底是干什么的?

  10. Spring系列第10篇:primary可以解决什么问题?

  11. Spring系列第11篇:bean中的autowire-candidate又是干什么的?

  12. Spring系列第12篇:lazy-init:bean延迟初始化

  13. Spring系列第13篇:使用继承简化bean配置(abstract & parent)

  14. Spring系列第14篇:lookup-method和replaced-method比较陌生,怎么玩的?

  15. Spring系列第15篇:代理详解(Java动态代理&cglib代理)?

  16. Spring系列第16篇:深入理解java注解及spring对注解的增强(预备知识)

  17. Spring系列第17篇:@Configration和@Bean注解详解(bean批量注册)

  18. Spring系列第18篇:@ComponentScan、@ComponentScans详解(bean批量注册)

  19. Spring系列第18篇:@import详解(bean批量注册)

  20. Spring系列第20篇:@Conditional通过条件来控制bean的注册

  21. Spring系列第21篇:注解实现依赖注入(@Autowired、@Resource、@Primary、@Qulifier)

  22. Spring系列第22篇:@Scope、@DependsOn、@ImportResource、@Lazy 详解

  23. Spring系列第23篇:Bean生命周期详解

  24. Spring系列第24篇:父子容器详解

  25. Spring系列第25篇:@Value【用法、数据来源、动态刷新】

  26. Spring系列第26篇:国际化详解

  27. Spring系列第27篇:spring事件机制详解

  28. Spring系列第28篇:Bean循环依赖详解

  29. Spring系列第29篇:BeanFactory扩展(BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor)

  30. Spring系列第30篇:jdk动态代理和cglib代理

  31. Spring系列第31篇:aop概念详解

  32. Spring系列第32篇:AOP核心源码、原理详解

  33. Spring系列第33篇:ProxyFactoryBean创建AOP代理

  34. Spring系列第34篇:@Aspect中@Pointcut 12种用法

  35. Spring系列第35篇:@Aspect中5中通知详解

  36. Spring系列第36篇:@EnableAspectJAutoProxy、@Aspect中通知顺序详解

  37. Spring系列第37篇:@EnableAsync & @Async 实现方法异步调用

  38. Spring系列第38篇:@Scheduled & @EnableScheduling定时器详解

  39. Spring系列第39篇:强大的Spel表达式

  40. Spring系列第40篇:缓存使用(@EnableCaching、@Cacheable、@CachePut、@CacheEvict、@Caching、@CacheConfig)

  41. Spring系列第41篇:@EnableCaching集成redis缓存

  42. Spring系列第42篇:玩转JdbcTemplate

  43. Spring系列第43篇:spring中编程式事务怎么用的?

  44. Spring系列第44篇:详解spring声明式事务(@Transactional)

  45. Spring系列第45篇:带你吃透Spring事务7种传播行为

  46. Spring系列第46篇:Spring如何管理多数据源事务?

  47. Spring系列第47篇:spring编程式事务源码解析

  48. Spring系列第48篇:@Transaction 事务源码解析

  49. Spring系列第49篇:通过Spring事务实现MQ中的事务消息

7、更多好文章

  1. Java高并发系列(共34篇)

  2. MySql高手系列(共27篇)

  3. Maven高手系列(共10篇)

  4. Mybatis系列(共12篇)

  5. 聊聊db和缓存一致性常见的实现方式

  6. 接口幂等性这么重要,它是什么?怎么实现?

  7. 泛型,有点难度,会让很多人懵逼,那是因为你没有看这篇文章!

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 精致技术 设计师:CSDN官方博客 返回首页