-
-
- 1 aop 代理如何执行的?
- 2 cglib代理分析
- 3 jdk代理分析
-
1 aop 代理如何执行的?
前两编主要分析代理是怎么创建，而且整过分析过程还是比较粗线条分析，真要非常详细分析估计用两编去写远远还是不够的，因为细节的内容实际太多了。另外我身有些细节我也不太理解。我通常比较关心整体的原理，然后慢慢深入分析，如果一开始就深入太多细节，恐怕很容易被绕进去出来。
2 cglib代理分析
直接debug进入代理
由上面的截图，很明显当前使用的是cglib的代理，也看到上一编曲在创建cglib 代理创建的那几个拦截器，下面f5进去代理方法testAAA里面，发现进入的是第一个拦截器
private class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {
//advisor信息
private final AdvisedSupport advised;
public DynamicAdvisedInterceptor(AdvisedSupport advised) {
this.advised = advised;
}
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object oldProxy = null;
boolean setProxyContext = false;
Class<?> targetClass = null;
Object target = null;
try {
//目标对象内部的自我调用将无法实施切面中的增强,
//<aop:aspect-autoproxy expose-proxy = "true"/>
if (this.advised.exposeProxy) {
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
// May be null. Get as late as possible to minimize the time we
// "own" the target, in case it comes from a pool...
target = getTarget();
if (target != null) {
targetClass = target.getClass();
}
//获取得当前拦截器链
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
Object retVal;
// Check whether we only have one InvokerInterceptor: that is,
// no real advice, but just reflective invocation of the target.
//如果拦截链为空，则仅仅是通过反身调用目标
if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
//没有任何advice 相当直接调用目标
retVal = methodProxy.invoke(target, argsToUse);
} else {
// We need to create a method invocation...
//传入拦截链路，创建Invocation，然后调用proceed();
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
}
//处理返回值
retVal = processReturnType(proxy, target, method, retVal);
return retVal;
} finally {
if (target != null) {
releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}
//省略一些代码
}
CglibMethodInvocation.proceed 处理拦截调用链
@Override
public Object proceed() throws Throwable {
// We start with an index of -1 and increment early.
//currentIndex 从-1开始递增，直到调用完所有拦截器，再调用连接点
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - ) {
return invokeJoinpoint();
}
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
// Evaluate dynamic method matcher here: static part will already have
// been evaluated and found to match.
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
else {
// Dynamic matching failed.
// Skip this interceptor and invoke the next in the chain.
return proceed();
}
}
else {
// It's an interceptor, so we just invoke it: The pointcut will have
// been evaluated statically before this object was constructed.
//调用interceptor，传入自身，以便拦截器回调自身的procced方法
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
//调用连接点
@Override
protected Object invokeJoinpoint() throws Throwable {
if (this.publicMethod) {
//调用目标方法
return this.methodProxy.invoke(this.target, this.arguments);
}
else {
//通过父类调用目标方法
return super.invokeJoinpoint();
}
}
上面截图可以看到两拦截器
public class ExposeInvocationInterceptor implements MethodInterceptor, PriorityOrdered, Serializable {
//省略部分代码
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
MethodInvocation oldInvocation = invocation.get();
invocation.set(mi);
try {
return mi.proceed();
}
finally {
invocation.set(oldInvocation);
}
}
//省略部分代码
}
MethodBeforeAdviceInterceptor
public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {
//省略一些代码
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
//执行前置方法
this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );
//继续执行下个拦截器
return mi.proceed();
}
}
AspectJAfterAdvice
public class AspectJAfterAdvice extends AbstractAspectJAdvice
implements MethodInterceptor, AfterAdvice, Serializable {
//省略一些代码
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
try {
//继续执行下一个拦截器
return mi.proceed();
}
finally {
//调用后置advice
invokeAdviceMethod(getJoinPointMatch(), null, null);
}
}
//省略一些代码
}
3 jdk代理分析
了解jdk动态代理应该都知道，jdk动态代理是利用目标类的接口去创建代理类的；换句话来说就是jdk动态代理的目标类必须实现一个接口；上面的demo目标类不太适用于此；再弄一个测试接口及目标类
其实jdk aop的代理过程与cglib代理差别并是不是很大，我们都知道jdk动态代理回调接口为InvocationHandler,而cglib的回调接口为MethodInterceptor，其主要差别就在两者口的实现上，后面的拦截过程是一样的；下来看一下jdk 代理的InvocationHandler invoke方法的实现JdkDynamicAopProxy
@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)) {
// 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;
}
target = targetSource.getTarget();
if (target != null) {
targetClass = target.getClass();
}
// 这一段代码跟cglib那边的实现是一样的，获取匹配的调用拦截链
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
if (chain.isEmpty()) {
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
}
else {
//上面大部分代码跟cglib的一样
//下面该类是cglib里用的CglibMethodInvocation的父类，内容基本是一样的
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, 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 aop代理的实现原理基介绍完了