您的位置：首页 > 编程语言 > Java开发

Springboot源码分析之代理对象内嵌调用

2019-09-10 21:46 1396 查看

摘要：

关于这个话题可能最多的是

@Async

和

@Transactional

一起混用，我先解释一下什么是代理对象内嵌调用，指的是一个代理方法调用了同类的另一个代理方法。首先在这儿我要声明事务直接的嵌套调用除外，至于为什么，是它已经将信息保存在线程级别了，是不是又点儿抽象，感觉吃力，可以看看我前面关于事务的介绍。

@Async和@Transactional共存

@Component
public class AsyncWithTransactional {

@Async
@Transactional
public void test() {

}
}

这样一段代码会发生什么？熟悉的人都会感觉疑惑，都有效果么？谁先被代理增强？

自动代理创建器

AbstractAutoProxyCreator

它实际也是个

BeanPostProcessor

，所以它们的执行顺序很重要~~~

两者都继承自
```
ProxyProcessorSupport
```
所以都能创建代理，且实现了
```
Ordered
```
接口- - -- - ---
```
AsyncAnnotationBeanPostProcessor
```
默认的
```
order
```
值为
```
Ordered.LOWEST_PRECEDENCE
```
。但可以通过
```
@EnableAsync
```
指定
```
order
```
属性来改变此值。
```
AsyncAnnotationBeanPostProcessor
```
在创建代理时有这样一个逻辑：若已经是
```
Advised
```
对象了，那就只需要把
```
@Async
```
的增强器添加进去即可。若不是代理对象才会自己去创建

public abstract class AbstractAdvisingBeanPostProcessor extends ProxyProcessorSupport implements BeanPostProcessor {
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
if (bean instanceof Advised) {
advised.addAdvisor(this.advisor);
return bean;
}
// 上面没有return，这里会继续判断自己去创建代理~
}
}

```
AbstractAutoProxyCreator
```
默认值也同上。但是在把自动代理创建器添加进容器的时候有这么一句代码：
```
beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
```
自动代理创建器这个处理器是最高优先级
由上可知因为标注有
```
@Transactional
```
，所以自动代理会生效，因此它会先交给
```
AbstractAutoProxyCreator
```
把代理对象生成好了，再交给后面的处理器执行
由于
```
AbstractAutoProxyCreator
```
先执行，所以
```
AsyncAnnotationBeanPostProcessor
```
执行的时候此时
```
Bean
```
已经是代理对象了，此时它会沿用这个代理，只需要把切面添加进去即可~

方法调用顺序影响

想必大家都知道一点就是同类的方法调用只有入口方法被代理才会被增强，这是由于源码级别只处理入口方法调用，是你的话你也这样设计，不然方法栈那么深，你管得了那么多吗？既然知道了这个原因，那么我们接下来在看一下后面的列子。

沿用代理对象

java.lang.IllegalStateException: Cannot find current proxy: Set 'exposeProxy' property on Advised to 'true' to make it available.
at org.springframework.aop.framework.AopContext.currentProxy(AopContext.java:69)
at com.fsx.dependency.B.funTemp(B.java:14)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:343)
at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:206)
at com.sun.proxy.$Proxy44.funTemp(Unknown Source)
...

这个异常在上述情况最容易出现，然而解决的方法都是

@EnableAspectJAutoProxy(exposeProxy = true)

咦，是不是我们可以从容器中获取代理对象呢？没有错，从容器获取代理对象也是一种沿用代理对象来调用方法链的手段，但是你会用么？依赖于代理的具体实现而书写代码，这样移植性会非常差的。

揭秘@EnableAspectJAutoProxy(exposeProxy = true)

Spring

内建的类且都是代理类的处理类：

CglibAopProxy

和

JdkDynamicAopProxy

两者很类似，在处理这个逻辑上。所以此处只以

JdkDynamicAopProxy

作为代表进行说明即可。

我们知道在执行代理对象的目标方法的时候，都会交给

InvocationHandler

处理，因此做事情的在

invoke()

方法里：

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
...
@Override
@Nullable
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
...
if (this.advised.exposeProxy) {
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
...
finally {
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}
}

最终决定是否会调用

set

方法是由

this.advised.exposeProxy

这个值决定的，因此下面我们只需要关心

ProxyConfig.exposeProxy

这个属性值什么时候被赋值为

true

的就可以了。

ProxyConfig.exposeProxy

这个属性的默认值是

false

。其实最终调用设置值的是同名方法

Advised.setExposeProxy()

方法，而且是通过反射调用的,再次强调看清楚后置处理器，

@EnableAspectJAutoProxy(exposeProxy = true)

作用的范围在

AbstractAutoProxyCreator

创建器，异步注解和缓存注解等就不行了，怎么解决后面在分析。

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
AspectJAutoProxyRegistrar() {
}

public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
if (enableAspectJAutoProxy != null) {
if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
//处理是否设置了该属性
if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
}
}

}
}

看一下是如何设置属性值的，我们后面可以采用这样的方式来设置

public static void forceAutoProxyCreatorToExposeProxy(BeanDefinitionRegistry registry) {
if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
definition.getPropertyValues().add("exposeProxy", Boolean.TRUE);
}
}

什么时候使用的呢？

AopContext.setCurrentProxy(@Nullable Object proxy)

在

CglibAopProxy

和

JdkDynamicAopProxy

代理都有使用。

案例分析

@Component
public class AsyncWithTransactional {
//入口方法
@Transactional
public void transactional() {
//不使用代理对象调用的话，后续方法不会被增强
AsyncWithTransactional asyncWithTransactional = AsyncWithTransactional.class.cast(AopContext.currentProxy());
asyncWithTransactional.async();

}
@Async
public void async() {

}
}

这样都完全ok的，但是如果换一下呢就会跑出异常。

子线程引起的问题

@Transactional//@Transactional有此注解和没有毫无关系
@Async
public void transactional() {
AsyncWithTransactional asyncWithTransactional = AsyncWithTransactional.class.cast(AopContext.currentProxy());
asyncWithTransactional.async();
}
public void async() {

}

根本原因就是关键节点的执行时机问题。在执行代理对象

transactional

方法的时候，先执行绑定动作

AopContext.setCurrentProxy(proxy);

然后目标方法执行（包括增强器的执行）

invocation.proceed()

。其实在执行绑定的还是在主线程里而并非是新的异步线程，所以在你在方法体内（已经属于异步线程了）执行

AopContext.currentProxy()

那可不就报错了嘛~

所以入口方法用了类似

@Async

的效果注解都会导致代理对象绑定不对，继而导致调用错误。

如何解决类似子线程引起的问题呢？

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
BeanDefinition beanDefinition = beanFactory.getBeanDefinition(TaskManagementConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME);
beanDefinition.getPropertyValues().add("exposeProxy", true);
}
}

这样解决了

@Async

的绑定问题，

@EnableCaching

也可以基于这样的思想来解决，以上就是我的简单例子，但是配合我的文字说明，相信大家可以举一反三，随意玩弄它们之间的调用关系。
其实如果Spring做出源码改变会更好的解决这个问题

```
@Async
```
的代理也交给自动代理创建器来完成(Spring做出源码改变)
```
@EnableAsync
```
增加
```
exposeProxy
```
属性，默认值给
```
false
```
即可(Spring做出源码改变)

总结：

不要在异步线程里使用
```
AopContext.currentProxy()
```
576
```
AopContext.currentProxy()
```
不能使用在非代理对象所在方法体内

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航