Spring的JDK动态代理如何实现的(源码解析)
前言
上一篇文章中提到了SpringAOP是如何决断使用哪种动态代理方式的,本文接上文讲解SpringAOP的JDK动态代理是如何实现的。SpringAOP的实现其实也是使用了
Proxy
和InvocationHandler
这两个东西的。
JDK动态代理的使用方式
首先对于InvocationHandler的创建是最为核心的,可以自定义类实现它。实现后需要重写3个函数:
- 构造函数,将代理的对象闯入
- invoke方法,此方法中实现了AOP增强的所有逻辑
- getProxy方法,此方法千篇一律,但是必不可少的一步
接下来我们看一下Spring中的JDK代理方式是如何实现的吧。
看源码之前先大致了解一下Spring的JDK创建过程的大致流程
如图:
- 看源码(
JdkDynamicAopProxy.java
)
/**
* 代理对象的配置信息,例如保存了 TargetSource 目标类来源、能够应用于目标类的所有 Advisor
*/
private final AdvisedSupport advised;
public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
Assert.notNull(config, "AdvisedSupport must not be null");
// config.getAdvisorCount() == 0 没有 Advisor,表示没有任何动作
if (config.getAdvisorCount() == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
throw new AopConfigException("No advisors and no TargetSource specified");
}
this.advised = config;
// 获取需要代理的接口(目标类实现的接口,会加上 Spring 内部的几个接口,例如 SpringProxy
this.proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
//判断目标类是否重写了 `equals` 或者 `hashCode` 方法
// 没有重写在拦截到这两个方法的时候,会调用当前类的实现
findDefinedEqualsAndHashCodeMethods(this.proxiedInterfaces);
}
@Override
public Object getProxy() {
return getProxy(ClassUtils.getDefaultClassLoader());
}
@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
if (logger.isTraceEnabled()) {
logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
}
// 调用 JDK 的 Proxy#newProxyInstance(..) 方法创建代理对象
// 传入的参数就是当前 ClassLoader 类加载器、需要代理的接口、InvocationHandler 实现类
return Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this);
}
@Override
@Nullable
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object oldProxy = null;
Boolean setProxyContext = false;
TargetSource targetSource = this.advised.targetSource;
Object target = null;
try {
if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
// The target does not implement the equals(Object) method itself.
return equals(args[0]);
} else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
// The target does not implement the hashCode() method itself.
return hashCode();
} else if (method.getDeclaringClass() == DecoratingProxy.class) {
// There is only getDecoratedClass() declared -> dispatch to proxy config.
return AopProxyUtils.ultimateTargetClass(this.advised);
} else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// Service invocations on ProxyConfig with the proxy config...
return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
}
Object retVal;
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);
// Get the interception chain for this method.
// 获取当前方法的拦截器链 具体实现是在 DefaultAdvisorChainFactory
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
// Check whether we have any advice. If we don't, we can fallback on direct
// reflective invocation of the target, and avoid creating a MethodInvocation.
if (chain.isEmpty()) {
// 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 = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
} else {
// We need to create a method invocation...
// 将拦截器封装在ReflectiveMethodInvocation,以便于使用其proceed进行链接表用拦截器
MethodInvocation invocation =
new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.
// 执行拦截器链
retVal = invocation.proceed();
}
// Massage return value if necessary.
Class<?> returnType = method.getReturnType();
// 返回结果
if (retVal != null && retVal == target &&
returnType != Object.class && returnType.isInstance(proxy) &&
!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
// Special case: it returned "this" and the return type of the method
// is type-compatible. Note that we can't help if the target sets
// a reference to itself in another returned object.
retVal = proxy;
} else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
throw new AopInvocationException(
"Null return value from advice does not match primitive return type for: " + method);
}
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) {
// Must have come from TargetSource.
targetSource.releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}
源码分析
从上面的源码可以看出Spring中的JDKDynamicAopProxy
和我们自定一JDK代理是一样的,也是实现了InvocationHandler
接口。并且提供了getProxy
方法创建代理类,重写了invoke
方法(该方法是一个回调方法)。具体看源码看源码
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object oldProxy = null;
Boolean setProxyContext = false;
TargetSource targetSource = this.advised.targetSource;
Object target = null;
try {
if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
// The target does not implement the equals(Object) method itself.
return equals(args[0]);
} else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
// The target does not implement the hashCode() method itself.
return hashCode();
} else if (method.getDeclaringClass() == DecoratingProxy.class) {
// There is only getDecoratedClass() declared -> dispatch to proxy config.
return AopProxyUtils.ultimateTargetClass(this.advised);
} else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// Service invocations on ProxyConfig with the proxy config...
return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
}
Object retVal;
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);
// Get the interception chain for this method.
// 获取当前方法的拦截器链 具体实现是在 DefaultAdvisorChainFactory
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
// Check whether we have any advice. If we don't, we can fallback on direct
// reflective invocation of the target, and avoid creating a MethodInvocation.
if (chain.isEmpty()) {
// 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 = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
} else {
// We need to create a method invocation...
// 将拦截器封装在ReflectiveMethodInvocation,以便于使用其proceed进行链接表用拦截器
MethodInvocation invocation =
new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.
// 执行拦截器链
retVal = invocation.proceed();
}
// Massage return value if necessary.
Class<?> returnType = method.getReturnType();
// 返回结果
if (retVal != null && retVal == target &&
returnType != Object.class && returnType.isInstance(proxy) &&
!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
// Special case: it returned "this" and the return type of the method
// is type-compatible. Note that we can't help if the target sets
// a reference to itself in another returned object.
retVal = proxy;
} else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
throw new AopInvocationException(
"Null return value from advice does not match primitive return type for: " + method);
}
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) {
// Must have come from TargetSource.
targetSource.releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}
源码分析
首先我们先看一下
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
该方法主要是获取目标bean中匹配method的增强器,并将增强器封装成拦截器链,具体实现是在DefaultAdvisorChainFactory
中。看源码(
DefaultAdvisorChainFactory.java
)
@Override
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
Advised config, Method method, @Nullable Class<?> targetClass) {
// This is somewhat tricky... We have to process introductions first,
// but we need to preserve order in the ultimate list.
AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
Advisor[] advisors = config.getAdvisors();
List<Object> interceptorList = new ArrayList<>(advisors.length);
Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
Boolean hasIntroductions = null;
// 获取bean中的所有增强器
for (Advisor advisor : advisors) {
if (advisor instanceof PointcutAdvisor) {
// Add it conditionally.
PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
Boolean match;
if (mm instanceof IntroductionAwareMethodMatcher) {
if (hasIntroductions == null) {
hasIntroductions = hasMatchingIntroductions(advisors, actualClass);
}
match = ((IntroductionAwareMethodMatcher) mm).matches(method, actualClass, hasIntroductions);
} else {
// 根据增强器中的Pointcut判断增强器是否能匹配当前类中的method
// 我们要知道目标Bean中并不是所有的方法都需要增强,也有一些普通方法
match = mm.matches(method, actualClass);
}
if (match) {
// 如果能匹配,就将 advisor 封装成 MethodInterceptor 加入到 interceptorList 中
// 具体实现在 DefaultAdvisorAdapterRegistry
MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
if (mm.isRuntime()) {
// Creating a new object instance in the getInterceptors() method
// isn't a problem as we normally cache created chains.
for (MethodInterceptor interceptor : interceptors) {
interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
}
} else {
interceptorList.addAll(Arrays.asList(interceptors));
}
}
}
} else if (advisor instanceof IntroductionAdvisor) {
IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
} else {
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
return interceptorList;
}
源码分析
我们知道并不是所有的方法都需要增强,我们在刚刚也有提到,所以我们需要遍历所有的
Advisor
,根据Pointcut判断增强器是否能匹配当前类中的method,取出能匹配的增强器,紧接着查看MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
,如果能够匹配了直接封装成 MethodInterceptor,加入到拦截器链中,看源码
@Override
public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
List<MethodInterceptor> interceptors = new ArrayList<>(3);
Advice advice = advisor.getAdvice();
if (advice instanceof MethodInterceptor) {
interceptors.add((MethodInterceptor) advice);
}
// 这里遍历三个适配器,将对应的advisor转化成Interceptor
// 这三个适配器分别是 MethodBeforeAdviceAdapter,AfterReturningAdviceAdapter,ThrowsAdviceAdapter
for (AdvisorAdapter adapter : this.adapters) {
if (adapter.supportsAdvice(advice)) {
interceptors.add(adapter.getInterceptor(advisor));
}
}
if (interceptors.isEmpty()) {
throw new UnknownAdviceTypeException(advisor.getAdvice());
}
return interceptors.toArray(new MethodInterceptor[0]);
}
private final List<AdvisorAdapter> adapters = new ArrayList<>(3);
public DefaultAdvisorAdapterRegistry() {
registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
registerAdvisorAdapter(new AfterReturningAdviceAdapter());
registerAdvisorAdapter(new ThrowsAdviceAdapter());
}
源码分析
在spring中AspectJAroundAdvice
、AspectJAfterAdvice
、AspectJAfterThrowingAdvice
这3个增强器都实现了MethodInterceptor
接口,AspectJMethodBeforeAdvice
和AspectJAfterReturningAdvice
并没有实现 MethodInterceptor
接口;因此这里Spring这里采用的是适配器模式
,注意这里spring采用了适配器模式
将AspectJMethodBeforeAdvice
和AspectJAfterReturningAdvice
转化成能满足需求的MethodInterceptor实现
然后遍历adapters,通过adapter.supportsAdvice(advice)
找到advice对应的适配器,adapter.getInterceptor(advisor)将
advisor转化成对应的interceptor;
有兴趣的可以看一下可以自行查看一下
AspectJAroundAdvice
、AspectJMethodBeforeAdvice
、AspectJAfterAdvice
、AspectJAfterReturningAdvice
、AspectJAfterThrowingAdvice
、这几个增强器。以及MethodBeforeAdviceAdapter
、AfterReturningAdviceAdapter
这两个适配器。
经过适配器模式的操作,我们获取到了一个拦截器链。链中包括AspectJAroundAdvice、AspectJAfterAdvice、AspectJAfterThrowingAdvice、MethodBeforeAdviceInterceptor、AfterReturningAdviceInterceptor
终于经过上述的流程,`List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);`这一步完成。获取到了当前方法的拦截器链
我们继续回到JDKDynamicAopProxy.java
类中,完成了当前方法拦截器链的获取,接下来我们查看MethodInvocation invocation =new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
这一段代码。改代码的主要作用就是将拦截器封装在ReflectiveMethodInvocation
,以便于使用其proceed进行链接表用拦截器。
- 看源码(
ReflectiveMethodInvocation.java
)
private int currentInterceptorIndex = -1;
protected ReflectiveMethodInvocation(
Object proxy, @Nullable Object target, Method method, @Nullable Object[] arguments,
@Nullable Class<?> targetClass, List<Object> interceptorsAndDynamicMethodMatchers) {
this.proxy = proxy;
this.target = target;
this.targetClass = targetClass;
this.method = BridgeMethodResolver.findBridgedMethod(method);
this.arguments = AopProxyUtils.adaptArgumentsIfNecessary(method, arguments);
this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers;
}
源码分析
ReflectiveMethodInvocation的构造器做了简单的赋值、链的封装,不过要注意一下
private int currentInterceptorIndex = -1;
这行代码。这个变量代表的是Interceptor的下标,从-1开始的,Interceptor执行一个,就会走++this.currentInterceptorIndex
,看完构造函数,接着看一下proceed
方法看源码(
ReflectiveMethodInvocation.java
)
@Override
@Nullable
public Object proceed() throws Throwable {
// We start with an index of -1 and increment early.
/*
* 首先,判断是不是所有的interceptor(也可以想像成advisor)都被执行完了。
* 判断的方法是看 currentInterceptorIndex 这个变量的值,有没有增加到Interceptor总个数这个数值
* 如果到了,就执行被代理方法 invokeJoinpoint();如果没到,就继续执行Interceptor。
* */
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
// 如果Interceptor没有被全部执行完,就取出要执行的Interceptor,并执行
// currentInterceptorIndex 先自增
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
// 如果Interceptor是PointCut类型
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());
// 如果当前方法符合Interceptor的PointCut限制,就执行Interceptor
if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
// 这里将this当变量传进去,这是非常重要的一点
return dm.interceptor.invoke(this);
}
// 如果不符合,就跳过当前Interceptor,执行下一个Interceptor else {
// Dynamic matching failed.
// Skip this interceptor and invoke the next in the chain.
return proceed();
}
}
// 如果Interceptor不是PointCut类型,就直接执行Interceptor里面的增强。 else {
// It's an interceptor, so we just invoke it: The pointcut will have
// been evaluated statically before this object was constructed.
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
- 源码分析
分析proceed
方法时,首先我们回到JDKDynamicAopProxy
的类中查看一下List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
,这里获取了所有的拦截器,然后通过ReflectiveMethodInvocation的构造方式进行了赋值,所以我们这里先看一下获取到的所有拦截器的顺序图,
从上面的顺序图中我们看到其顺序是AspectJAfterThrowingAdvice->AfterReturningAdviceInterceptor->AspectJAfterAdvice->MethodBeforeAdviceInterceptor,
因为proceed方法是递归调用的,所以该方法拦截器的执行顺序也是按照上面的顺序执行的。接下来我们先看一下proceed方法中的核心调用`dm.interceptor.invoke(this)`,这里很重要,因为它传入的参数是`this`,也就是`ReflectiveMethodInvocation` ,了解这些后我们先看一下`AspectJAfterThrowingAdvice`这拦截器链中第一个执行的连接器。
- 看源码(
AspectJAfterThrowingAdvice.java
)
@Override
@Nullable
public Object invoke(MethodInvocation mi) throws Throwable {
try {
// 直接调用MethodInvocation的proceed方法
// 从proceed()方法中我们知道dm.interceptor.invoke(this)传过来的参数就是 ReflectiveMethodInvocation 执行器本身
// 也就是说这里又直接调用了 ReflectiveMethodInvocation 的proceed()方法
return mi.proceed();
}
catch (Throwable ex) {
if (shouldInvokeOnThrowing(ex)) {
invokeAdviceMethod(getJoinPointMatch(), null, ex);
}
throw ex;
}
}
源码分析
该类的invoke方法中,注意
mi.proceed()
,上面我们说到dm.interceptor.invoke(this)传过来的参数就是ReflectiveMethodInvocation执行器本身,所以mi就是ReflectiveMethodInvocation,也就是说又会执行ReflectiveMethodInvocation的proceed方法,然后使ReflectiveMethodInvocation的变量currentInterceptorIndex自增,紧接着就会获取拦截器链中的下一个拦截器AfterReturningAdviceInterceptor,执行它的invoke方法,此时第一个拦截器的invoke方法就卡在了mi.proceed()
这里;继续追踪AfterReturningAdviceInterceptor.java
的源码看源码
@Override
@Nullable
public Object invoke(MethodInvocation mi) throws Throwable {
// 直接调用MethodInvocation的proceed方法
Object retVal = mi.proceed();
this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
return retVal;
}
源码分析
和第一个拦截器一样,它也是调用了ReflectiveMethodInvocation的proceed方法,此时第二个拦截器也会卡在
mi.proceed
这里。并且使ReflectiveMethodInvocation的变量currentInterceptorIndex自增,紧接着又会获取下一个拦截器AspectJAfterAdvice.java
,看源码(
AspectJAfterAdvice.java
)
@Override
@Nullable
public Object invoke(MethodInvocation mi) throws Throwable {
try {
// 直接调用MethodInvocation的proceed方法
return mi.proceed();
}
finally {
// 激活增强方法
invokeAdviceMethod(getJoinPointMatch(), null, null);
}
}
源码分析
此时这个类的invoke方法也会执行ReflectiveMethodInvocation方法的proceed方法,同样也使currentInterceptorIndex变量自增,此时第三个拦截器也会卡在
mi.proceed
方法上,ReflectiveMethodInvocation又去调用下一个拦截器MethodBeforeAdviceInterceptor.java
的invoke方法看源码
@Override
@Nullable
public Object invoke(MethodInvocation mi) throws Throwable {
// 这里终于开始做事了,调用增强器的before方法,明显是通过反射的方式调用
// 到这里增强方法before的业务逻辑执行
this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
// 又调用了调用MethodInvocation的proceed方法
return mi.proceed();
}
源码分析
此时,
this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
这里终于利用反射的方式调用了切面里面增强器的before方法,这时ReflectiveMethodInvocation的this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1
应该为true了,那么就会执行return invokeJoinpoint();
这行代码也就是执行bean的目标方法,接下来我们来看看目标方法的执行看源码(
ReflectiveMethodInvocation.java
)
@Nullable
@Nullable
protected Object invokeJoinpoint() throws Throwable {
return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
}
继续追踪invokeJoinpointUsingReflection
方法:
- 看源码(
AopUtils.java
)
@Nullable
public static Object invokeJoinpointUsingReflection(@Nullable Object target, Method method, Object[] args)
throws Throwable {
// Use reflection to invoke the method.
try {
ReflectionUtils.makeAccessible(method);
// 直接通过反射调用目标bean中的method
return method.invoke(target, args);
}
catch (InvocationTargetException ex) {
// Invoked method threw a checked exception.
// We must rethrow it. The client won't see the interceptor.
throw ex.getTargetException();
}
catch (IllegalArgumentException ex) {
throw new AopInvocationException("AOP configuration seems to be invalid: tried calling method [" +
method + "] on target [" + target + "]", ex);
}
catch (IllegalAccessException ex) {
throw new AopInvocationException("Could not access method [" + method + "]", ex);
}
}
- 源码分析
before方法执行完后,就通过反射的方式执行目标bean中的method,并且返回了结果。接下来我们继续想一下程序会怎么继续执行呢?
- MethodBeforeAdviceInterceptor执行完了后,开始退栈,AspectJAfterAdvice中invoke卡在第5行的代码继续往下执行, 我们看到在AspectJAfterAdvice的invoke方法中的finally中第8行有这样一句话
invokeAdviceMethod(getJoinPointMatch(), null, null);
这里就是通过反射调用AfterAdvice的方法,意思是切面类中的 @After方法不管怎样都会执行,因为在finally中。- AspectJAfterAdvice中invoke方法发执行完后,也开始退栈,接着就到了AfterReturningAdviceInterceptor的invoke方法的
Object retVal = mi.proceed()
开始恢复,但是此时如果目标bean和前面增强器中出现了异常,此时AfterReturningAdviceInterceptor中this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis())
这一行代码就不会执行了,直接退栈;如果没有出现异常,则执行这一行,也就是通过反射执行切面类中@AfterReturning注解的方法,然后退栈- AfterReturningAdviceInterceptor退栈后,就到了AspectJAfterThrowingAdvice拦截器,此拦截器中invoke方法的
return mi.proceed();
这一行代码开始恢复;我们看到在 catch (Throwable ex) { 代码中,也catch (Throwable ex) {
if (shouldInvokeOnThrowing(ex)) {
invokeAdviceMethod(getJoinPointMatch(), null, ex);
}
throw ex;
}
如果目标bean的method或者前面的增强方法中出现了异常,则会被这里的catch捕获,也是通过反射的方式执行@AfterThrowing注解的方法,然后退栈
总结
这个代理类的调用过程,我们可以看到时一个递归的调用过程,通过ReflectiveMethodInvocation
的proceed方法递归调用,顺序执行拦截器链中的AspectJAfterThrowingAdvice、AfterReturningAdviceInterceptor、AspectJAfterAdvice、MethodBeforeAdviceInterceptor这几个拦截器,在拦截器中反射调用增强方法。
微信搜索【码上遇见你】获取更多精彩内容
Spring的JDK动态代理如何实现的(源码解析)的更多相关文章
- MyBatis Mapper 接口如何通过JDK动态代理来包装SqlSession 源码分析
我们以往使用ibatis或者mybatis 都是以这种方式调用XML当中定义的CRUD标签来执行SQL 比如这样 <?xml version="1.0" encoding=& ...
- Spring AOP --JDK动态代理方式
我们知道Spring是通过JDK或者CGLib实现动态代理的,今天我们讨论一下JDK实现动态代理的原理. 一.简述 Spring在解析Bean的定义之后会将Bean的定义生成一个BeanDefinit ...
- Spring Cloud系列(四):Eureka源码解析之客户端
一.自动装配 1.根据自动装配原理(详见:Spring Boot系列(二):Spring Boot自动装配原理解析),找到spring-cloud-netflix-eureka-client.jar的 ...
- 浅谈Spring中JDK动态代理与CGLIB动态代理
前言Spring是Java程序员基本不可能绕开的一个框架,它的核心思想是IOC(控制反转)和AOP(面向切面编程).在Spring中这两个核心思想都是基于设计模式实现的,IOC思想的实现基于工厂模式, ...
- SSM-Spring-09:Spring中jdk动态代理
------------吾亦无他,唯手熟尔,谦卑若愚,好学若饥------------- JDK动态代理: 为何叫JDK动态代理呢? 所谓JDK,jdk是java开发工具包,它里面包含了一个动态代理的 ...
- Spring AOP JDK动态代理与CGLib动态代理区别
静态代理与动态代理 静态代理 代理模式 (1)代理模式是常用设计模式的一种,我们在软件设计时常用的代理一般是指静态代理,也就是在代码中显式指定的代理. (2)静态代理由 业务实现类.业务代理类 两部分 ...
- Spring Cloud系列(三):Eureka源码解析之服务端
一.自动装配 1.根据自动装配原理(详见:Spring Boot系列(二):Spring Boot自动装配原理解析),找到spring-cloud-starter-netflix-eureka-ser ...
- java动态代理基本原理及proxy源码分析一
本系列文章主要是博主在学习spring aop的过程中了解到其使用了java动态代理,本着究根问底的态度,于是对java动态代理的本质原理做了一些研究,于是便有了这个系列的文章 为了尽快进入正题,这里 ...
- 【JDK】:java.lang.Integer源码解析
本文对JDK8中的java.lang.Integer包装类的部分数值缓存技术.valueOf().stringSize().toString().getChars().parseInt()等进行简要分 ...
随机推荐
- 硬核! Github上 ,star超高的Java 开源项目分享给你!
Awsome JavaGreat Java project on Github(Github 上非常棒的 Java 开源项目). English Version 大家都知道 Github 是一个程序员 ...
- CPU内部结构域寄存器
CPU内部结构域寄存器 64位和32位系统区别: 寄存器是CPU内部最基本的存储单元. CPU对外是通过总线(地址.控制.数据)来和外部设备交互的,总线的宽度是8位,同时CPU的寄存器也是8位,那 ...
- 干货:详解C++ sort函数的cmp参数!
学算法的第一天你在学冒泡.桶排 在你还没搞明白快排和归并的时候 你已经学到了数据结构最后的堆排序和希尔排序 可以说排序是很多竞赛生的噩梦-- 于是它诞生了 void std::sort() Sort ...
- Gitlab(2)- centos7.x 下安装社区版 Gitlab 以及它的配置管理
前置准备:虚拟机安装以及配置相关 包含安装 centos7.8 虚拟机.设置静态 ip 等 https://www.cnblogs.com/poloyy/category/1703784.html 注 ...
- shell脚本测试变量是否为空,测试文件是否存在,sed修改配置文件参数,分支语句
Shell脚本 1. 基本的几个变量 使用$?获取最近一次的执行结果: 使用$#获取传递的参数个数,类似C语言中的int argc; 使用$@获取所有的传参,类似C语言的char **argv 2. ...
- LayoutControl控件使用
因默认外边距过大需要将外边距缩小用以下代码实现layoutControlGroup1.Padding = DevExpress.XtraLayout.Utils.Padding.Empty;是否允许只 ...
- 【MyBatis】几种批量插入效率的比较
批处理数据主要有三种方式: 反复执行单条插入语句 foreach 拼接 sql 批处理 一.前期准备 基于Spring Boot + Mysql,同时为了省略get/set,使用了lombok,详见p ...
- vue 进入页面每次都调用methods里的方法
// 监听路由,每次进入页面调用方法,放在method里 mounted(){ this.getPath() }, methods: { getPath(){ console.log(this.$ro ...
- 【第一篇】- Maven 系列教程之Spring Cloud直播商城 b2b2c电子商务技术总结
Maven 教程 Maven 翻译为"专家"."内行",是 Apache 下的一个纯 Java 开发的开源项目.基于项目对象模型(缩写:POM)概念,Maven ...
- 彻底解决Hive小文件问题
最近发现离线任务对一个增量Hive表的查询越来越慢,这引起了我的注意,我在cmd窗口手动执行count操作查询发现,速度确实很慢,才不到五千万的数据,居然需要300s,这显然是有问题的,我推测可能是有 ...