首先对于InvocationHandler的创建是最为核心的，可以自定义类实现它。实现后需要重写3个函数：
接下来我们看一下Spring中的JDK代理方式是如何实现的吧。
看源码之前先大致了解一下Spring的JDK创建过程的大致流程
如图：
/**
* 代理对象的配置信息，例如保存了 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
Listpublic 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@Override
public List@Override
public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
List 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 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我们继续回到 JDKDynamicAopProxy.java 类中，完成了当前方法拦截器链的获取，接下来我们查看 MethodInvocation invocation =new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain); 这一段代码。改代码的主要作用就是将拦截器封装在 ReflectiveMethodInvocation ，以便于使用其proceed进行链接表用拦截器。
private int currentInterceptorIndex = -1;
protected ReflectiveMethodInvocation(
Object proxy, @Nullable Object target, Method method, @Nullable Object[] arguments,
@Nullable Class<?> targetClass, List@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 ，这里获取了所有的拦截器，然后通过ReflectiveMethodInvocation的构造方式进行了赋值，所以我们这里先看一下获取到的所有拦截器的顺序图，
从上面的顺序图中我们看到其顺序是AspectJAfterThrowingAdvice->AfterReturningAdviceInterceptor->AspectJAfterAdvice->MethodBeforeAdviceInterceptor，
因为proceed方法是递归调用的，所以该方法拦截器的执行顺序也是按照上面的顺序执行的。接下来我们先看一下proceed方法中的核心调用`dm.interceptor.invoke(this)`，这里很重要，因为它传入的参数是`this`，也就是`ReflectiveMethodInvocation` ，了解这些后我们先看一下`AspectJAfterThrowingAdvice`这拦截器链中第一个执行的连接器。@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;
}
}@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;
}@Override
@Nullable
public Object invoke(MethodInvocation mi) throws Throwable {
try {
// 直接调用MethodInvocation的proceed方法
return mi.proceed();
}
finally {
// 激活增强方法
invokeAdviceMethod(getJoinPointMatch(), null, null);
}
}@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();
}@Nullable
@Nullable
protected Object invokeJoinpoint() throws Throwable {
return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
}继续追踪 invokeJoinpointUsingReflection 方法：
@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，并且返回了结果。接下来我们继续想一下程序会怎么继续执行呢？
catch (Throwable ex) {
if (shouldInvokeOnThrowing(ex)) {
invokeAdviceMethod(getJoinPointMatch(), null, ex);
}
throw ex;
}如果目标bean的method或者前面的增强方法中出现了异常，则会被这里的catch捕获，也是通过反射的方式执行@AfterThrowing注解的方法，然后退栈
这个代理类的调用过程，我们可以看到时一个递归的调用过程，通过 ReflectiveMethodInvocation 的 proceed 方法递归调用，顺序执行拦截器链中的AspectJAfterThrowingAdvice、AfterReturningAdviceInterceptor、AspectJAfterAdvice、MethodBeforeAdviceInterceptor这几个拦截器，在拦截器中反射调用增强方法。
原文链接：https://www.tuicool.com/articles/uQ3Eni6
页面更新：2024-05-21
本站资料均由网友自行发布提供，仅用于学习交流。如有版权问题，请与我联系，QQ：4156828
© CopyRight 2020-2024 All Rights Reserved. Powered By 71396.com 闽ICP备11008920号-4
闽公网安备35020302034903号
