1.类继承关系
2.解析
ProxyCreatorSupport继承AdvisedSupport,主要提供了createAopProxy方法用来得到用来生成代理对象的AopProxy对象
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
return getAopProxyFactory().createAopProxy(this);
}
AopProxy有两种实现，JdkDynamicAopProxy和ObjenesisCglibAopProxy
public interface AopProxy {
Object getProxy();
Object getProxy(ClassLoader classLoader);
}
具体选择哪一种代理生成方式使用了DefaultAopProxyFactory这个工厂类来决定
在DefaultAopProxyFactory的createAopProxy方法中，会根据Aop的配置以及代理类的信息来选择使用jdk还是cglib来生成动态代理
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
if (targetClass.isInterface()) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}
讲一下我们比较熟悉的JDK动态代理吧
JdkDynamicAopProxy 实现了 InvocationHandler,也就是说生成代理的时候，它要把自己当做参数传进去
public Object getProxy(ClassLoader classLoader) {
if (logger.isDebugEnabled()) {
logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
}
Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
显而易见，具体的代理执行拦截器链的逻辑也就在JdkDynamicAopProxy 的invoke方法中
截取invoke中比较核心的代码片段
// Get the interception chain for this method.
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.
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
}
else {
// We need to create a method invocation...
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.
retVal = invocation.proceed();
}
先通过AdvisedSupport的getInterceptorsAndDynamicInterceptionAdvice拿到拦截器链，然后封装到ReflectiveMethodInvocation进行链式调用
下面来看下如何在ReflectiveMethodInvocation中执行链式调用，逻辑在它的proceed方法中
public Object proceed() throws Throwable {
//拦截器下标从-1开始
//如果没有拦截器链，直接进行连接点，也就是被切方法
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
//直接执行连接点逻辑
return invokeJoinpoint();
}
//获取下一个拦截器，第一次进来就-1+1=0，也就是第一个
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
//判断interceptorOrInterceptionAdvice是否是动态拦截器
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
//动态拦截器的methodMatcher匹配
//invoke执行完切面逻辑后，会调用this执行proceed方法，再次回到这个方法
return dm.interceptor.invoke(this);
}
else {
//动态拦截器的methodMatcher不匹配，再次执行proceed，相当于调用下一个拦截器
return proceed();
}
}
else {
//如果是静态拦截器，直接执行
//invoke执行完切面逻辑后，会调用this执行proceed方法，再次回到这个方法
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
invokeJoinpoint用反射来执行连接点的逻辑，也就是执行被切方法
protected Object invokeJoinpoint() throws Throwable {
return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
}
public static Object invokeJoinpointUsingReflection(Object target, Method method, Object[] args)
throws Throwable {
// Use reflection to invoke the method.
try {
ReflectionUtils.makeAccessible(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);
}
}
Cglib的实现也大同小异，代理的生成方式不同，但是拦截器链的调用逻辑应该一致
总结
ProxyCreatorSupport专注于提供生成代理对象的AopProxy，具体使用AopProxy生成代理对象在ProxyFactoryBean和ProxyFactory中使用，将在下一章讲解
