Aop的实现可以看成由基础设施准备和Aop运行辅助两个部分组成。AopProxy对象的生成，可以看成是一个静态的Aop基础设施的建立过程。对于应用触发的Aop应用，会涉及Aop框架的运行和对Aop基础设施的使用。这些动态部分就是拦截器回调的入口的开始，也是拦截器调用的实现原理。下面我们以JdkDynamicAopProxy的invoke拦截举例。
JdkDynamicAopProxy的invoke拦截
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
//构造方法
public JdkDynamicAopProxy(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");
}
//为当前对象设置AOP配置
this.advised = config;
}
//AopProxy代理对象的回调方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
MethodInvocation invocation;
Object oldProxy = null;
boolean setProxyContext = false;
//目标源
TargetSource targetSource = this.advised.targetSource;
Class<?> targetClass = null;
Object target = null;
try {
if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
//如果目标对象没有实现Object类的基本方法：equals.
return equals(args[0]);
}
if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
//如果目标对象没有实现Object类的基本方法：hashCode .
return hashCode();
}
if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// 如果AOP配置了通知，使用反射机制调用通知的同名方法...
return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
}
Object retVal;
//如果当前通知暴露了代理，则将当前代理使用currentProxy()方法变为可用代理
if (this.advised.exposeProxy) {
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
// 获得目标对象.
target = targetSource.getTarget();
if (target != null) {
targetClass = target.getClass();
}
// 获得该方法定义好的连接器链.
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
// 如果拦截器为空，那么直接调用target的对应方法，并获取方法返回值.
if (chain.isEmpty()) {
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
}
else {
// 为目标对象创建方法回调对象，需要在调用通知之后才调用目标对象的方法
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// 依次调用拦截器链，这是一个递归实现.
retVal = invocation.proceed();
}
// 方法有返回值，则将代理对象作为方法返回.
Class<?> returnType = method.getReturnType();
if (retVal != null && retVal == target && returnType.isInstance(proxy) &&
!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
//特殊情况：方法返回this，该方法的返回类型是兼容的。
//如果目标在另一个返回的对象中设置对自身的引用，我们将无法帮助
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()) {
// 释放目标对象
targetSource.releaseTarget(target);
}
if (setProxyContext) {
//释放代理对象.
AopContext.setCurrentProxy(oldProxy);
}
}
}
}
ReflectiveMethodInvocation的proceed方法
//处理AOP配置的通知
public Object proceed() throws Throwable {
//从索引为-1的拦截器开始调用，并按序递增
//若拦截器链中的拦截器迭代调用完毕，则就是调用target的函数
//这个函数是通过反射机制完成的，具体实现在AopUtils.invokeJoinpointUsingReflection方法中
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
//获取配置的Advice
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
//通知器或通知是动态匹配方法拦截器类型
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
//动态匹配方法拦截器 .
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
//进行匹配，如果这里和定义的Pointcut匹配，则调用这个advice
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
else {
//不匹配，则递归调用.
return proceed();
}
}
else {
//如果是一个interceptor，直接调用这个interceptor对应的方法.
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
