Spring事务如何基于SpringAOP来实现事务代理？

已于 2023-09-14 10:31:59 修改
阅读量1.3k 收藏 3
点赞数 2
分类专栏： Spring 文章标签： spring
于 2021-07-15 19:11:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37689658/article/details/118766462
版权

通常我们要开启spring的事务我们需要加上@EnableTransactionManagement这个注解，那么肯定的这个注解的作用就是往容器里面去import了一个组件从而使得方法上面的@Transaction注解生效，而且spring事务的原理也是基于代理去实现事务回滚，事务隔离等功能的，那么既然是基于代理的原理，spring的事务与springAOP在实现这方面上有何异曲同工之处呢？

首先来看看@EnableTransactionManagement这个注解做了什么事

@Override
protected String[] selectImports(AdviceMode adviceMode) {
   switch (adviceMode) {
      case PROXY:
         return new String[] {AutoProxyRegistrar.class.getName(),
               ProxyTransactionManagementConfiguration.class.getName()};
      case ASPECTJ:
         return new String[] {determineTransactionAspectClass()};
      default:
         return null;
   }
}

这个注解往里面导入了一个TransactionManagementConfigurationSelector，最终这个selector往容器导入了两个组件，分别是AutoProxyRegistrar和ProxyTransactionManagementConfiguration

AutoProxyRegistrar

这个类又是一个ImportBeanDefinitionRegistrar组件，所以最终会调用registerBeanDefinitions这个方法，根据参数中的registry去向容器注册BeanDefinition，最终注册的逻辑：

@Nullable
public static BeanDefinition registerAutoProxyCreatorIfNecessary(
      BeanDefinitionRegistry registry, @Nullable Object source) {

   return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);
}

@Nullable
private static BeanDefinition registerOrEscalateApcAsRequired(
      Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {

   Assert.notNull(registry, "BeanDefinitionRegistry must not be null");

   if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
      BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
      if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
         int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
         int requiredPriority = findPriorityForClass(cls);
         if (currentPriority < requiredPriority) {
            apcDefinition.setBeanClassName(cls.getName());
         }
      }
      return null;
   }

   RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
   beanDefinition.setSource(source);
   beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
   beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
   registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
   return beanDefinition;
}

上面的代码不必再过多解释，就是往容器中注册了一个InfrastructureAdvisorAutoProxyCreator这个类，接下来我们再来看下ProxyTransactionManagementConfiguration这个类

ProxyTransactionManagementConfiguration

@Configuration
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {

   @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
   @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
   public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
      BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
      advisor.setTransactionAttributeSource(transactionAttributeSource());
      advisor.setAdvice(transactionInterceptor());
      if (this.enableTx != null) {
         advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
      }
      return advisor;
   }

   @Bean
   @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
   public TransactionAttributeSource transactionAttributeSource() {
      return new AnnotationTransactionAttributeSource();
   }

   @Bean
   @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
   public TransactionInterceptor transactionInterceptor() {
      TransactionInterceptor interceptor = new TransactionInterceptor();
      interceptor.setTransactionAttributeSource(transactionAttributeSource());
      if (this.txManager != null) {
         interceptor.setTransactionManager(this.txManager);
      }
      return interceptor;
   }

}

这个类就是 一个配置类，里面配置3个需要往容器中去注册的Bean，分别是BeanFactoryTransactionAttributeSourceAdvisor，TransactionAttributeSource，TransactionInterceptor并且需要注意的是这三个bean都使用@Role注解声明为ROLE_INFRASTRUCTURE，这个在后面的代码中会用到。上面我们先总结下@EnableTransactionManagement注解最终做了就是往spring容器中导入了4个关键组件，分别是InfrastructureAdvisorAutoProxyCreator，BeanFactoryTransactionAttributeSourceAdvisor，TransactionAttributeSource，TransactionInterceptor

InfrastructureAdvisorAutoProxyCreator

先看下这个类的继承关系图

 能够看到这个类最终也是继承于AbstractAutoProxyCreator，在前面SpringAOP的自动代理就说过这个类，这个类实现了BeanPostProcessor下面的两个子接口，所以在当bean在实例化之前和初始化之后都会被这个类所拦截，这里细节就不再多说，我们直接看拦截的方法

实例化之前org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessBeforeInstantiation

@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
   Object cacheKey = getCacheKey(beanClass, beanName);

   if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
      if (this.advisedBeans.containsKey(cacheKey)) {
         return null;
      }
      if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
         this.advisedBeans.put(cacheKey, Boolean.FALSE);
         return null;
      }
   }

   // Create proxy here if we have a custom TargetSource.
   // Suppresses unnecessary default instantiation of the target bean:
   // The TargetSource will handle target instances in a custom fashion.
   TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
   if (targetSource != null) {
      if (StringUtils.hasLength(beanName)) {
         this.targetSourcedBeans.add(beanName);
      }
      Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
      Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
      this.proxyTypes.put(cacheKey, proxy.getClass());
      return proxy;
   }

   return null;
}

这个方法在SpringAOP中主要就是去解析我们的aspect切面类得到解析后的advisor并缓存起来，而spring事务在这里却没有做什么事情。初始化之后就要来到bean的初始化之后的后置处理了：org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
   if (bean != null) {
      Object cacheKey = getCacheKey(bean.getClass(), beanName);
      if (this.earlyProxyReferences.remove(cacheKey) != bean) {
         return wrapIfNecessary(bean, beanName, cacheKey);
      }
   }
   return bean;
}

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNecessary

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
   if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
      return bean;
   }
   if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
      return bean;
   }
   if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
      this.advisedBeans.put(cacheKey, Boolean.FALSE);
      return bean;
   }

   // Create proxy if we have advice.
   Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
   if (specificInterceptors != DO_NOT_PROXY) {
      this.advisedBeans.put(cacheKey, Boolean.TRUE);
      Object proxy = createProxy(
            bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
      this.proxyTypes.put(cacheKey, proxy.getClass());
      return proxy;
   }

   this.advisedBeans.put(cacheKey, Boolean.FALSE);
   return bean;
}

和SpringAOP套路一样，都是在bean初始化的后置方法里面去生成代理对象，在生成代理对象之前会先寻找适合该bean使用的advisor，那么重点来看getAdvicesAndAdvisorsForBean这个方法

org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean

protected Object[] getAdvicesAndAdvisorsForBean(
      Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
   
   // 寻找适合的advisor
   List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
   if (advisors.isEmpty()) {
      return DO_NOT_PROXY;
   }
   return advisors.toArray();
}

org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#findEligibleAdvisors

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
   // 寻找候选的advisor
   List<Advisor> candidateAdvisors = findCandidateAdvisors();
   // 从寻找到的候选的advisor中去找到适合该bean的advisor
   List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
   extendAdvisors(eligibleAdvisors);
   if (!eligibleAdvisors.isEmpty()) {
      eligibleAdvisors = sortAdvisors(eligibleAdvisors);
   }
   return eligibleAdvisors;
}

org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#findCandidateAdvisors

protected List<Advisor> findCandidateAdvisors() {
   Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
   // 调用了AbstractAdvisorAutoProxyCreator中寻找候选advisor辅助类
   return this.advisorRetrievalHelper.findAdvisorBeans();
}

这个辅助类重写了它父类的isEligibleBean方法，而isEligibleBean方法是判断advisor是否能够成为候选的条件判断方法

private class BeanFactoryAdvisorRetrievalHelperAdapter extends BeanFactoryAdvisorRetrievalHelper {

   public BeanFactoryAdvisorRetrievalHelperAdapter(ConfigurableListableBeanFactory beanFactory) {
      super(beanFactory);
   }

   @Override
   protected boolean isEligibleBean(String beanName) {
      return AbstractAdvisorAutoProxyCreator.this.isEligibleAdvisorBean(beanName);
   }
}

根据上面我们的分析，上面的方法我们一直所执行的对象都是InfrastructureAdvisorAutoProxyCreator，只不过都是这个类的父类的方法，而在这里的isEligibleBean方法，里面调用的AbstractAdvisorAutoProxyCreator.this.isEligibleAdvisorBean(beanName)这句代码刚好就被InfrastructureAdvisorAutoProxyCreator所重写了

@Override
protected boolean isEligibleAdvisorBean(String beanName) {
   return (this.beanFactory != null && this.beanFactory.containsBeanDefinition(beanName) &&
         this.beanFactory.getBeanDefinition(beanName).getRole() == BeanDefinition.ROLE_INFRASTRUCTURE);
}

而在InfrastructureAdvisorAutoProxyCreator中重写判断advisor是否是候选的advisor的条件就是这个advisor的role等于BeanDefinition.ROLE_INFRASTRUCTURE，这个值是不是有点眼熟？没错，就是上面叫大家去注意的地方，回到ProxyTransactionManagementConfiguration这个类，这个类在spring容器进行bean注册的时候就往容器中放进了三个bean，而这三个bean的role都等于BeanDefinition.ROLE_INFRASTRUCTURE

@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
   BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
   advisor.setTransactionAttributeSource(transactionAttributeSource());
   advisor.setAdvice(transactionInterceptor());
   if (this.enableTx != null) {
      advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
   }
   return advisor;
}

@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public TransactionAttributeSource transactionAttributeSource() {
   return new AnnotationTransactionAttributeSource();
}

@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public TransactionInterceptor transactionInterceptor() {
   TransactionInterceptor interceptor = new TransactionInterceptor();
   interceptor.setTransactionAttributeSource(transactionAttributeSource());
   if (this.txManager != null) {
      interceptor.setTransactionManager(this.txManager);
   }
   return interceptor;
}

在这里就可以说下这三个bean的作用了，第一个bean是一个advisor，在寻找候选的advisor方法的时候会从容器中getBean可以得到，然后又符合了role等于BeanDefinition.ROLE_INFRASTRUCTURE的条件，所以此时最终候选的advisor只有这个advisor，第二个bean能够作用于advisor的pointcut处理，是用来配合处理判断目标bean是否符合这个advisor的，判断逻辑就是判断该bean的方法或者类上面是否有@Transactional注解，如果有就说明这个advisor适用于这个bean，而第三个就是我们的事务拦截器了，代理对象增强逻辑的地方，会处理有关spring事务的所有事情

总结

关于advisor中的pointcut的细节逻辑是怎样的，以及之后的事务增强的处理就不细说了，我们这里主要是去学习到了整个spring事务在创建代理以及寻找advisor，MethodInteceptor的过程与SpringAOP的相似之处，SpringAOP是会在bean实例化之前的前置处理会先去解析aspect切面并且把解析出来的advisor缓存起来，而spring事务在这一步基本上没做什么处理，然后在bean初始化的后置处理SpringAOP和spring事务都会去创建代理对象，但是两者在寻找advisor的逻辑上就有些不同，SpringAOP是会找出spring容器中所有的advisor（包括了解析aspect切面的advisor），而spring事务是找role等于BeanDefinition.ROLE_INFRASTRUCTURE的advisor，之后两者在判断适用于bean的advisor的pointcut的逻辑也是各自的不同，最后在代理对象执行方法的时候，如果单独只开启了spring事务那么此时的拦截链是只会有一个，就是上面注册的TransactionInterceptor这个bean

我神级欧文
关注
专栏目录
Spring事务实现原理—Aop以及动态代理
JFIA的博客
06-09 2144
Spring事务实现原理—Aop以及动态代理 Spring事务管理机制的实现原理是由Spring内置的AOP——默认使用动态代理模式实现的。 AOP Spring的两大核心之一就是AOP，AOP：面向切面编程。在说原理之前，得先知道一些 AOP的专业术语。 AOP的专业术语 连接点（JoinPoint）：增强执行的位置（增加代码的位置），Spring只支持方法； 切点（PointCut）：具体的连接点；一般可能通过一个表达式来描述； 增强（Advice）：也称为消息，指的是增加的额外的代码，Spring中，
Spring事务五种不同的代理配置
07-19
Spring事务配置的五种方式 ,根据代理机制的不同，总结了五种Spring事务的配置方式.
Spring事务代理
loganyang123的专栏
04-25 1497
Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口
浅谈Spring中的事务及事务传播机制
最新发布
m0_63191002的博客
08-11 1267
Spring事务传播机制定义了：多个包含了事务的方法在相互调用时，事务是如何在这些方法间进行传递的。
Spring事务管理和代理模式
Java_ttcd的博客
07-30 771
前言这样在直接调用batchConfirmPurchaseOrders()方法时，如果confirmPurchaseOrder()方法发生了异常，是不会回滚的。原理在于Spring的事务管理依靠的动态代理模式，当在同一个类中调用一个非事务方法，是不会生成代理对象的，自然也不会触发事务。借此机会回顾一下代理模式和Spring事务管理的原理。代理模式网上讲解代理模式的文章千奇百怪，很多时候看完了也不明白讲的重点是什么。...
代理与Spring事务
Kerwin_luo的博客
02-14 673
代理与Spring事务Java代理方式JDK静态代理实现思路特点代码示例JDK动态代理实现思路特点代码示例Cglib动态代理实现思路特点代码示例事务与AOP原理概述业务场景总结 Java代理方式 JDK静态代理 实现思路 被代理类和代理类实现同一个接口 被代理人持有代理类的对象 代理类为被代理类预处理消息、过滤消息并在此之后将消息转发给被代理类，之后还能进行消息的后置处理 特点 在编译后、运...
浅入浅出代理模式与Spring事务管理
m0_69860228的博客
05-19 174
本文回顾了代理模式和Spring事务管理的原理。 前言 最近在开发业务代码的时候，犯了一个事务注解的错误：在同一个类的非事务方法中调用了另一个事务方法，导致事务没有生效，如下所示： public ConfirmOrderResultVO batchConfirmPurchaseOrders(Long taobaoUserId, List<String> bizOrderIds) throws TCException { ………………………………………………………………
Spring如何基于aop实现事务控制
08-24
Spring框架中提供了多种方式来实现事务控制，基于AOP（Aspect-Oriented Programming，面向方面编程）是其中的一种常用方式。通过使用AOP，可以将事务控制逻辑从业务逻辑中分离出来，提高代码的可读性和可维护性。 ...
spring基于AOP实现事务
07-30
本文将深入探讨如何基于AOP（面向切面编程）来实现Spring的事务管理，特别是通过TransactionProxyFactoryBean。让我们一起探索这个主题。 首先，了解什么是AOP。AOP是Spring框架的核心特性，它允许我们在不修改业务...
Spring基于ProxyFactoryBean创建AOP代理
08-25
Spring 基于 ProxyFactoryBean 创建 AOP 代理 ProxyFactoryBean 是 Spring 中用于创建 AOP 代理的重要工具类，它提供了完整的控制能力，可以生成指定的内容。下面将详细介绍 ProxyFactoryBean 的使用方法和 Spring...
线程池中使用spring aop事务增强
08-25
Spring AOP通常通过动态代理（JDK动态代理或CGLIB）来实现，当方法通过代理调用时，会触发AOP拦截器链，从而进行事务管理、日志记录等操作。然而，当`job`方法直接在`doJob`内部被非代理实例调用时，AOP机制不会介入...
spring 事务代理的方法
john201314的专栏
04-28 203
由于 Spring 事务管理是基于接口代理或动态字节码技术，通过 AOP 实施事务增强的。虽然，Spring 还支持 AspectJ LTW 在类加载期实施增强，但这种方法很少使用，所以我们不予关注。 对于基于接口动态代理的 AOP 事务增强来说，由于接口的方法是 public 的，这就要求实现类的实现方法必须是 public 的（不能是 protected，private 等），同时不能使用 ...
Spring AOP应用之事务
weixin_47742705的博客
04-24 614
Spring AOP应用之事务
Spring 事务代理配置
stevenbill的博客
08-25 159
让Spring架构减化事务配置 注：原创文章,本文曾发表于it168 Spring颠覆了以前的编程模式，引入了IOC等全新的概念，广受大家的喜爱。目前大多数j2ee项目都已经采用Spring框架。Spring最大的问题是太多的配置文件，使得你不仅需要维护程序代码，还需要额外去维护相关的配置文件。最典型的就是事务配置(注：这里的“事务配置”都指“声明式事务配置”)，在Spring中进行事务配...
Spring声明式事务如何选择代理方式？
qq_30908729的博客
06-22 472
Spring声明式事务如何选择代理方式？解决方法：基于注解和基于xml配置的选择代理方式：http://www.yayihouse.com/yayishuwu/chapter/1304
spring两种代理方式
ruky36的专栏
06-05 546
使用net.sf.cglib.proxy.Enhancer类和net.sf.cglib.proxy.MethodInterceptor接口来实现。Spring 提供了两种主要的代理（proxy）方式，分别是基于JDK动态代理和基于CGLIB的代理。- 生成的代理类是目标类的子类，可能会有一些不兼容的情况（例如目标类是final类，或者目标方法是final方法时无法代理）。- 使用CGLIB代理时，不需要接口，适用于需要代理具体类的方法的场景。- 生成的代理类是接口的实现类，遵循面向接口编程的原则。
spring事务 spring事务代理
lgh1117的专栏
10-16 966
根据代理机制不同，有以下几种配置方式： 先定义一个DAO接口及实现类: public interface IUserDao { public void insertUser(UserTable user); } public interface IUserDao { public void insertUser(UserTable user);
spring事务代理
amwpynnwxf的专栏
04-22 413
                  PROPAGATION_REQUIRED,readOnly  //匹配...只读    PROPAGATION_REQUIRED,readOnly    PROPAGATION_REQUIRED       //===                                //该类由于有了Spring事务功能,所以保存历史记录和修改用户信息成
Spring中实现AOP事务
蚂蚁
06-12 509
事务相关知识 事务特性：ACID 事务并发的问题：脏读、不可重复读（行记录）、幻读（虚读）（表记录） 事务的隔离级别：1读未提交、2读已经提交数据 4 可重复读 8串行化 Spring实现事务 Spring需要干的事情 （1）封装相关的代码：打开事务、提交事务、回滚事务 （2）提供 事务操作的对象 因为在不同的平台，操作事务的代码各不相同， Sp...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值