Spring AOP事务实现原理之BeanFactoryTransactionAttributeSourceAdvisor

yaoshengting

已于 2022-03-20 10:38:41 修改

阅读量1.1k

点赞数

分类专栏： spring 文章标签： spring java 后端

于 2022-03-16 23:26:24 首次发布

本文链接：https://blog.csdn.net/ystyaoshengting/article/details/123539455

版权

spring 专栏收录该内容

45 篇文章 5 订阅

订阅专栏

学习这篇博文需要首先明白Spring AOP的实现原理，可以参考Spring的BeanPostProcessor扩展点实现类AbstractAutoProxyCreator和Spring AOP创建代理类之JdkDynamicAopProxy这两篇博文。

前置学习

该篇接着上篇Spring AOP事务实现原理之启用事务EnableTransactionManagement，在上篇中学习到如何通过注解开启事务，并向BeanFactory注册相关的BeanFactoryTransactionAttributeSourceAdvisor,AnnotationTransactionAttributeSource,TransactionInterceptor

创建AOP代理流程图

Spring的事务的advisor，advice都是通过BeanFactory获取的，就是下图中间最上面的蓝色部分（从类名都是以BeanFactory开头就可以看出来）。
在这里插入图片描述

BeanFactoryTransactionAttributeSourceAdvisor

包含 {@link TransactionAttributeSource} 的advisor，用于为advisor提供事务属性源。

public class BeanFactoryTransactionAttributeSourceAdvisor extends AbstractBeanFactoryPointcutAdvisor {

    //事务属性源
	private TransactionAttributeSource transactionAttributeSource;

    //advisor的切点pointcut
	private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {
		@Override
		protected TransactionAttributeSource getTransactionAttributeSource() {
			return transactionAttributeSource;
		}
	};

    //设置事务属性源，该属性源用于找到事务属性
	public void setTransactionAttributeSource(TransactionAttributeSource transactionAttributeSource) {
		this.transactionAttributeSource = transactionAttributeSource;
	}

	public void setClassFilter(ClassFilter classFilter) {
		this.pointcut.setClassFilter(classFilter);
	}

	@Override
	public Pointcut getPointcut() {
		return this.pointcut;
	}
}

AbstractBeanFactoryPointcutAdvisor

基于 BeanFactory 的PointcutAdvisor的抽象类，允许将任何 Advice 配置为BeanFactory中的bean，例如：TransactionInterceptor。

实现了BeanFactoryAware，会将BeanFactory对象设置到该对象里，然后就可以通过BeanFactory获取到相应的Advice bean。

public abstract class AbstractBeanFactoryPointcutAdvisor extends AbstractPointcutAdvisor implements BeanFactoryAware {

	@Nullable
	private String adviceBeanName;

	@Nullable
	private BeanFactory beanFactory;

	@Nullable
	private transient volatile Advice advice;

	private transient volatile Object adviceMonitor = new Object();

    //指定该advisor需要引用的Advice的bean名称
	public void setAdviceBeanName(@Nullable String adviceBeanName) {
		this.adviceBeanName = adviceBeanName;
	}

	@Nullable
	public String getAdviceBeanName() {
		return this.adviceBeanName;
	}

	@Override
	public void setBeanFactory(BeanFactory beanFactory) {
		this.beanFactory = beanFactory;
		resetAdviceMonitor();
	}

	private void resetAdviceMonitor() {
		if (this.beanFactory instanceof ConfigurableBeanFactory) {
			this.adviceMonitor = ((ConfigurableBeanFactory) this.beanFactory).getSingletonMutex();
		}
		else {
			this.adviceMonitor = new Object();
		}
	}

    //给advisor直接指定一个Advice实例bean
	public void setAdvice(Advice advice) {
		synchronized (this.adviceMonitor) {
			this.advice = advice;
		}
	}

	@Override
	public Advice getAdvice() {
		Advice advice = this.advice;
		if (advice != null) {
			return advice;
		}

		Assert.state(this.adviceBeanName != null, "'adviceBeanName' must be specified");
		Assert.state(this.beanFactory != null, "BeanFactory must be set to resolve 'adviceBeanName'");

        //如果bean factory中有该advice的单例，则直接获取
		if (this.beanFactory.isSingleton(this.adviceBeanName)) {
			// Rely on singleton semantics provided by the factory.
			advice = this.beanFactory.getBean(this.adviceBeanName, Advice.class);
			this.advice = advice;
			return advice;
		}
        //如果不是单例，则加上锁，然后再从bean factory中获取该实例
		else {
			// No singleton guarantees from the factory -> let's lock locally but
			// reuse the factory's singleton lock, just in case a lazy dependency
			// of our advice bean happens to trigger the singleton lock implicitly...
			synchronized (this.adviceMonitor) {
				advice = this.advice;
				if (advice == null) {
					advice = this.beanFactory.getBean(this.adviceBeanName, Advice.class);
					this.advice = advice;
				}
				return advice;
			}
		}
	}
}