Spring-AOP源码探讨-创建bean代理对象&代理方法执行流程

曾经终败给现在 2022-02-26 13:40 209阅读 0赞

在[上一篇][Link 1]中梳理了匹配bean通知(Advisor)的流程。  
这篇延续上篇，梳理创建bean代理对象源码。

先回顾下AbstractAutoProxyCreator类的wrapIfNecessary方法：

/**
     * Wrap the given bean if necessary, i.e. if it is eligible for being proxied.
     * @param bean the raw bean instance
     * @param beanName the name of the bean
     * @param cacheKey the cache key for metadata access
     * @return a proxy wrapping the bean, or the raw bean instance as-is
     */
    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    	...
    	// Create proxy if we have advice.
    	//获取目标bean的各种增强
    	Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    	if (specificInterceptors != DO_NOT_PROXY) {
    		this.advisedBeans.put(cacheKey, Boolean.TRUE);
    		//创建代理对象
    		Object proxy = createProxy(
    				bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
    		this.proxyTypes.put(cacheKey, proxy.getClass());
    		return proxy;
    	}
    
    	this.advisedBeans.put(cacheKey, Boolean.FALSE);
    	return bean;
    }

跟着createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean))方法：

protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
    			@Nullable Object[] specificInterceptors, TargetSource targetSource) {
    
    		if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
    			AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
    		}
    
    		ProxyFactory proxyFactory = new ProxyFactory();
    		proxyFactory.copyFrom(this);
    
    		if (!proxyFactory.isProxyTargetClass()) {
    			if (shouldProxyTargetClass(beanClass, beanName)) {
    				proxyFactory.setProxyTargetClass(true);
    			}
    			else {
    				evaluateProxyInterfaces(beanClass, proxyFactory);
    			}
    		}
    
    		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    		proxyFactory.addAdvisors(advisors);
    		proxyFactory.setTargetSource(targetSource);
    		customizeProxyFactory(proxyFactory);
    
    		proxyFactory.setFrozen(this.freezeProxy);
    		if (advisorsPreFiltered()) {
    			proxyFactory.setPreFiltered(true);
    		}
    
    		return proxyFactory.getProxy(getProxyClassLoader());
    	}

代理对象的创建通过ProxyFactory工厂类的getProxy方法创建：

public Object getProxy(@Nullable ClassLoader classLoader) {
    		return createAopProxy().getProxy(classLoader);
    	}

这里需要根据配置使用不同的AopProxy代理方式创建代理对象，分别是JDK动态代理或CGlib代理。  
ProxyCreatorSupport\#createAopProxy：

protected final synchronized AopProxy createAopProxy() {
    	if (!this.active) {
    		activate();
    	}
    	return getAopProxyFactory().createAopProxy(this);
    }

AopProxyFactory默认实现类是DefaultAopProxyFactory：

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() || Proxy.isProxyClass(targetClass)) {
    			//JDK动态代理
    			return new JdkDynamicAopProxy(config);
    		}
    		//Cglib代理
    		return new ObjenesisCglibAopProxy(config);
    	}
    	else {
    		return new JdkDynamicAopProxy(config);
    	}
    }

这里以JdkDynamicAopProxy类为例，看看其getProxy方法：

public Object getProxy() {
    	return getProxy(ClassUtils.getDefaultClassLoader());
    }
    public Object getProxy(@Nullable ClassLoader classLoader) {
    	if (logger.isDebugEnabled()) {
    		logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
    	}
    	Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
    	findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    	return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }

最终是调用Proxy类的newProxyInstance方法创建代理对象。

JdkDynamicAopProxy类本身实现了InvocationHandler接口，其invoke方法：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    	MethodInvocation invocation;
    	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.
    		//获取拦截器链，也就是MethodInterceptor，前面的PointcutAdvisor封装的实例
    		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);
    		}
    		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();
    		}
    
    		// 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);
    		}
    	}
    }

这里主要是获取目标方法是否有拦截器链，有则执行，没有则通过反射执行目标方法。

再看看如何获取拦截器链。

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：

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.
    	List<Object> interceptorList = new ArrayList<>(config.getAdvisors().length);
    	Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
    	boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
    	AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
    
    	for (Advisor advisor : config.getAdvisors()) {
    		if (advisor instanceof PointcutAdvisor) {
    			// Add it conditionally.
    			PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
    			if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
    				//将通知的增强代码包装成MethodInterceptor类实例
    				MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
    				MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
    				if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
    					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 {
    						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));
    			}
    		}
    		else {
    			Interceptor[] interceptors = registry.getInterceptors(advisor);
    			interceptorList.addAll(Arrays.asList(interceptors));
    		}
    	}
    
    	return interceptorList;
    }

看看DefaultAdvisorAdapterRegistry\#getInterceptors：

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);
    	}
    	//有3个类，分别是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]);
    }

这里补充下，此时在容器中的Advisor的实现类是InstantiationModelAwarePointcutAdvisorImpl，其getAdvice方法：

/**
     * Lazily instantiate advice if necessary.
     */
    @Override
    public synchronized Advice getAdvice() {
    	if (this.instantiatedAdvice == null) {
    		//懒加载，实例化Advice
    		this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
    	}
    	return this.instantiatedAdvice;
    }

instantiateAdvice：

private Advice instantiateAdvice(AspectJExpressionPointcut pointcut) {
    	Advice advice = this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pointcut,
    			this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
    	return (advice != null ? advice : EMPTY_ADVICE);
    }

ReflectiveAspectJAdvisorFactory\#getAdvisor方法：

public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
    			MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
    
    		Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
    		validate(candidateAspectClass);
    
    		AspectJAnnotation<?> aspectJAnnotation =
    				AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
    		if (aspectJAnnotation == null) {
    			return null;
    		}
    
    		// If we get here, we know we have an AspectJ method.
    		// Check that it's an AspectJ-annotated class
    		if (!isAspect(candidateAspectClass)) {
    			throw new AopConfigException("Advice must be declared inside an aspect type: " +
    					"Offending method '" + candidateAdviceMethod + "' in class [" +
    					candidateAspectClass.getName() + "]");
    		}
    
    		if (logger.isDebugEnabled()) {
    			logger.debug("Found AspectJ method: " + candidateAdviceMethod);
    		}
    
    		AbstractAspectJAdvice springAdvice;
    
    		switch (aspectJAnnotation.getAnnotationType()) {
    			case AtBefore:
    				springAdvice = new AspectJMethodBeforeAdvice(
    						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
    				break;
    			case AtAfter:
    				springAdvice = new AspectJAfterAdvice(
    						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
    				break;
    			case AtAfterReturning:
    				springAdvice = new AspectJAfterReturningAdvice(
    						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
    				AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
    				if (StringUtils.hasText(afterReturningAnnotation.returning())) {
    					springAdvice.setReturningName(afterReturningAnnotation.returning());
    				}
    				break;
    			case AtAfterThrowing:
    				springAdvice = new AspectJAfterThrowingAdvice(
    						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
    				AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
    				if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
    					springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
    				}
    				break;
    			case AtAround:
    				springAdvice = new AspectJAroundAdvice(
    						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
    				break;
    			case AtPointcut:
    				if (logger.isDebugEnabled()) {
    					logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
    				}
    				return null;
    			default:
    				throw new UnsupportedOperationException(
    						"Unsupported advice type on method: " + candidateAdviceMethod);
    		}
    
    		// Now to configure the advice...
    		springAdvice.setAspectName(aspectName);
    		springAdvice.setDeclarationOrder(declarationOrder);
    		String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
    		if (argNames != null) {
    			springAdvice.setArgumentNamesFromStringArray(argNames);
    		}
    		springAdvice.calculateArgumentBindings();
    
    		return springAdvice;
    	}

假设是AspectJMethodBeforeAdvice类型，其实现了MethodBeforeAdvice接口，MethodBeforeAdviceAdapter的supportsAdvice方法返回true：

public boolean supportsAdvice(Advice advice) {
    	return (advice instanceof MethodBeforeAdvice);
    }

如果是AspectJAfterAdvice类型，因为其实现了MethodInterceptor接口，所以可以直接加入到interceptors。

获取到拦截器链后，创建ReflectiveMethodInvocation类，然后调用其proceed方法：

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;
    		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.
    		//调用拦截器的invoke方法
    		return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    	}
    }

假设拦截器链中有MethodBeforeAdviceInterceptor，其invoke方法：

public Object invoke(MethodInvocation mi) throws Throwable {
    	this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
    	return mi.proceed();
    }

AspectJAfterAdvice的invoke方法：

public Object invoke(MethodInvocation mi) throws Throwable {
    	try {
    		return mi.proceed();
    	}
    	finally {
    		invokeAdviceMethod(getJoinPointMatch(), null, null);
    	}
    }

先AspectJAfterAdvice的invoke方法，接着调用回proceed方法，因为拦截器链还没执行  
完，接着调用MethodBeforeAdviceInterceptor的invoke方法，其执行before逻辑，执行完后递归调用proceed方法，此时拦截器链执行完成，再调用目标类方法，再返回调用后置逻辑，至此，调用结束。

参考

> [https://www.imooc.com/article/43379][https_www.imooc.com_article_43379]

[Link 1]: https://blog.csdn.net/wang704987562/article/details/88902773
[https_www.imooc.com_article_43379]: https://www.imooc.com/article/43379