Springboot中怎么調用代理對象內嵌

本篇文章給大家分享的是有關Springboot中怎么調用代理對象內嵌，小編覺得挺實用的，因此分享給大家學習，希望大家閱讀完這篇文章后可以有所收獲，話不多說，跟著小編一起來看看吧。

@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()

• AopContext.currentProxy()不能使用在非代理對象所在方法體內

以上就是Springboot中怎么調用代理對象內嵌，小編相信有部分知識點可能是我們日常工作會見到或用到的。希望你能通過這篇文章學到更多知識。更多詳情敬請關注億速云行業資訊頻道。