欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

【原创】002 | 搭上SpringBoot事务源码分析专车

程序员文章站 2022-07-04 22:41:21
前言 如果这是你 第二次 看到师长,说明你在觊觎我的美色! 点赞+关注再看,养成习惯 没别的意思,就是需要你的窥屏^_^ 专车介绍 该趟专车是开往Spring Boot事务源码分析的专车 专车问题 为什么加上@Transactional注解就可以实现事务? 分析事务源码之后我们可以学到什么? 专车名 ......

前言

如果这是你第二次看到师长,说明你在觊觎我的美色!

点赞+关注再看,养成习惯

没别的意思,就是需要你的窥屏^_^ 【原创】002 | 搭上SpringBoot事务源码分析专车

专车介绍**

该趟专车是开往spring boot事务源码分析的专车 【原创】002 | 搭上SpringBoot事务源码分析专车

专车问题

  • 为什么加上@transactional注解就可以实现事务?
  • 分析事务源码之后我们可以学到什么?

专车名词

事务

程序中通常使用事务来达到数据的一致性,从而避免脏数据

编程式事务

在业务方法开头开启事务,然后对我们的业务进行try-catch,假设没有异常则提交事务,如果出现异常,则在catch模块回滚事务

声明式事务由来

如果采用编程式事务,那么在任何需要事务的地方都要开启事务、try-catch、提交或者回滚事务,会导致重复编码、编写与业务无关的代码。基于spring aop思想,我们可以利用aop的方式,对需要使用事务的方法进行增强,将公用的部分提取出来,那么就实现了声明式事务。

spring提供的声明式事务

在需要使用事务的业务方法上添加@transactional注解,那么就可以使用事务的特性,要么成功,要么失败

spring aop核心概念

  • 切面:切面是由切点和通知组成
  • 切点:用来匹配符合条件类或方法
  • 通知:需要执行的操作

专车分析

基于spring boot自动配置原理,我们应该寻找xxxautoconfiguration自动配置类,此处要寻找和事务相关的,那么自然是transactionautoconfiguration

自动配置

打开transactionautoconfiguration自动配置类

@configuration
@conditionalonbean(platformtransactionmanager.class)
@conditionalonmissingbean(abstracttransactionmanagementconfiguration.class)
public static class enabletransactionmanagementconfiguration {

	@configuration
	@enabletransactionmanagement(proxytargetclass = false)
	@conditionalonproperty(prefix = "spring.aop", name = "proxy-target-class", havingvalue = "false", matchifmissing = false)
	public static class jdkdynamicautoproxyconfiguration {

	}

	@configuration
	@enabletransactionmanagement(proxytargetclass = true)
	@conditionalonproperty(prefix = "spring.aop", name = "proxy-target-class", havingvalue = "true", matchifmissing = true)
	public static class cglibautoproxyconfiguration {

	}

}

可以看到开启事务管理器的注解@enabletransactionmanagement

@target(elementtype.type)
@retention(retentionpolicy.runtime)
@documented
@import(transactionmanagementconfigurationselector.class)
public @interface enabletransactionmanagement {}

查看transactionmanagementconfigurationselector导入的类

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;
	}
}

可以看到导入了autoproxyregistrar和proxytransactionmanagementconfiguration

首先看看autoproxyregistrar,该类实现了importbeandefinitionregistrar

public void registerbeandefinitions(annotationmetadata importingclassmetadata, beandefinitionregistry registry) {
	boolean candidatefound = false;
	set<string> annotypes = importingclassmetadata.getannotationtypes();
	for (string annotype : annotypes) {
		annotationattributes candidate = annotationconfigutils.attributesfor(importingclassmetadata, annotype);
		if (candidate == null) {
			continue;
		}
		object mode = candidate.get("mode");
		object proxytargetclass = candidate.get("proxytargetclass");
		if (mode != null && proxytargetclass != null && advicemode.class == mode.getclass() &&
				boolean.class == proxytargetclass.getclass()) {
			candidatefound = true;
			if (mode == advicemode.proxy) {
			    // 注册自动代理创建器
				aopconfigutils.registerautoproxycreatorifnecessary(registry);
				if ((boolean) proxytargetclass) {
					aopconfigutils.forceautoproxycreatortouseclassproxying(registry);
					return;
				}
			}
		}
	}
}

注册自动代理创建器,aopconfigutils#registerautoproxycreatorifnecessary

public static beandefinition registerautoproxycreatorifnecessary(
			beandefinitionregistry registry, @nullable object source) {
    // 注册了infrastructureadvisorautoproxycreator到ioc容器中
	return registerorescalateapcasrequired(infrastructureadvisorautoproxycreator.class, registry, source);
}

infrastructureadvisorautoproxycreator是abstractautoproxycreator的子类,abstractautoproxycreator又实现了beanpostprocessor接口,那么在bean初始化完毕后就会调用postprocessafterinstantiation()方法,postprocessafterinstantiation()定义在abstractautoproxycreator类中

beanpostprocessor后置处理

打开abstractautoproxycreator

@override
public object postprocessafterinitialization(@nullable object bean, string beanname) {
	if (bean != null) {
		object cachekey = getcachekey(bean.getclass(), beanname);
		if (!this.earlyproxyreferences.contains(cachekey)) {
		    // 如果满足条件对bean进行包裹
			return wrapifnecessary(bean, beanname, cachekey);
		}
	}
	return bean;
}

该方法调用了wrapifnecessary()方法

protected object wrapifnecessary(object bean, string beanname, object cachekey) {
	// create proxy if we have advice.
  	// 获取bean的切面和通知
	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;
}

根据注释的意思就是如果存在advice,那么就创建代理,

寻找切面

进入abstractadvisorautoproxycreator#getadvicesandadvisorsforbean

protected object[] getadvicesandadvisorsforbean(
			class<?> beanclass, string beanname, @nullable targetsource targetsource) {
    // 查找符合条件的切面
	list<advisor> advisors = findeligibleadvisors(beanclass, beanname);
	// 不存在符合条件的切面,则不生成代理
	if (advisors.isempty()) {
		return do_not_proxy;
	}
	return advisors.toarray();
}

该代码第一句最重要,如果不存在符合条件的切面,那么最终的结果返回null,根据上面分析的,如果为null就不创建代理,否则创建代理。接下来看看第一句的实现

protected list<advisor> findeligibleadvisors(class<?> beanclass, string beanname) {
    // 获取所有候选的切面,也就是类型为advisor的切面,此处获取到的候选切面为beanfactorytransactionattributesourceadvisor
    list<advisor> candidateadvisors = findcandidateadvisors();
    // 从候选的切面中获取可以解析当前bean的切面,最终符合条件的切面为beanfactorytransactionattributesourceadvisor
    list<advisor> eligibleadvisors = findadvisorsthatcanapply(candidateadvisors, beanclass, beanname);
    extendadvisors(eligibleadvisors);
    if (!eligibleadvisors.isempty()) {
    	eligibleadvisors = sortadvisors(eligibleadvisors);
    }
    return eligibleadvisors;
}

为什么上面获取到的切面是beanfactorytransactionattributesourceadvisor?是否还记得之前导入配置类的时候还有一个配置类没有分析?那就是proxytransactionmanagementconfiguration

打开proxytransactionmanagementconfiguration

@configuration
public class proxytransactionmanagementconfiguration extends abstracttransactionmanagementconfiguration {

    // 创建beanfactorytransactionattributesourceadvisor
	@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;
	}

}

通过上面的自动配置,可得知获取到的候选切面为什么是beanfactorytransactionattributesourceadvisor

接下来看看如何从候选切面中找到可以解析当前bean的切面?

protected list<advisor> findadvisorsthatcanapply(
			list<advisor> candidateadvisors, class<?> beanclass, string beanname) {

	proxycreationcontext.setcurrentproxiedbeanname(beanname);
	try {
	    // 查找可以解析当前bean对应的切面
		return aoputils.findadvisorsthatcanapply(candidateadvisors, beanclass);
	}
	finally {
		proxycreationcontext.setcurrentproxiedbeanname(null);
	}
}

查找可以解析当前bean对应的切面,aoputils#findadvisorsthatcanapply

public static list<advisor> findadvisorsthatcanapply(list<advisor> candidateadvisors, class<?> clazz) {
	if (candidateadvisors.isempty()) {
		return candidateadvisors;
	}
	list<advisor> eligibleadvisors = new arraylist<>();
	for (advisor candidate : candidateadvisors) {
		if (candidate instanceof introductionadvisor && canapply(candidate, clazz)) {
			eligibleadvisors.add(candidate);
		}
	}
	boolean hasintroductions = !eligibleadvisors.isempty();
	for (advisor candidate : candidateadvisors) {
		if (candidate instanceof introductionadvisor) {
			// already processed
			continue;
		}
		// 当前切面是否可以解析bean
		if (canapply(candidate, clazz, hasintroductions)) {
			eligibleadvisors.add(candidate);
		}
	}
	return eligibleadvisors;
}

候选切面是否可以解析bean

public static boolean canapply(advisor advisor, class<?> targetclass, boolean hasintroductions) {
	if (advisor instanceof introductionadvisor) {
		return ((introductionadvisor) advisor).getclassfilter().matches(targetclass);
	}
	else if (advisor instanceof pointcutadvisor) {
	    // 由上面分析知道最终的候选切面为beanfactorytransactionattributesourceadvisor
	    // 该类实现了pointcutadvisor
		pointcutadvisor pca = (pointcutadvisor) advisor;
		return canapply(pca.getpointcut(), targetclass, hasintroductions);
	}
	else {
		// it doesn't have a pointcut so we assume it applies.
		return true;
	}
}

候选切面是否可以解析bean

public static boolean canapply(pointcut pc, class<?> targetclass, boolean hasintroductions) {
	assert.notnull(pc, "pointcut must not be null");
	if (!pc.getclassfilter().matches(targetclass)) {
		return false;
	}

    // 获取切面切点方法匹配对象,用来匹配方法是否符合
	methodmatcher methodmatcher = pc.getmethodmatcher();
	if (methodmatcher == methodmatcher.true) {
		// no need to iterate the methods if we're matching any method anyway...
		return true;
	}

	introductionawaremethodmatcher introductionawaremethodmatcher = null;
	if (methodmatcher instanceof introductionawaremethodmatcher) {
		introductionawaremethodmatcher = (introductionawaremethodmatcher) methodmatcher;
	}

	set<class<?>> classes = new linkedhashset<>();
	if (!proxy.isproxyclass(targetclass)) {
		classes.add(classutils.getuserclass(targetclass));
	}
	classes.addall(classutils.getallinterfacesforclassasset(targetclass));

	for (class<?> clazz : classes) {
	    // 通过反射获取当前类所有的method对象
		method[] methods = reflectionutils.getalldeclaredmethods(clazz);
		for (method method : methods) {
			if (introductionawaremethodmatcher != null ?
					introductionawaremethodmatcher.matches(method, targetclass, hasintroductions) :
					// 匹配方法是否符合
					methodmatcher.matches(method, targetclass)) {
				return true;
			}
		}
	}

	return false;
}

匹配方法transactionattributesourcepointcut#matches

public boolean matches(method method, class<?> targetclass) {
	if (transactionalproxy.class.isassignablefrom(targetclass) ||
			platformtransactionmanager.class.isassignablefrom(targetclass) ||
			persistenceexceptiontranslator.class.isassignablefrom(targetclass)) {
		return false;
	}
	transactionattributesource tas = gettransactionattributesource();
	// 如果事务属性源对象为空或者事务属性对象不为null返回true,代表匹配成功;否则返回false,匹配失败
	return (tas == null || tas.gettransactionattribute(method, targetclass) != null);
}

获取事务属性对象,abstractfallbacktransactionattributesource#gettransactionattribute

public transactionattribute gettransactionattribute(method method, @nullable class<?> targetclass) {
	if (method.getdeclaringclass() == object.class) {
		return null;
	}

	// first, see if we have a cached value.
	object cachekey = getcachekey(method, targetclass);
	transactionattribute cached = this.attributecache.get(cachekey);
	if (cached != null) {
		// value will either be canonical value indicating there is no transaction attribute,
		// or an actual transaction attribute.
		if (cached == null_transaction_attribute) {
			return null;
		}
		else {
			return cached;
		}
	}
	else {
		// 计算事务属性对象
		transactionattribute txattr = computetransactionattribute(method, targetclass);
		// put it in the cache.
		if (txattr == null) {
			this.attributecache.put(cachekey, null_transaction_attribute);
		}
		else {
			string methodidentification = classutils.getqualifiedmethodname(method, targetclass);
			if (txattr instanceof defaulttransactionattribute) {
				((defaulttransactionattribute) txattr).setdescriptor(methodidentification);
			}
			if (logger.istraceenabled()) {
				logger.trace("adding transactional method '" + methodidentification + "' with attribute: " + txattr);
			}
			this.attributecache.put(cachekey, txattr);
		}
		return txattr;
	}
}

计算事务属性对象

protected transactionattribute computetransactionattribute(method method, @nullable class<?> targetclass) {
	// don't allow no-public methods as required.
	if (allowpublicmethodsonly() && !modifier.ispublic(method.getmodifiers())) {
		return null;
	}

	// the method may be on an interface, but we need attributes from the target class.
	// if the target class is null, the method will be unchanged.
	method specificmethod = aoputils.getmostspecificmethod(method, targetclass);

	// first try is the method in the target class.
	// 首先根据method对象获取事务属性对象
	transactionattribute txattr = findtransactionattribute(specificmethod);
	if (txattr != null) {
		return txattr;
	}

	// second try is the transaction attribute on the target class.
	// 如果根据method对象获取不到事务属性对象,那么根据class来获取属性对象
	txattr = findtransactionattribute(specificmethod.getdeclaringclass());
	if (txattr != null && classutils.isuserlevelmethod(method)) {
		return txattr;
	}

	if (specificmethod != method) {
		// fallback is to look at the original method.
		txattr = findtransactionattribute(method);
		if (txattr != null) {
			return txattr;
		}
		// last fallback is the class of the original method.
		txattr = findtransactionattribute(method.getdeclaringclass());
		if (txattr != null && classutils.isuserlevelmethod(method)) {
			return txattr;
		}
	}

	return null;
}

获取属性对象annotationtransactionattributesource#findtransactionattribute

protected transactionattribute findtransactionattribute(class<?> clazz) {
	return determinetransactionattribute(clazz);
}

决定事务属性对象

protected transactionattribute determinetransactionattribute(annotatedelement element) {
	for (transactionannotationparser annotationparser : this.annotationparsers) {
		transactionattribute attr = annotationparser.parsetransactionannotation(element);
		if (attr != null) {
			return attr;
		}
	}
	return null;
}

解析事务属性对象,springtransactionannotationparser#parsetransactionannotation

public transactionattribute parsetransactionannotation(annotatedelement element) {
    // 判断元素是否含有@transactional注解,通过前面的分析我们可以得出如下结论:
    // 1、首选判断类的方法上是否含有@transactional注解,如果有就解析
    // 2、如果所有的方法都不含有@transactional注解,那么判断当前类是否含有@transactional注解,如果有就解析
    // 3、如果类或者类的某个方法含有@transactional注解,那么事务属性对象就不为空,则说明次切面可以解析当前bean
	annotationattributes attributes = annotatedelementutils.findmergedannotationattributes(
			element, transactional.class, false, false);
	if (attributes != null) {
		return parsetransactionannotation(attributes);
	}
	else {
		return null;
	}
}

回到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;
}

创建代理

创建代理abstractautoproxycreator#createproxy

protected object createproxy(class<?> beanclass, @nullable string beanname,
			@nullable object[] specificinterceptors, targetsource targetsource) {

	if (this.beanfactory instanceof configurablelistablebeanfactory) {
		autoproxyutils.exposetargetclass((configurablelistablebeanfactory) this.beanfactory, beanname, beanclass);
	}

    // 创建代理工厂
	proxyfactory proxyfactory = new proxyfactory();
	proxyfactory.copyfrom(this);

	if (!proxyfactory.isproxytargetclass()) {
		if (shouldproxytargetclass(beanclass, beanname)) {
			proxyfactory.setproxytargetclass(true);
		}
		else {
			evaluateproxyinterfaces(beanclass, proxyfactory);
		}
	}

    // 构建切面,此处的切面为beanfactorytransactionattributesourceadvisor
	advisor[] advisors = buildadvisors(beanname, specificinterceptors);
	// 设置切面
	proxyfactory.addadvisors(advisors);
	proxyfactory.settargetsource(targetsource);
	customizeproxyfactory(proxyfactory);

	proxyfactory.setfrozen(this.freezeproxy);
	if (advisorsprefiltered()) {
		proxyfactory.setprefiltered(true);
	}

	return proxyfactory.getproxy(getproxyclassloader());
}

获取代理proxyfactory#getproxy

public object getproxy(@nullable classloader classloader) {
	return createaopproxy().getproxy(classloader);
}

创建aop代理

protected final synchronized aopproxy createaopproxy() {
	if (!this.active) {
		activate();
	}
	// 此处的this实际上就是proxyfactory
	return getaopproxyfactory().createaopproxy(this);
}

aop代理工厂创建aop代理defaultaopproxyfactory#createaopproxy

public aopproxy createaopproxy(advisedsupport config) throws aopconfigexception {
	if (config.isoptimize() || config.isproxytargetclass() || hasnousersuppliedproxyinterfaces(config)) {
		class<?> targetclass = config.gettargetclass();
		if (targetclass == null) {
			throw new aopconfigexception("targetsource cannot determine target class: " +
					"either an interface or a target is required for proxy creation.");
		}
		if (targetclass.isinterface() || proxy.isproxyclass(targetclass)) {
			return new jdkdynamicaopproxy(config);
		}
		// 创建cglib aop代理
		return new objenesiscglibaopproxy(config);
	}
	else {
		return new jdkdynamicaopproxy(config);
	}
}

实例化objenesiscglibaopproxy对象

public objenesiscglibaopproxy(advisedsupport config) {
	super(config);
}

父类实例化

public cglibaopproxy(advisedsupport config) throws aopconfigexception {
	assert.notnull(config, "advisedsupport must not be null");
	if (config.getadvisors().length == 0 && config.gettargetsource() == advisedsupport.empty_target_source) {
		throw new aopconfigexception("no advisors and no targetsource specified");
	}
	// 此处的config就是之前的proxyfactory
	this.advised = config;
	this.adviseddispatcher = new adviseddispatcher(this.advised);
}

回到之前获取代理的地方

public object getproxy(@nullable classloader classloader) {
	return createaopproxy().getproxy(classloader);
}

通过上面的分析可以得知createaopproxy()返回的是cglibaopproxy

通过cglibaopproxy获取代理,cglibaopproxy#getproxy

public object getproxy(@nullable classloader classloader) {
	if (logger.istraceenabled()) {
		logger.trace("creating cglib proxy: " + this.advised.gettargetsource());
	}

	try {
		class<?> rootclass = this.advised.gettargetclass();
		assert.state(rootclass != null, "target class must be available for creating a cglib proxy");

		class<?> proxysuperclass = rootclass;
		if (classutils.iscglibproxyclass(rootclass)) {
			proxysuperclass = rootclass.getsuperclass();
			class<?>[] additionalinterfaces = rootclass.getinterfaces();
			for (class<?> additionalinterface : additionalinterfaces) {
				this.advised.addinterface(additionalinterface);
			}
		}

		// validate the class, writing log messages as necessary.
		validateclassifnecessary(proxysuperclass, classloader);

		// configure cglib enhancer...
		// 创建enhancer对象
		enhancer enhancer = createenhancer();
		if (classloader != null) {
			enhancer.setclassloader(classloader);
			if (classloader instanceof smartclassloader &&
					((smartclassloader) classloader).isclassreloadable(proxysuperclass)) {
				enhancer.setusecache(false);
			}
		}
		// 设置父类
		enhancer.setsuperclass(proxysuperclass);
		// 设置接口
		enhancer.setinterfaces(aopproxyutils.completeproxiedinterfaces(this.advised));
		enhancer.setnamingpolicy(springnamingpolicy.instance);
		enhancer.setstrategy(new classloaderawareundeclaredthrowablestrategy(classloader));

        // 获取回调,重点分析
		callback[] callbacks = getcallbacks(rootclass);
		class<?>[] types = new class<?>[callbacks.length];
		for (int x = 0; x < types.length; x++) {
			types[x] = callbacks[x].getclass();
		}
		// fixedinterceptormap only populated at this point, after getcallbacks call above
		enhancer.setcallbackfilter(new proxycallbackfilter(
				this.advised.getconfigurationonlycopy(), this.fixedinterceptormap, this.fixedinterceptoroffset));
		// 设置回调类型
		enhancer.setcallbacktypes(types);

		// generate the proxy class and create a proxy instance.
		// 生成代理并创建代理实例
		return createproxyclassandinstance(enhancer, callbacks);
	}
	catch (codegenerationexception | illegalargumentexception ex) {
		throw new aopconfigexception("could not generate cglib subclass of " + this.advised.gettargetclass() +
				": common causes of this problem include using a final class or a non-visible class",
				ex);
	}
	catch (throwable ex) {
		// targetsource.gettarget() failed
		throw new aopconfigexception("unexpected aop exception", ex);
	}
}

获取回调

private callback[] getcallbacks(class<?> rootclass) throws exception {
	// parameters used for optimization choices...
	boolean exposeproxy = this.advised.isexposeproxy();
	boolean isfrozen = this.advised.isfrozen();
	boolean isstatic = this.advised.gettargetsource().isstatic();

	// choose an "aop" interceptor (used for aop calls).
	// 实例化回调,在调用目标对象方法的时候执行
	callback aopinterceptor = new dynamicadvisedinterceptor(this.advised);
	return callbacks;
}

实例化回调部分

private static class dynamicadvisedinterceptor implements methodinterceptor, serializable {

	private final advisedsupport advised;

	public dynamicadvisedinterceptor(advisedsupport advised) {
	    // 设置切面信息,也就是之前的proxyfactory
		this.advised = advised;
	}

	@override
	@nullable
	// 调用目标方法的时候执行
	public object intercept(object proxy, method method, object[] args, methodproxy methodproxy) throws throwable {
		object oldproxy = null;
		boolean setproxycontext = false;
		object target = null;
		targetsource targetsource = this.advised.gettargetsource();
		try {
			if (this.advised.exposeproxy) {
				// make invocation available if necessary.
				oldproxy = aopcontext.setcurrentproxy(proxy);
				setproxycontext = true;
			}
			// get as late as possible to minimize the time we "own" the target, in case it comes from a pool...
			target = targetsource.gettarget();
			class<?> targetclass = (target != null ? target.getclass() : null);
		    // 获取通知,此处的通知为transactioninterceptor
			list<object> chain = this.advised.getinterceptorsanddynamicinterceptionadvice(method, targetclass);
			object retval;
			// check whether we only have one invokerinterceptor: that is,
			// no real advice, but just reflective invocation of the target.
			if (chain.isempty() && modifier.ispublic(method.getmodifiers())) {
				// we can skip creating a methodinvocation: just invoke the target directly.
				// note that the final invoker must be an invokerinterceptor, so we know
				// it does nothing but a reflective operation on the target, and no hot
				// swapping or fancy proxying.
				object[] argstouse = aopproxyutils.adaptargumentsifnecessary(method, args);
				retval = methodproxy.invoke(target, argstouse);
			}
			else {
				// we need to create a method invocation...
				retval = new cglibmethodinvocation(proxy, target, method, args, targetclass, chain, methodproxy).proceed();
			}
			retval = processreturntype(proxy, target, method, retval);
			return retval;
		}
		finally {
			if (target != null && !targetsource.isstatic()) {
				targetsource.releasetarget(target);
			}
			if (setproxycontext) {
				// restore old proxy.
				aopcontext.setcurrentproxy(oldproxy);
			}
		}
	}

	@override
	public boolean equals(object other) {
		return (this == other ||
				(other instanceof dynamicadvisedinterceptor &&
						this.advised.equals(((dynamicadvisedinterceptor) other).advised)));
	}

	/**
	 * cglib uses this to drive proxy creation.
	 */
	@override
	public int hashcode() {
		return this.advised.hashcode();
	}
}

调用invocation的处理方法,reflectivemethodinvocation#proceed

public object proceed() throws throwable {
	//	we start with an index of -1 and increment early.
	if (this.currentinterceptorindex == this.interceptorsanddynamicmethodmatchers.size() - 1) {
		return invokejoinpoint();
	}

    // 此处的通知transactioninterceptor
	object interceptororinterceptionadvice =
			this.interceptorsanddynamicmethodmatchers.get(++this.currentinterceptorindex);
	if (interceptororinterceptionadvice instanceof interceptoranddynamicmethodmatcher) {
		// evaluate dynamic method matcher here: static part will already have
		// been evaluated and found to match.
		interceptoranddynamicmethodmatcher dm =
				(interceptoranddynamicmethodmatcher) interceptororinterceptionadvice;
		class<?> targetclass = (this.targetclass != null ? this.targetclass : this.method.getdeclaringclass());
		if (dm.methodmatcher.matches(this.method, targetclass, this.arguments)) {
			return dm.interceptor.invoke(this);
		}
		else {
			// dynamic matching failed.
			// skip this interceptor and invoke the next in the chain.
			return proceed();
		}
	}
	else {
		// it's an interceptor, so we just invoke it: the pointcut will have
		// been evaluated statically before this object was constructed.
		// 调用transactioninterceptor#invoke
		return ((methodinterceptor) interceptororinterceptionadvice).invoke(this);
	}
}

调用transactioninterceptor#invoke

public object invoke(methodinvocation invocation) throws throwable {
	// work out the target class: may be {@code null}.
	// the transactionattributesource should be passed the target class
	// as well as the method, which may be from an interface.
	class<?> targetclass = (invocation.getthis() != null ? aoputils.gettargetclass(invocation.getthis()) : null);

	// adapt to transactionaspectsupport's invokewithintransaction...
	// 以事务的方式进行调用
	return invokewithintransaction(invocation.getmethod(), targetclass, invocation::proceed);
}

事务方式调用

protected object invokewithintransaction(method method, @nullable class<?> targetclass,
			final invocationcallback invocation) throws throwable {

	// if the transaction attribute is null, the method is non-transactional.
	transactionattributesource tas = gettransactionattributesource();
	final transactionattribute txattr = (tas != null ? tas.gettransactionattribute(method, targetclass) : null);
	final platformtransactionmanager tm = determinetransactionmanager(txattr);
	final string joinpointidentification = methodidentification(method, targetclass, txattr);

	if (txattr == null || !(tm instanceof callbackpreferringplatformtransactionmanager)) {
		// standard transaction demarcation with gettransaction and commit/rollback calls.
		// 创建事务信息对象
		transactioninfo txinfo = createtransactionifnecessary(tm, txattr, joinpointidentification);
		object retval = null;
		try {
			// this is an around advice: invoke the next interceptor in the chain.
			// this will normally result in a target object being invoked.
			// 调用被代理对象方法
			retval = invocation.proceedwithinvocation();
		}
		catch (throwable ex) {
			// target invocation exception
			// 业务方法执行异常,进行事务回滚
			completetransactionafterthrowing(txinfo, ex);
			throw ex;
		}
		finally {
		    // 清除事务信息对象
			cleanuptransactioninfo(txinfo);
		}
		// 提交事务
		committransactionafterreturning(txinfo);
		return retval;
	}

	else {
		final throwableholder throwableholder = new throwableholder();

		// it's a callbackpreferringplatformtransactionmanager: pass a transactioncallback in.
		try {
			object result = ((callbackpreferringplatformtransactionmanager) tm).execute(txattr, status -> {
				transactioninfo txinfo = preparetransactioninfo(tm, txattr, joinpointidentification, status);
				try {
					return invocation.proceedwithinvocation();
				}
				catch (throwable ex) {
					if (txattr.rollbackon(ex)) {
						// a runtimeexception: will lead to a rollback.
						if (ex instanceof runtimeexception) {
							throw (runtimeexception) ex;
						}
						else {
							throw new throwableholderexception(ex);
						}
					}
					else {
						// a normal return value: will lead to a commit.
						throwableholder.throwable = ex;
						return null;
					}
				}
				finally {
					cleanuptransactioninfo(txinfo);
				}
			});

			// check result state: it might indicate a throwable to rethrow.
			if (throwableholder.throwable != null) {
				throw throwableholder.throwable;
			}
			return result;
		}
		catch (throwableholderexception ex) {
			throw ex.getcause();
		}
		catch (transactionsystemexception ex2) {
			if (throwableholder.throwable != null) {
				logger.error("application exception overridden by commit exception", throwableholder.throwable);
				ex2.initapplicationexception(throwableholder.throwable);
			}
			throw ex2;
		}
		catch (throwable ex2) {
			if (throwableholder.throwable != null) {
				logger.error("application exception overridden by commit exception", throwableholder.throwable);
			}
			throw ex2;
		}
	}
}

到此事务的源码分析就结束了

专车总结

  • 导入autoproxyregistrar、proxytransactionmanagementconfiguration配置类
  • autoproxyregistrar用来注册infrastructureadvisorautoproxycreator到ioc中,infrastructureadvisorautoproxycreator实现了beanpostprocessor
  • 执行beanpostprocessor的后置处理
  • 获取由proxytransactionmanagementconfiguration配置类创建的切面
  • 通过切面解析bean是否需要创建代理,需要就创建代理
  • 执行代理的回调,在回调中拿到通知
  • 执行通知,通知里面逻辑:开启事务、执行目标方法、提交或回滚事务

专车回顾

回顾下开头的两个问题:

  • 为什么加上@transactional注解就可以实现事务?
  • 分析事务源码之后我们可以学到什么?

通过以上分析,第一个问题应该就迎刃而解了,那么通过以上学到的知识我们可以实现什么功能呢?在下一篇我们会在此基础上进行实战,通过@systemlog注解实现系统日志功能。感谢各位撸友乘坐此趟专车,欢迎下次继续乘坐

最后

师长,【java进阶架构师】号主,短短一年在各大平台斩获15w+程序员关注,专注分享java进阶、架构技术、高并发、微服务、bat面试、redis专题、jvm调优、springboot源码、mysql优化等20大进阶架构专题,关注【java进阶架构师】回复【架构】领取2019架构师完整视频一套。

转载说明:请务必注明来源(本文首发于公众号:【java进阶架构师】)