Spring读源码系列之AOP--05---aop常用工具类学习

引言
环境搭建
AopUtils---aop常用方法抽离
- AopUtils使用演示
AopConfigUtils---自动代理创建器的管理
AopNamespaceUtils---xml形式aop处理
AopProxyUtils---获取代理接口和代理类的相关操作
AopContext---aop上下文
AutoProxyUtils---是否应该被代理，获得目标对象类型和是否暴露目标对象
AspectJAopUtils---前置和后置增强判断
AspectJProxyUtils----将ExposeInvocationInterceptor放入增强链头部
ExposeInvocationInterceptor---将当前MethodInvocation放入ThreadLocal中

引言

Spring AOP框架的代码结构组织得不可为不好，良好的面向对象的编程思想，其中很有一部分得益于它对代码的结构的把控。良好的封装、分层、隔离。而在其中起到重要作用的，便是本文要盘点的一些工具类。

Spring框架的工具类，其实它是分为内部工具类和外部工具类的。如果是外部工具类，那是可以给调用者使用的，如果是内部工具类，那它一般都是在Spring的流程内部使用。

环境搭建

public interface HelloService {
    Object hello();
}

public class HelloServiceImpl implements HelloService{
    @Override
    public Object hello() {
        System.out.println("HelloServiceImpl is invoked");
        return "hello world";
    }
}

public class AopUtilMain {
    public static void main(String[] args) {
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(new HelloServiceImpl());
        proxyFactory.addAdvice((MethodBeforeAdvice)(method, args1, target)->{
            System.out.println("前置通知~~~");
        });

        HelloService helloService = (HelloService) proxyFactory.getProxy();
        helloService.hello();
        System.out.println(helloService.getClass().getName());
    }
}

测试:

AopUtils—aop常用方法抽离

该工具类是Spring非常重要的一个工具类。显然它是一个外部工具类，我们平时若想要对AOP做一些判断、处理，也是可议使用此工具类的。

public abstract class AopUtils {

	
	public static boolean isAopProxy(@Nullable Object object) {
		return (object instanceof SpringProxy && (Proxy.isProxyClass(object.getClass()) ||
				object.getClass().getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)));
	}

	
	public static boolean isJdkDynamicProxy(@Nullable Object object) {
		return (object instanceof SpringProxy && Proxy.isProxyClass(object.getClass()));
	}

	
	public static boolean isCglibProxy(@Nullable Object object) {
		return (object instanceof SpringProxy &&
				object.getClass().getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR));
	}

	
	public static Class getTargetClass(Object candidate) {
		Assert.notNull(candidate, "Candidate object must not be null");
		Class result = null;
		//TargetClassAware提供了暴露目标对象类型的api
		if (candidate instanceof TargetClassAware) {
			result = ((TargetClassAware) candidate).getTargetClass();
		}
		if (result == null) {
            //是否是被cglib代理的对象,如果是返回代理对象的父类类型即目标对象的class类型
            //否在返回当前对象本身的类型			
			result = (isCglibProxy(candidate) ? candidate.getClass().getSuperclass() : candidate.getClass());
		}
		return result;
	}

	
	public static Method selectInvocableMethod(Method method, @Nullable Class targetType) {
		if (targetType == null) {
			return method;
		}
		//MethodIntrospector.selectInvocableMethod是去寻找targetType类中是否存在method方法，如果不存在在去targetType
		//的父接口中寻找是否存在，存在即返回，否在抛出异常
		Method methodToUse = MethodIntrospector.selectInvocableMethod(method, targetType);
		//当前方法如果是私有的并且是非静态的并且是targetType是代理类
		if (Modifier.isPrivate(methodToUse.getModifiers()) && !Modifier.isStatic(methodToUse.getModifiers()) &&
				SpringProxy.class.isAssignableFrom(targetType)) {
			throw new IllegalStateException(String.format(
					"Need to invoke method '%s' found on proxy for target class '%s' but cannot " +
					"be delegated to target bean. Switch its visibility to package or protected.",
					method.getName(), method.getDeclaringClass().getSimpleName()));
		}
		//返回找到的这个方法
		return methodToUse;
	}
    
    //四个特殊方法的判断
	public static boolean isEqualsMethod(@Nullable Method method) {
		return ReflectionUtils.isEqualsMethod(method);
	}

	public static boolean isHashCodeMethod(@Nullable Method method) {
		return ReflectionUtils.isHashCodeMethod(method);
	}

	public static boolean isToStringMethod(@Nullable Method method) {
		return ReflectionUtils.isToStringMethod(method);
	}

	public static boolean isFinalizeMethod(@Nullable Method method) {
		return (method != null && method.getName().equals("finalize") &&
				method.getParameterCount() == 0);
	}

	
	public static Method getMostSpecificMethod(Method method, @Nullable Class targetClass) {
		Class specificTargetClass = (targetClass != null ? ClassUtils.getUserClass(targetClass) : null);
		Method resolvedMethod = ClassUtils.getMostSpecificMethod(method, specificTargetClass);
		// If we are dealing with method with generic parameters, find the original method.
		return BridgeMethodResolver.findBridgedMethod(resolvedMethod);
	}

	public static boolean canApply(Pointcut pc, Class targetClass) {
		return canApply(pc, targetClass, false);
	}

	
	public static boolean canApply(Pointcut pc, Class targetClass, boolean hasIntroductions) {
		Assert.notNull(pc, "Pointcut must not be null");
		//先从类级别进行过滤
		if (!pc.getClassFilter().matches(targetClass)) {
			return false;
		}
       //再从方法级别进行过滤
		MethodMatcher methodMatcher = pc.getMethodMatcher();
		if (methodMatcher == MethodMatcher.TRUE) {
			// No need to iterate the methods if we're matching any method anyway...
			return true;
		}

		IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
		if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
			introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
		}

		Set> classes = new LinkedHashSet<>();
		//目标对象如果不是jdk代理类
		if (!Proxy.isProxyClass(targetClass)) {
		//getUserClass会尝试去处理cglib代理的情况，返回代理类的父类类型即目标对象类型---cglib
			classes.add(ClassUtils.getUserClass(targetClass));
		}
		//加入当前类实现的所有接口---jdk
		classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
        
        //遍历 
		for (Class clazz : classes) {
		//拿到当前类型的所有方法
			Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
			//对每个方法挨个进行匹配
			for (Method method : methods) {
				if (introductionAwareMethodMatcher != null ?
						introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
						methodMatcher.matches(method, targetClass)) {
					return true;
				}
			}
		}

		return false;
	}

	public static boolean canApply(Advisor advisor, Class targetClass, boolean hasIntroductions) {
	//IntroductionAdvisor只需要进行类级别过滤即可
		if (advisor instanceof IntroductionAdvisor) {
			return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
		}
		else if (advisor instanceof PointcutAdvisor) {
			PointcutAdvisor pca = (PointcutAdvisor) advisor;
			//调用上面分析的重载canApply方法
			return canApply(pca.getPointcut(), targetClass, hasIntroductions);
		}
		else {
			// It doesn't have a pointcut so we assume it applies.
			//其他类型的advisor没有ponitcut,默认都可以应用
			return true;
		}
	}

	public static boolean canApply(Pointcut pc, Class targetClass) {
		return canApply(pc, targetClass, false);
	}
	
	public static boolean canApply(Advisor advisor, Class targetClass) {
		return canApply(advisor, targetClass, false);
	}
	
	
	public static List findAdvisorsThatCanApply(List candidateAdvisors, Class clazz) {
		if (candidateAdvisors.isEmpty()) {
			return candidateAdvisors;
		}
		List eligibleAdvisors = new ArrayList<>();
		for (Advisor candidate : candidateAdvisors) {
		//如果是IntroductionAdvisor ，那么直接进行类级别过滤级别，调用canApply其中一个重载方法完成类级别的过滤
			if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
			//如果发现满足类匹配的条件，加入候选增强器集合
				eligibleAdvisors.add(candidate);
			}
		}
		boolean hasIntroductions = !eligibleAdvisors.isEmpty();
		for (Advisor candidate : candidateAdvisors) {
		//IntroductionAdvisor上面已经处理过了
			if (candidate instanceof IntroductionAdvisor) {
				// already processed
				continue;
			}
			//判断ponitcutAdvisor和其他类型的Advisor能否应用
			if (canApply(candidate, clazz, hasIntroductions)) {
				eligibleAdvisors.add(candidate);
			}
		}
		return eligibleAdvisors;
	}

	
	@Nullable
	public static Object invokeJoinpointUsingReflection(@Nullable 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);
		}
	}

}

AopUtils使用演示

    public static void main(String[] args) {
        HelloService helloService = getProxy(new HelloServiceImpl());
        //===============演示AopUtils==================

        // AopUtils.isAopProxy:是否是代理对象
        System.out.println(AopUtils.isAopProxy(helloService)); // true
        System.out.println(AopUtils.isJdkDynamicProxy(helloService)); // false
        System.out.println(AopUtils.isCglibProxy(helloService)); // true

        // 拿到目标对象
        System.out.println(AopUtils.getTargetClass(helloService)); //class com.fsx.service.HelloServiceImpl

        // selectInvocableMethod:方法@since 4.3  底层依赖于方法MethodIntrospector.selectInvocableMethod
        // 只是在他技术上做了一个判断： 必须是被代理的方法才行（targetType是SpringProxy的子类,且是private这种方法，且不是static的就不行）
        // Spring MVC的detectHandlerMethods对此方法有大量调用~~~~~
        Method method = ClassUtils.getMethod(HelloServiceImpl.class, "hello");
        System.out.println(AopUtils.selectInvocableMethod(method, HelloServiceImpl.class)); //public java.lang.Object com.fsx.service.HelloServiceImpl.hello()

        // 是否是equals方法
        // isToStringMethod、isHashCodeMethod、isFinalizeMethod  都是类似的
        System.out.println(AopUtils.isEqualsMethod(method)); //false

        // 它是对ClassUtils.getMostSpecificMethod,增加了对代理对象的特殊处理。。。
        System.out.println(AopUtils.getMostSpecificMethod(method,HelloService.class));
	｝

AopConfigUtils—自动代理创建器的管理

从名字可以看出，这个是关于AOP配置的工具类。因为配置AOP的方式有多种（比如xml、注解等），此工具类就是针对不同配置，提供不同的工具方法的。

它的好处是不管什么配置，最终走底层逻辑都让归一了~~~~

类注释翻译:

该类是来管理自动代理创建器的注册

应该只注册一个自动代理创建者，但可以使用多个具体实现。

此类提供了一个简单的升级协议，允许调用者请求特定的自动代理创建者，并知道该创建者或其更强大的变体将被注册为后处理器。

public abstract class AopConfigUtils {

	
	public static final String AUTO_PROXY_CREATOR_BEAN_NAME =
			"org.springframework.aop.config.internalAutoProxyCreator";

	
	private static final List> APC_PRIORITY_LIST = new ArrayList<>(3);

	static {
		// Set up the escalation list...
		//这里每个自动代理创建器都对应一个优先级，优先级就是该自动代理创建器再集合中的下标，下标越大，优先级越高
		APC_PRIORITY_LIST.add(InfrastructureAdvisorAutoProxyCreator.class);
		APC_PRIORITY_LIST.add(AspectJAwareAdvisorAutoProxyCreator.class);
		APC_PRIORITY_LIST.add(AnnotationAwareAspectJAutoProxyCreator.class);
	}

    // 这两个：注册的是`InfrastructureAdvisorAutoProxyCreator`  
	// 调用处为：AutoProxyRegistrar#registerBeanDefinitions（它是一个ImportBeanDefinitionRegistrar实现类） 
	// 而AutoProxyRegistrar使用处为CachingConfigurationSelector，和`@EnableCaching`注解有关
	// 其次就是AopNamespaceUtils有点用，这个下面再分析
	@Nullable
	public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
		return registerAutoProxyCreatorIfNecessary(registry, null);
	}
	
	@Nullable
	public static BeanDefinition registerAutoProxyCreatorIfNecessary(
			BeanDefinitionRegistry registry, @Nullable Object source) {
       
		return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);
	}

	// 下面这两个是注入：AspectJAwareAdvisorAutoProxyCreator
	// 目前没有地方默认调用~~~~和Aop的xml配置方案有关的
	@Nullable
	public static BeanDefinition registerAspectJAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
		return registerAspectJAutoProxyCreatorIfNecessary(registry, null);
	}

	@Nullable
	public static BeanDefinition registerAspectJAutoProxyCreatorIfNecessary(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		return registerOrEscalateApcAsRequired(AspectJAwareAdvisorAutoProxyCreator.class, registry, source);
	}



	// 这个就是最常用的，注入的是：AnnotationAwareAspectJAutoProxyCreator  注解驱动的自动代理创建器
	// `@EnableAspectJAutoProxy`注入进来的就是它了
	@Nullable
	public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
		return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
	}
	@Nullable
	public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
	}

	// 这两个方法，很显然，就是处理注解的两个属性值
	// proxyTargetClass：true表示强制使用CGLIB的动态代理
	// exposeProxy：true暴露当前代理对象到线程上绑定
	// 最终都会放到自动代理创建器得BeanDefinition 里面去~~~创建代理的时候会用到此属性值
	public static void forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry registry) {
		if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
			BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
			definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
		}
	}

	public static void forceAutoProxyCreatorToExposeProxy(BeanDefinitionRegistry registry) {
		if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
			BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
			definition.getPropertyValues().add("exposeProxy", Boolean.TRUE);
		}
	}


	//========上面的注册自动代理创建器IfNecessary之类的方法，最终都是调用了这里========
	@Nullable
	private static BeanDefinition registerOrEscalateApcAsRequired(
			Class cls, BeanDefinitionRegistry registry, @Nullable Object source) {

		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
       //如果容器中包含了AUTO_PROXY_CREATOR_BEAN_NAME对应的beanName,那么此时再进行注册操作就需要根据优先级来判断是否需要进行覆盖
		if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
			//拿到容器中现存的自动代理创建器
			BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
			//当然要注册进容器的bean和容器中现存的bean的类型不能一样，否则不进行操作
			if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
			//获取容器中已有的自动代理创建器的优先级
				int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
			//获取要注册进容器的自动代理创建器的优先级
				int requiredPriority = findPriorityForClass(cls);
				//只有在优先级更大的情况下，才会覆盖成功
				if (currentPriority < requiredPriority) {
					apcDefinition.setBeanClassName(cls.getName());
				}
			}
			return null;
		}
        //容器中还没有自动代理创建器，那么就直接把当前要注册进容器的自动代理创建器注册到容器中
        	// 绝大部分情况下都会走这里，new一个Bean定义信息出来，然后order属性值为HIGHEST_PRECEDENCE
		// role是：ROLE_INFRASTRUCTURE属于Spring框架自己使用的Bean
		// BeanName为：AUTO_PROXY_CREATOR_BEAN_NAME
		RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
		beanDefinition.setSource(source);
		beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
		beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
		//注册beanDefinition
		registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
		return beanDefinition;
	}
   
    //优先级就是根据当前自动代理创建器在集合中的序号决定的
	private static int findPriorityForClass(Class clazz) {
		return APC_PRIORITY_LIST.indexOf(clazz);
	}

	private static int findPriorityForClass(@Nullable String className) {
		for (int i = 0; i < APC_PRIORITY_LIST.size(); i++) {
			Class clazz = APC_PRIORITY_LIST.get(i);
			if (clazz.getName().equals(className)) {
				return i;
			}
		}
		throw new IllegalArgumentException(
				"Class name [" + className + "] is not a known auto-proxy creator class");
	}

}

由于AopConfigUtils 并没有公开可以向APC_PRIORITY_LIST 中添加元素的方法，因此我们只能注册他规定的三种自动代理创建器

备注：请尽量不要自定义自动代理创建器，也不要轻易使用低级别的创建器，若你对原理不是非常懂的话，慎重

AopNamespaceUtils—xml形式aop处理

这个从名字可以看出，是处理Spring AOP命名空间的工具类。比如

xmlns:aop="http://www.springframework.org/schema/aop

处理这种xml里面的

等这种。当然还有对proxy-target-class和expose-proxy的处理。因为接下来的重点都不在xml里，因此此处略过（最终它调用都是AopConfigUtils#XXXIfNecessary的方法，去注册不同的自动代理创建器的）

AopProxyUtils—获取代理接口和代理类的相关操作

我理解成它是对org.springframework.aop.support.AopUtils的一个补充。

public abstract class AopProxyUtils {

	// JDK 17 Class.isSealed() method available?
	@Nullable
	private static final Method isSealedMethod = ClassUtils.getMethodIfAvailable(Class.class, "isSealed");


	
	@Nullable
	public static Object getSingletonTarget(Object candidate) {
	//如果传入的代理对象实现了Advised接口
		if (candidate instanceof Advised) {
		//拿到TargetSource
			TargetSource targetSource = ((Advised) candidate).getTargetSource();
			if (targetSource instanceof SingletonTargetSource) {
				//拿到目标对象
				return ((SingletonTargetSource) targetSource).getTarget();
			}
		}
		return null;
	}

	
	public static Class ultimateTargetClass(Object candidate) {
		Assert.notNull(candidate, "Candidate object must not be null");
		Object current = candidate;
		Class result = null;
		//如果代理对象实现了TargetClassAware接口，可以通过该接口直接获取到目标对象的类型
		while (current instanceof TargetClassAware) {
			result = ((TargetClassAware) current).getTargetClass();
			//拿到目标对象
			current = getSingletonTarget(current);
		}
		if (result == null) {
			//如果上面没能获取到结果
			//代理类是否是被cglib代理，如果是的话，返回代理类的父类类型,否则返回代理类自身类型
			result = (AopUtils.isCglibProxy(candidate) ? candidate.getClass().getSuperclass() : candidate.getClass());
		}
		return result;
	}

	
	public static Class[] completeProxiedInterfaces(AdvisedSupport advised) {
		return completeProxiedInterfaces(advised, false);
	}

//decoratingProxy：代理对象是否要实现 DecoratingProxy接口
	static Class[] completeProxiedInterfaces(AdvisedSupport advised, boolean decoratingProxy) {
	//从代理配置中拿到当前代理对象设置的需要代理的接口
		Class[] specifiedInterfaces = advised.getProxiedInterfaces();
	//如果没有需要代理的接口
		if (specifiedInterfaces.length == 0) {
			// No user-specified interfaces: check whether target class is an interface.
			//拿到目标对象的类型
			Class targetClass = advised.getTargetClass();
			if (targetClass != null) {
				//判断是否是接口,如果是,那么设置代理对象需要实现目标对象的接口
				if (targetClass.isInterface()) {
					advised.setInterfaces(targetClass);
				}
				//当前目标对象是否是jdk动态代理类型
				else if (Proxy.isProxyClass(targetClass)) {
					//如果是的话，拿到jdk动态代理类实现的接口，设置为需要实现的代理接口
					advised.setInterfaces(targetClass.getInterfaces());
				}
				specifiedInterfaces = advised.getProxiedInterfaces();
			}
		}
		//这边的+3，意味着下面可能需要实现额外的三个接口
		List> proxiedInterfaces = new ArrayList<>(specifiedInterfaces.length + 3);
		//jdk17的适配处理，这里先跳过
		for (Class ifc : specifiedInterfaces) {
			// Only non-sealed interfaces are actually eligible for JDK proxying (on JDK 17)
			if (isSealedMethod == null || Boolean.FALSE.equals(ReflectionUtils.invokeMethod(isSealedMethod, ifc))) {
				proxiedInterfaces.add(ifc);
			}
		}
		//判断SpringProxy接口是否已经加入了代理类需要实现的接口，没加入则加入
		//即所有代理对象都会实现SpringProxy接口
		if (!advised.isInterfaceProxied(SpringProxy.class)) {
			proxiedInterfaces.add(SpringProxy.class);
		}
		//proxyConfig的opaque属性是否为true,该属性为true,则表示代理类不能强制转换为advised接口，默认为false,即代理类需要继承advised接口
		//还有一点需要保证，就是Advised未被加入需要代理的接口数组中
		if (!advised.isOpaque() && !advised.isInterfaceProxied(Advised.class)) {
			proxiedInterfaces.add(Advised.class);
		}
		//decoratingProxy属性来确保代理类是否需要实现DecoratingProxy接口，该接口会暴露api来获取到代理对象代理的目标对象的类型
		if (decoratingProxy && !advised.isInterfaceProxied(DecoratingProxy.class)) {
			proxiedInterfaces.add(DecoratingProxy.class);
		}
		//返回最终需要实现的代理接口集合
		return ClassUtils.toClassArray(proxiedInterfaces);
	}

	
	public static Class[] proxiedUserInterfaces(Object proxy) {
	//拿到代理类已经实现的所有接口
		Class[] proxyInterfaces = proxy.getClass().getInterfaces();
		int nonUserIfcCount = 0;
		//判断下面三个接口实现了几个
		if (proxy instanceof SpringProxy) {
			nonUserIfcCount++;
		}
		if (proxy instanceof Advised) {
			nonUserIfcCount++;
		}
		if (proxy instanceof DecoratingProxy) {
			nonUserIfcCount++;
		}
		//行为额外新增加的三个接口，会放在数组尾部，因此从尾部嘎掉他们即可
		Class[] userInterfaces = Arrays.copyOf(proxyInterfaces, proxyInterfaces.length - nonUserIfcCount);
		Assert.notEmpty(userInterfaces, "JDK proxy must implement one or more interfaces");
		return userInterfaces;
	}

	
	public static boolean equalsInProxy(AdvisedSupport a, AdvisedSupport b) {
		return (a == b ||
				(equalsProxiedInterfaces(a, b) && equalsAdvisors(a, b) && a.getTargetSource().equals(b.getTargetSource())));
	}

	
	public static boolean equalsProxiedInterfaces(AdvisedSupport a, AdvisedSupport b) {
		return Arrays.equals(a.getProxiedInterfaces(), b.getProxiedInterfaces());
	}

	
	public static boolean equalsAdvisors(AdvisedSupport a, AdvisedSupport b) {
		return a.getAdvisorCount() == b.getAdvisorCount() && Arrays.equals(a.getAdvisors(), b.getAdvisors());
	}


	
	static Object[] adaptArgumentsIfNecessary(Method method, @Nullable Object[] arguments) {
		if (ObjectUtils.isEmpty(arguments)) {
			return new Object[0];
		}
		if (method.isVarArgs()) {
			if (method.getParameterCount() == arguments.length) {
				Class[] paramTypes = method.getParameterTypes();
				int varargIndex = paramTypes.length - 1;
				Class varargType = paramTypes[varargIndex];
				if (varargType.isArray()) {
					Object varargArray = arguments[varargIndex];
					if (varargArray instanceof Object[] && !varargType.isInstance(varargArray)) {
						Object[] newArguments = new Object[arguments.length];
						System.arraycopy(arguments, 0, newArguments, 0, varargIndex);
						Class targetElementType = varargType.getComponentType();
						int varargLength = Array.getLength(varargArray);
						Object newVarargArray = Array.newInstance(targetElementType, varargLength);
						System.arraycopy(varargArray, 0, newVarargArray, 0, varargLength);
						newArguments[varargIndex] = newVarargArray;
						return newArguments;
					}
				}
			}
		}
		return arguments;
	}

}

JDK代理和CGLIB代理的获取代理对象方法都用使用到了该类中的方法：

	// JDK代理的获取代理对象~~~
	@Override
	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);
	}

AopProxyUtils中的方法不多，但是其中的ultimateTargetClass和completeProxiedInterfaces方法确是Spring AOP中比较重要的方法，也给

AopContext—aop上下文

包含用于获取有关当前 AOP 调用信息的静态方法的类。

如果 AOP 框架配置为公开当前代理（不是默认代理），则 currentProxy() 方法可用。它返回正在使用的 AOP 代理。目标对象或advice 可以使用它来进行advice 调用，就像在 EJB 中使用 getEJBObject() 一样。他们还可以使用它来查找advice configuration.。

Spring 的 AOP 框架默认不公开代理，因为这样做会降低性能。

此类中的功能可能由需要在调用时访问资源的目标对象使用。但是，如果有合理的替代方案，则不应使用此方法，因为它使应用程序代码依赖于 AOP 下的使用，尤其是 Spring AOP 框架。

public final class AopContext {

	
	private static final ThreadLocal

Spring读源码系列之AOP--05---aop常用工具类学习

Java相关栏目本月热门文章