AOP基础——JdkDynamicAopProxy
2022-12-12 本文已影响0人
王侦
1.示例代码
public class Main {
public static void main(String[] args) {
//1. 创建被代理对象
Cat cat = new Cat();
System.out.println("--------------------");
//2. 创建Spring 代理工厂对象 ProxyFactory
// ProxyFactory 是Config + Factory 的存在,持有Aop操作所有的生产资料
ProxyFactory proxyFactory = new ProxyFactory(cat);
//3. 添加方法拦截器
MyPointcut pointcut = new MyPointcut();
proxyFactory.addAdvisor(new DefaultPointcutAdvisor(pointcut, new MethodInterceptor01()));
proxyFactory.addAdvisor(new DefaultPointcutAdvisor(pointcut, new MethodInterceptor02()));
//4. 获取代理对象
Animal proxy = (Animal) proxyFactory.getProxy();
proxy.eat();
System.out.println("--------------------");
proxy.go();
}
}
结果,只有eat()方法被加强了:
--------------------
methodInterceptor01 begin
MethodInterceptor02 begin
猫猫 吃 猫粮!
MethodInterceptor02 end
methodInterceptor01 end
--------------------
猫猫 跑跑~!
切点:
- 1)匹配所有类
- 2)匹配eat()方法
public class MyPointcut implements Pointcut {
@Override
public ClassFilter getClassFilter() {
return new ClassFilter() {
@Override
public boolean matches(Class<?> clazz) {
return true;
}
};
}
@Override
public MethodMatcher getMethodMatcher() {
return new MethodMatcher() {
@Override
public boolean matches(Method method, Class<?> targetClass) {
if(method.getName().equals("eat")) {
return true;
}
return false;
}
@Override
public boolean isRuntime() {
return false;
}
@Override
public boolean matches(Method method, Class<?> targetClass, Object... args) {
return false;
}
};
}
}
2.ProxyFactory#getProxy()
public Object getProxy() {
//主要分析 JdkDynamicAopProxy, 假设 createAopProxy 返回的就是 JdkDynamicAopProxy
return createAopProxy().getProxy();
}
2.1 ProxyCreatorSupport#createAopProxy
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
return getAopProxyFactory().createAopProxy(this);
}
/**
* config 就是我们的ProxyFactory对象,咱们说过 ProxyFactory
* 它是一个配置管理对象,保存着 创建 代理对象所有的生产资料呢。
*/
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
//条件一:config.isOptimize() 暂且不管
//条件二:config.isProxyTargetClass() true 强制使用cglib 动态代理
//条件三:hasNoUserSuppliedProxyInterfaces(config)
// 说明被代理对象 没有实现任何接口,没有办法使用JDK动态代理,只能使用cglib动态代理
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.");
}
//条件成立:说明targetClass是接口 或者 已经是被代理过的类型了,只能使用Jdk动态代理
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
else {
//执行到else 什么情况? targetClass 是实现了接口情况下,
// 会走这个分支!咱们大多数情况都是 面向接口 编程,所以主要分析 JdkDynamicAopProxy
return new JdkDynamicAopProxy(config);
}
}
2.2 JdkDynamicAopProxy#getProxy()
@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());
}
// 获取需要代理的接口数组
Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
// 查找当前所有的需要代理的接口,看看 是否有
// equals 方法 和 hashcode 方法,如果有,就打个标记。
findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
// classLoader :类加载器
// proxiedInterfaces :生成的代理类 需要 实现的接口集合
// this? : JdkDynamicAopProxy 该类 实现了 InvocationHandler 接口
// 该方法最终会返回一个 代理类 对象。
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
生成的代理类类似于下面所示:
public final class $proxy0 extends Proxy implements Animal {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $proxy0(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void eat() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
所有方法最后都经由InvocationHandler#invoke进行处理
3.调用流程JdkDynamicAopProxy#invoke
/**
* Implementation of {@code InvocationHandler.invoke}.
* <p>Callers will see exactly the exception thrown by the target,
* unless a hook method throws an exception.
* * @param proxy 代理对象
* * @param method 目标对象的方法
* * @param args 目标对象方法对应的参数
*/
@Override
@Nullable
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object oldProxy = null;
boolean setProxyContext = false;
// 获取到创建ProxyFactory时 提供的 target
TargetSource targetSource = this.advised.targetSource;
// 真正的target 的一个引用
Object target = null;
try {
// 条件成立,说明代理类实现的哪些接口 没有定义equals方法,
// 并且当前method 是 equals方法的话,就使用JdkDynamicAopProxy 提供的 equals方法。
if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
// The target does not implement the equals(Object) method itself.
return equals(args[0]);
}
// 条件成立,说明代理类实现的哪些接口 没有定义hashCode方法,
// 并且当前method 是 hashCode方法的话,就使用JdkDynamicAopProxy 提供的 equals方法。
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;
//this.advised.exposeProxy 如果是true,
// 就要把当前这个代理对象,暴漏 到Aop上下文内。
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.
// 根据targetSource拿到真正的目标对象
target = targetSource.getTarget();
// 获取到目标对象的 class
Class<?> targetClass = (target != null ? target.getClass() : null);
// 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.
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
// 直接调用目标对象的目标方法。
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
}
// 说明有匹配当前method的方法拦截器,所以要做增强处理了。
else {
// We need to create a method invocation...
MethodInvocation invocation =
new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.
// 核心!注释 :ReflectiveMethodInvocation
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) {
// 将 上次设置的proxy 再次 设置回去到 AopContext中。
// 因为当前代理对象的方法已经完事了,需要回到再上一层逻辑了,
// 这里是一个恢复现场的逻辑。
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}
3.1获取目标方法的拦截器
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class<?> targetClass) {
MethodCacheKey cacheKey = new MethodCacheKey(method);
List<Object> cached = this.methodCache.get(cacheKey);
if (cached == null) {
cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
this, method, targetClass);
this.methodCache.put(cacheKey, cached);
}
return cached;
}
DefaultAdvisorChainFactory#getInterceptorsAndDynamicInterceptionAdvice
/**
* 该方法的目的,就是查找出来适合当前方法 增强!
* @param config ProxyFactory,它掌握着AOP的所有资料呢
* @param method 目标对象的方法
* @param targetClass 目标对象的类型
*/
@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 接口有两个作用,一个作用是
// 可以向里面注册 AdvisorAdapter 适配器
// 适配器目的:1. 将非Advisor 类型的 增强,包装成为Advisor
// 2. 将Advisor 类型的增强 提取出来对应 MethodInterceptor
AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
// 获取出来 ProxyFactory 内部 持有的 增强信息
// 1. addAdvice()
// 2. AddAdvisor() 最终 在ProxyFactory 内 都会包装成 Advisor 的。
Advisor[] advisors = config.getAdvisors();
List<Object> interceptorList = new ArrayList<>(advisors.length);
// 真实的目标对象类型
Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
Boolean hasIntroductions = null;
for (Advisor advisor : advisors) {
//条件成立:说明当前advisor是包含 切点 信息的,
// 所以 这个if内部的逻辑,就是做匹配算法。
if (advisor instanceof PointcutAdvisor) {
// Add it conditionally.
// 转换成 可以获取到切点信息的接口。
PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
// 条件二:成立,说明当前被代理对象的class 匹配
// 当前 Advisor 成功,这一步 只是class 匹配成功。
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 {
// 如果 目标方法 匹配成功 ,那么match = true,静态匹配成功。
match = mm.matches(method, actualClass);
}
//静态匹配成功的话,再检查是否需要 运行时匹配。
if (match) {
// 提取出来 advisor内持有的拦截器信息
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 {
// 将当前advisor内部的方法拦截器 追加到 interceptorList
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));
}
}
// 说明当前 Advisor 匹配全部class 全部 method
else {
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
// 返回所有匹配当前method的方法拦截器
return interceptorList;
}
DefaultAdvisorAdapterRegistry#getInterceptors
@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);
}
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]);
}
public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {
private final List<AdvisorAdapter> adapters = new ArrayList<>(3);
/**
* Create a new DefaultAdvisorAdapterRegistry, registering well-known adapters.
*/
public DefaultAdvisorAdapterRegistry() {
registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
registerAdvisorAdapter(new AfterReturningAdviceAdapter());
registerAdvisorAdapter(new ThrowsAdviceAdapter());
}
以MethodBeforeAdviceAdapter为例
class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
@Override
public boolean supportsAdvice(Advice advice) {
return (advice instanceof MethodBeforeAdvice);
}
@Override
public MethodInterceptor getInterceptor(Advisor advisor) {
MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
return new MethodBeforeAdviceInterceptor(advice);
}
}
看看 MethodBeforeAdviceInterceptor#invoke
public Object invoke(MethodInvocation mi) throws Throwable {
this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
return mi.proceed();
}
3.2 调用ReflectiveMethodInvocation#proceed
@Override
@Nullable
public Object proceed() throws Throwable {
// We start with an index of -1 and increment early.
//条件成立:说明方法拦截器 全部都已经调用过了。
// 接下来 需要执行 目标对象的目标方法。
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
// 调用连接点
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;
Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
if (dm.methodMatcher.matches(this.method, 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 。
else {
// It's an interceptor, so we just invoke it: The pointcut will have
// been evaluated statically before this object was constructed.
// 让当前方法拦截器执行,并且将 this 传递了 进去,this? MethodInvocation
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
总结
- 1)ProxyFactory是所有核心要素的汇集地,包括被代理对象、增强器Advisor
- 2)JdkDynamicAopProxy作为InvocationHandler是所有方法调用的入口
- 3)调用链路
step1.JdkDynamicAopProxy#invoke
获取匹配该方法的拦截器链;
调用ReflectiveMethodInvocation;
step2.ReflectiveMethodInvocation#proceed
根据currentInterceptorIndex逐个进行调用;
最终调用至被代理的方法;
step3.MethodInterceptor#invoke(this),这里的this就是ReflectiveMethodInvocation
MethodBeforeAdviceAdapter -> MethodBeforeAdviceInterceptor
AfterReturningAdviceAdapter -> AfterReturningAdviceInterceptor
ThrowsAdviceAdapter -> ThrowsAdviceInterceptor
step4.最后反射调用至被代理的方法