sping aop 源码分析（-）-- 代理对象的创建过程分析
测试项目已上传到码云，可以下载：https://gitee.com/yangxioahui/aopdemo.git
具体如下：
public interface Calc { Integer add(int num1,int num2); }
//目标是对add 方法进行切入 @Component public class MyMath implements Calc { public Integer add(int num1,int num2){ return num1+num2; } } @Aspect @Component public class MyAspectJ { @Pointcut(" execution(* com.yang.xiao.hui.aop.MyMath.*(..))") private void pointcut(){} @Before(value = "pointcut()") public void before(JoinPoint joinPoint){ System.out.println("before。。。。。"); } @After(value = "pointcut()") public void after(JoinPoint joinPoint){ System.out.println("after。。。。"); } @AfterReturning(value = "pointcut()") public void afterReturning(){ System.out.println("afterReturning。。。"); } @AfterThrowing(value = "pointcut()") public void afterThrowing(JoinPoint joinPoint){ System.out.println("afterThrowing。。。。"); } @Around(value ="pointcut()") public void around(ProceedingJoinPoint joinPoint){ System.out.println("around-before。。。。"); try { Object proceed = joinPoint.proceed(); System.out.println("around-after_return。。。"); } catch (Throwable throwable) { System.out.println("around-throw。。。"+throwable.getMessage()); } System.out.println("around-after。。。"); } } //测试类 @Configuration @ComponentScan("com.yang.xiao.hui.aop") @EnableAspectJAutoProxy(exposeProxy = true) public class App { public static void main( String[] args ) { ApplicationContext ctx = new AnnotationConfigApplicationContext(App.class); Calc myMath = (Calc)ctx.getBean("myMath"); myMath.add(3,5); System.out.println(ctx.getBean("myMath").getClass()); } }
启动项目结果：
至此，测试环境搭建完毕
原理分析：
我们要对MyMath 类的add 方法进行前后代理，我们也可以自己实现：
我们实现的叫静态代理，如果是程序实现的叫动态代理；切入的方式有前置切入，后置切入等，切入点有切入表达式（Pointcut），在java中，一切皆对象，spring将各种切入方式叫做Advice（增强器），如BeforeAdvice，而我们是通过方法切入
所以又叫MethodBeforeAdvice：
单有一个Advice 我们并不知道要给哪个类进行切入，因此还需要切入点，于是我们将Advice和切入点Pointcut 结合一起组成一个Advisor:
例如：DefaultPointcutAdvisor它的构造器:
一个被切入的类，它的代理类，会有很多个Advisor,那么我们称这个代理类叫做Advised：
至此，我们知道了advice ，advisor 和advised的三者之间的关系了：
下面的我们要解决的问题是：1.各种切入方式是如何被封装成advisor的 2 如何知道某个类是否需要被代理 3. 如何创建代理类 4 类被代理后，目标方法是如何执行的：
先来看一个注解：@EnableAspectJAutoProxy()
点击进入该注解：
我们继续跟进，看看到底向容器注册的是哪个bean;
我们再看看注解信息是怎么保存到注册器中的；
小结：@EnableAspectJAutoProxy 注解最终向容器中注入了一个 bean---- AnnotationAwareAspectJAutoProxyCreator,因此我们问题的答案都可以在这个bean找到，那么我们看看其继承体系：
可见，AnnotationAwareAspectJAutoProxyCreator是一个beanPostProcessor,也就是后置处理器，会在bean的不同生命周期里其作用：
因此，这些生命周期里，会进行代理对象的创建：
我们debug 调试容器创建过程：
省略n步骤：
public List<Advisor> buildAspectJAdvisors() { List<String> aspectNames = this.aspectBeanNames; //首次进来，这个为null if (aspectNames == null) { synchronized (this) { aspectNames = this.aspectBeanNames; if (aspectNames == null) { List<Advisor> advisors = new ArrayList<>(); aspectNames = new ArrayList<>(); String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors( this.beanFactory, Object.class, true, false); //容器中获取所有的beanName，因为Object可以代表所有的类型 for (String beanName : beanNames) { if (!isEligibleBean(beanName)) { //isEligibleBean(beanName)这个基本返回true continue; } // We must be careful not to instantiate beans eagerly as in this case they // would be cached by the Spring container but would not have been weaved. Class<?> beanType = this.beanFactory.getType(beanName); //获取对应的类型 if (beanType == null) { continue; } if (this.advisorFactory.isAspect(beanType)) { //判断类有没@Aspect注解，而我们定义的MyAspectJ是有该注解的 aspectNames.add(beanName);//切面类可能有多个，我本次测试写了一个MyAspectJ AspectMetadata amd = new AspectMetadata(beanType, beanName); if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) { //如果我们的MyMyAspectJ是单例的话，条件成立，显然，我们的就是单例 MetadataAwareAspectInstanceFactory factory = new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName); //获取一个切面工厂 List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);//这里获取了我们要的advisor，所以稍后要分析 if (this.beanFactory.isSingleton(beanName)) { this.advisorsCache.put(beanName, classAdvisors); //如果是单例就缓存起来，下次就不用再次获取了 } else { this.aspectFactoryCache.put(beanName, factory);//非单例就缓存工厂 } advisors.addAll(classAdvisors);//收集所有的advisor } else { // Per target or per this. if (this.beanFactory.isSingleton(beanName)) { throw new IllegalArgumentException("Bean with name '" + beanName + "' is a singleton, but aspect instantiation model is not singleton"); } MetadataAwareAspectInstanceFactory factory = new PrototypeAspectInstanceFactory(this.beanFactory, beanName); this.aspectFactoryCache.put(beanName, factory); advisors.addAll(this.advisorFactory.getAdvisors(factory)); } } } this.aspectBeanNames = aspectNames; return advisors; //第一次进来在这里就返回去了，下面的不会执行 } } } 第二次进来，从缓存中取 if (aspectNames.isEmpty()) { return Collections.emptyList(); } List<Advisor> advisors = new ArrayList<>(); for (String aspectName : aspectNames) { List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName); if (cachedAdvisors != null) { advisors.addAll(cachedAdvisors); //单例的切面类，从缓存中就可以取到他们所有的advisor } else { MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName); advisors.addAll(this.advisorFactory.getAdvisors(factory)); //非单例的切面类，从工厂中去处 } } return advisors; }
//通过上面分析：最终会通过调用advisorFactory.getAdvisors(factory)获取到advisor，继续跟进：
@Override public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) { Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass(); //获取切面类，在这里就是我们的com.yang.xiao.hui.aop.MyAspectJ String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();//获取类名，这里是myAspectJ validate(aspectClass);//这里主要校验切面类的父类有没@Aspect注解，如果有，必须是抽象类，其次会校验切面类有没@Aspect注解 // We need to wrap the MetadataAwareAspectInstanceFactory with a decorator // so that it will only instantiate once. MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory = new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory); //将工厂进行包装，让其只会实例化一次 List<Advisor> advisors = new ArrayList<>(); for (Method method : getAdvisorMethods(aspectClass)) { //通过切面类，获取所有的方法，方法不包含含有@Pointcut注解的方法，因为带有该注解的方法为切入点 Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName); //这里将方法封装成了Advisor,后续会跟踪 if (advisor != null) { //并不是所有方法，都能封装成advisor的，只有含有@before，@after等注解的方法才会被封装 advisors.add(advisor); } } // If it's a per target aspect, emit the dummy instantiating aspect. if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) { //懒加载相关的，会增加一个advisor，显然我们的不是 Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory); advisors.add(0, instantiationAdvisor); } // Find introduction fields. for (Field field : aspectClass.getDeclaredFields()) { //查询有没哪个字段是有@DeclareParents注解的，我们定义的类没有字段 Advisor advisor = getDeclareParentsAdvisor(field); if (advisor != null) { advisors.add(advisor); } } return advisors; }
根据上面分析，切面类的方法最终转成advisor，是调用了 Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);我们跟进去：
@Override @Nullable public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrderInAspect, String aspectName) { validate(aspectInstanceFactory.getAspectMetadata().getAspectClass()); //校验切面类的父类有没@Aspect注解，如果有，必须是抽象类，其次会校验切面类有没@Aspect注解 AspectJExpressionPointcut expressionPointcut = getPointcut( candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass()); //里面会校验candidateAdviceMethod方法是否有@Before @After等注解 if (expressionPointcut == null) { return null; } return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod, this, aspectInstanceFactory, declarationOrderInAspect, aspectName); //这个就是我们要找的advisor，expressionPointcut含有pointcut和advice
}
我们分析下： AspectJExpressionPointcut expressionPointcut = getPointcut( candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass()); 方法：
@Nullable private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) { AspectJAnnotation<?> aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod); //这里是判断有没对应注解 if (aspectJAnnotation == null) { return null; } AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]); ajexp.setExpression(aspectJAnnotation.getPointcutExpression()); //这里将@before/@After等注解的切入点表达式存起来了 if (this.beanFactory != null) { ajexp.setBeanFactory(this.beanFactory); } return ajexp; }
@Nullable protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) { //查询某个方法是否有aspectj相关注解 for (Class<?> clazz : ASPECTJ_ANNOTATION_CLASSES) { //ASPECTJ_ANNOTATION_CLASSES //相关注解类如下图： AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) clazz); if (foundAnnotation != null) { return foundAnnotation; } } return null; }
//经过分析，所有的advisor,最终的类型是InstantiationModelAwarePointcutAdvisorImpl 看看起构造器
public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut, Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) { this.declaredPointcut = declaredPointcut; //切入点表达式 this.declaringClass = aspectJAdviceMethod.getDeclaringClass(); //增强方法所在的类，也就是切入类 this.methodName = aspectJAdviceMethod.getName(); //增强的方法名@before等注解标注的类 this.parameterTypes = aspectJAdviceMethod.getParameterTypes();//advice方法的参数类型 this.aspectJAdviceMethod = aspectJAdviceMethod;//advice方法，@before等注解标注的方法 this.aspectJAdvisorFactory = aspectJAdvisorFactory; //工厂类 this.aspectInstanceFactory = aspectInstanceFactory;//工厂类 this.declarationOrder = declarationOrder; this.aspectName = aspectName;//切面类 if (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) { //切面类如果是懒加载的话，走下面逻辑 // Static part of the pointcut is a lazy type. Pointcut preInstantiationPointcut = Pointcuts.union( aspectInstanceFactory.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut); // Make it dynamic: must mutate from pre-instantiation to post-instantiation state. // If it's not a dynamic pointcut, it may be optimized out // by the Spring AOP infrastructure after the first evaluation. this.pointcut = new PerTargetInstantiationModelPointcut( this.declaredPointcut, preInstantiationPointcut, aspectInstanceFactory); this.lazy = true; } else { // A singleton aspect. this.pointcut = this.declaredPointcut; //切入点 this.lazy = false; this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);//创建一个advice } }
我们看看advice的创建过程：
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); }
@Override @Nullable 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);//校验增强方法是否含有@before等相关注解 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)) { //这里又一次校验有没@Aspect注解 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()) { //根据注解的类型创建对应的advice case AtPointcut: //如果是切入点，其实就不用创建advice了 if (logger.isDebugEnabled()) { logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'"); } return null; case AtAround: springAdvice = new AspectJAroundAdvice( candidateAdviceMethod, expressionPointcut, aspectInstanceFactory); break; 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; 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; }
通过advice的创建过程，我们知道，一个advice主要包含增强的方法，方法参数，以及切入点，而advisor是包含Advice的，并且属性更多，功能更强大
至此，我们的第一个问题解决了：各种切入方式是如何被封装成advisor的?
小结：AnnotationAwareAspectJAutoProxyCreator这个类实现了InstantiationAwareBeanPostProcessor接口，所以其中有个方法：Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName)
在其他bean创建的过程中，会调用该方法，该方法会去查找容器中所有的advisor,查找的思路是获取所有的Bean的名称，然后通过名称获取bean的类型（此时bean还没实例化，所以取得是类型），之后判断有没@Aspect注解如果有该注解的话，就判断类下面的方法有没Pointcut.class, Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class 这几个注解，有就将对应的方法封装成advice,进一步封装成advisor
至此，所有的切入方法都封装成了advisor,存到了一个list集合中，下面分析代理类的创建，也就是我们的MyMath被代理过程：debug调试其创建bean的过程
前面分析过： AnnotationAwareAspectJAutoProxyCreator 实现BeanPostProcessor接口，该接口有2个方法：
我们先看看postProcessBeforeInitialization 的代码：
可见，没做任何逻辑，我们再看看另外一个方法：postProcessAfterInitialization
所以我们断点在该方法，调试MyMath创建过程：
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) { //在postProcessBeforeInstantiation方法也有创建代理对象逻辑，如果在那个方法创建的代理对象会存到targetSourcedBeans return bean; } if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) { //advisedBeans 缓存中已经有该bean，并且不用增强 return bean; }
//InfrastructureClass 是指Advice，Pointcut，Advisor，AopInfrastructureBean； shouldSkip(bean.getClass(), beanName)指的是beanName以 “.ORIGINAL” 结尾的
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { 在postProcessBeforeInstantiation这个方法也有一样的逻辑 this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; } // Create proxy if we have advice. Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null); //获取能用在该类上的advisor,逻辑是根据切面表达式来判断，之后会分析 if (specificInterceptors != DO_NOT_PROXY) { //如果获取到的advisor不为空，也就是由advisor可以用在该类上就创建代理对象 this.advisedBeans.put(cacheKey, Boolean.TRUE); //设置缓存，说明该bean的创建需要代理 Object proxy = createProxy( bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); //创建代理对象 this.proxyTypes.put(cacheKey, proxy.getClass());//缓存代理对象的类 return proxy; } this.advisedBeans.put(cacheKey, Boolean.FALSE); //如果没有可用的增强器，就标注上该bean不用创建代理 return bean; }
//上面要关注的2个方法，一个是如何查找一个类的增强器，也就是advisor,第二个是代理对象的创建：
先看这个方法：Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) { List<Advisor> candidateAdvisors = findCandidateAdvisors(); //获取所有的advisor,这个在之前已经分析过了 List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);//拿到所有的advisor,看看哪些能用在指定的bean,下面会跟进分析 extendAdvisors(eligibleAdvisors); //而外加入了一个advisor： advisors.add(0, ExposeInvocationInterceptor.ADVISOR); if (!eligibleAdvisors.isEmpty()) { eligibleAdvisors = sortAdvisors(eligibleAdvisors); //排序 } return eligibleAdvisors; }
protected List<Advisor> findAdvisorsThatCanApply( List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) { ProxyCreationContext.setCurrentProxiedBeanName(beanName); try { return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass); //继续跟进该方法 } finally { ProxyCreationContext.setCurrentProxiedBeanName(null); } }
public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) { if (candidateAdvisors.isEmpty()) { //如果没有候选的advisor,就不用走下去了 return candidateAdvisors; } List<Advisor> eligibleAdvisors = new ArrayList<>(); for (Advisor candidate : candidateAdvisors) { if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {//前面分析过，我们的advisor类型是：InstantiationModelAwarePointcutAdvisor 所以不会进入下面逻辑 eligibleAdvisors.add(candidate); } } boolean hasIntroductions = !eligibleAdvisors.isEmpty(); for (Advisor candidate : candidateAdvisors) { if (candidate instanceof IntroductionAdvisor) {//前面分析过，我们的advisor类型是：InstantiationModelAwarePointcutAdvisor 所以不会进入下面逻辑 // already processed continue; } if (canApply(candidate, clazz, hasIntroductions)) { //最终会到达这里，所以canApply(candidate, clazz, hasIntroductions) 决定了该advisor能否用于指定的class eligibleAdvisors.add(candidate); } } return eligibleAdvisors; }
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) { if (advisor instanceof IntroductionAdvisor) { return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass); } else if (advisor instanceof PointcutAdvisor) { PointcutAdvisor pca = (PointcutAdvisor) advisor; return canApply(pca.getPointcut(), targetClass, hasIntroductions); //判断逻辑会到达这里 } else { // It doesn't have a pointcut so we assume it applies. return true; } }
public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) { Assert.notNull(pc, "Pointcut must not be null"); if (!pc.getClassFilter().matches(targetClass)) { //判断切入点过滤的类型能否跟指定的类匹配，例如切入点表达式指定的是A类型，那么只有A类型才符合 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<Class<?>> classes = new LinkedHashSet<>(); if (!Proxy.isProxyClass(targetClass)) { //如果目标class不是Proxy的子类 classes.add(ClassUtils.getUserClass(targetClass)); } 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; //判断是否有方法匹配了，只要有一个方法匹配上切入点表达式，对应的advisor就可以用在目标class上 } } } return false; }
至此，我们知道了给目标class获取advisor的原理： 获取所有的advisor,然后遍历，根据advisor的切入点表达式Pointcut，校验目标class的方法是否有匹配上advisor的
接着，我们分析代理对象的创建过程：
Object proxy = createProxy( bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); //创建代理对象
目标bean被封装成了一个SingletonTargetSource
protected Object createProxy(Class<?> beanClass, @Nullable String beanName, @Nullable Object[] specificInterceptors, TargetSource targetSource) { if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
//这里给bean的定义设置了一个属性originalTargetClass AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass); } ProxyFactory proxyFactory = new ProxyFactory();//代理工厂 proxyFactory.copyFrom(this); if (!proxyFactory.isProxyTargetClass()) { //@EnableAspectJAutoProxy 注解的proxyTargetClass属性，当为true时，就不支持jdk动态代理，全部使用cglib，默认是false if (shouldProxyTargetClass(beanClass, beanName)) { //判断bean的定义对象的属性preserveTargetClass 是否为true,为true时，只支持cglib proxyFactory.setProxyTargetClass(true); } else {
//判断beanClass所有的实现接口，排除InitializingBean，AutoCloseable，DisposableBean，Closeable，Aware，是否还有其他接口，是的话，就可以用jdk动态代理 evaluateProxyInterfaces(beanClass, proxyFactory); } } Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);//主要的功能是强转，因为specificInterceptors数组的类型是Object proxyFactory.addAdvisors(advisors); proxyFactory.setTargetSource(targetSource); customizeProxyFactory(proxyFactory);//目前空实现 proxyFactory.setFrozen(this.freezeProxy); //设置是否需要冻结代理相关的配置，false if (advisorsPreFiltered()) { //advisor是否是过滤过的了，根据前面分析，advisor用于指定的bean前，通过切入点表达式过滤过了 proxyFactory.setPreFiltered(true); } return proxyFactory.getProxy(getProxyClassLoader()); }
//上面只是为需要代理的bean，创建了一个代理工厂，并且代理工厂设置了advisors 和目标bean对象，接下来跟进代理对象创建：
先分析： createAopProxy()
public class DefaultAopProxyFactory implements AopProxyFactory, Serializable { //前面ProxyFactory 设置的目标对象，advisors 都存在AdvisedSupport这里了 @Override public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
// 源码对 config.isOptimize()解释：optimization will usually mean that advice changes won't take effect after a proxy has been created.
//config.isOptimize()默认是false,config.isProxyTargetClass这个是@EnableAspectJAutoProxy的属性，为true时，即使目标类实现了接口也用cglib代理
//hasNoUserSuppliedProxyInterfaces(config) 没有用户提供的接口时，也没法使用jdk动态代理
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)) { //如果目标类就是接口，或者其继承了Proxy类，那就没法使用cglib代理了 return new JdkDynamicAopProxy(config); } return new ObjenesisCglibAopProxy(config); //使用cglib代理 } else { return new JdkDynamicAopProxy(config); //使用jdk代理 } }
... 省略其他代码
}
由于我的是jdk动态代理，执行getProxy后：
我们看看获取接口的方法：
static Class<?>[] completeProxiedInterfaces(AdvisedSupport advised, boolean decoratingProxy) { //主要是加上了三个接口SpringProxy，Advised，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); } else if (Proxy.isProxyClass(targetClass)) { advised.setInterfaces(targetClass.getInterfaces()); } specifiedInterfaces = advised.getProxiedInterfaces(); } } boolean addSpringProxy = !advised.isInterfaceProxied(SpringProxy.class); boolean addAdvised = !advised.isOpaque() && !advised.isInterfaceProxied(Advised.class); boolean addDecoratingProxy = (decoratingProxy && !advised.isInterfaceProxied(DecoratingProxy.class)); int nonUserIfcCount = 0; if (addSpringProxy) { nonUserIfcCount++; } if (addAdvised) { nonUserIfcCount++; } if (addDecoratingProxy) { nonUserIfcCount++; } Class<?>[] proxiedInterfaces = new Class<?>[specifiedInterfaces.length + nonUserIfcCount]; System.arraycopy(specifiedInterfaces, 0, proxiedInterfaces, 0, specifiedInterfaces.length); int index = specifiedInterfaces.length; if (addSpringProxy) { proxiedInterfaces[index] = SpringProxy.class; index++; } if (addAdvised) { proxiedInterfaces[index] = Advised.class; index++; } if (addDecoratingProxy) { proxiedInterfaces[index] = DecoratingProxy.class; } return proxiedInterfaces; }
Proxy.newProxyInstance(classLoader, proxiedInterfaces, this); 这个是jdk源码的内容了
至此，spring创建代理对象的源码分析完毕了，我们看看cglib的getProxy方法：
@Override public Object getProxy(@Nullable ClassLoader classLoader) { if (logger.isTraceEnabled()) { logger.trace("Creating CGLIB proxy: " + this.advised.getTargetSource()); } try { Class<?> rootClass = this.advised.getTargetClass(); //因为cglib使用的继承方式，所以目标类就是父类 Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy"); Class<?> proxySuperClass = rootClass; if (ClassUtils.isCglibProxyClass(rootClass)) { //判断目标类是否已经是cglib的代理类了，cglib的代理类，beanName是以"$$" 结尾的 proxySuperClass = rootClass.getSuperclass(); 如果是的话，就代理目标类的父类 Class<?>[] additionalInterfaces = rootClass.getInterfaces(); for (Class<?> additionalInterface : additionalInterfaces) { this.advised.addInterface(additionalInterface); } } // Validate the class, writing log messages as necessary. 做一些日志打印 validateClassIfNecessary(proxySuperClass, classLoader); // Configure CGLIB Enhancer... Enhancer enhancer = createEnhancer(); //cglib的创建器，相当于jdk动态代理的代理工厂Proxy if (classLoader != null) { enhancer.setClassLoader(classLoader); //设置类加载器 if (classLoader instanceof SmartClassLoader && ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) { enhancer.setUseCache(false); } } enhancer.setSuperclass(proxySuperClass); //设置需要代理的类 enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised)); //跟jdk代理一样，这里也会新增三个接口SpringProxy，Advised，DecoratingProxy enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);//cglib代理对象的命名策略，会加上"$$" 和 BySpringCGLIB 这些字符 enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader)); Callback[] callbacks = getCallbacks(rootClass); Class<?>[] types = new Class<?>[callbacks.length]; for (int x = 0; x < types.length; x++) { types[x] = callbacks[x].getClass(); } // fixedInterceptorMap only populated at this point, after getCallbacks call above enhancer.setCallbackFilter(new ProxyCallbackFilter( this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset)); enhancer.setCallbackTypes(types); // Generate the proxy class and create a proxy instance. return createProxyClassAndInstance(enhancer, callbacks);//最终会调用该方法创建一个代理对象 } catch (CodeGenerationException | IllegalArgumentException ex) { throw new AopConfigException("Could not generate CGLIB subclass of " + this.advised.getTargetClass() + ": Common causes of this problem include using a final class or a non-visible class", ex); } catch (Throwable ex) { // TargetSource.getTarget() failed throw new AopConfigException("Unexpected AOP exception", ex); } }
@Override protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) { Class<?> proxyClass = enhancer.createClass(); //创建出代理类 Object proxyInstance = null; if (objenesis.isWorthTrying()) { try { proxyInstance = objenesis.newInstance(proxyClass, enhancer.getUseCache()); //创建代理实例 } catch (Throwable ex) { logger.debug("Unable to instantiate proxy using Objenesis, " + "falling back to regular proxy construction", ex); } } if (proxyInstance == null) { // Regular instantiation via default constructor... try { Constructor<?> ctor = (this.constructorArgs != null ? proxyClass.getDeclaredConstructor(this.constructorArgTypes) : proxyClass.getDeclaredConstructor()); ReflectionUtils.makeAccessible(ctor); proxyInstance = (this.constructorArgs != null ? ctor.newInstance(this.constructorArgs) : ctor.newInstance()); //通过构造器创建代理实例 } catch (Throwable ex) { throw new AopConfigException("Unable to instantiate proxy using Objenesis, " + "and regular proxy instantiation via default constructor fails as well", ex); } } ((Factory) proxyInstance).setCallbacks(callbacks); return proxyInstance; }
我们可以输出代理类的字节码，设置一个属性：System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
执行后，在类路径可以看到：
找到我们的目标类：
// // Source code recreated from a .class file by IntelliJ IDEA // (powered by Fernflower decompiler) // package com.sun.proxy; import com.yang.xiao.hui.aop.Calc; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.lang.reflect.UndeclaredThrowableException; import org.aopalliance.aop.Advice; import org.springframework.aop.Advisor; import org.springframework.aop.SpringProxy; import org.springframework.aop.TargetSource; import org.springframework.aop.framework.Advised; import org.springframework.aop.framework.AopConfigException; import org.springframework.core.DecoratingProxy; //代理对象的所有方法的调用最终都会交给InvocationHandler 的invoke方法执行 public final class $Proxy22 extends Proxy implements Calc, SpringProxy, Advised, DecoratingProxy { // SpringProxy, Advised, DecoratingProxy 这三个接口是后面加上的，前面分析过了 private static Method m1; private static Method m9; private static Method m14; private static Method m13; private static Method m19; private static Method m24; private static Method m4; private static Method m8; private static Method m17; private static Method m18; private static Method m0; private static Method m23; private static Method m16; private static Method m11; private static Method m7; private static Method m2; private static Method m26; private static Method m15; private static Method m27; private static Method m20; private static Method m5; private static Method m6; private static Method m21; private static Method m10; private static Method m3; private static Method m25; private static Method m12; private static Method m22; public $Proxy22(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 boolean isExposeProxy() throws { try { return (Boolean)super.h.invoke(this, m9, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final void addAdvisor(Advisor var1) throws AopConfigException { try { super.h.invoke(this, m14, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final boolean isProxyTargetClass() throws { try { return (Boolean)super.h.invoke(this, m13, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final void removeAdvisor(int var1) throws AopConfigException { try { super.h.invoke(this, m19, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final Class[] getProxiedInterfaces() throws { try { return (Class[])super.h.invoke(this, m24, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final int indexOf(Advisor var1) throws { try { return (Integer)super.h.invoke(this, m4, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final TargetSource getTargetSource() throws { try { return (TargetSource)super.h.invoke(this, m8, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final void addAdvice(int var1, Advice var2) throws AopConfigException { try { super.h.invoke(this, m17, new Object[]{var1, var2}); } catch (RuntimeException | Error var4) { throw var4; } catch (Throwable var5) { throw new UndeclaredThrowableException(var5); } } public final void addAdvice(Advice var1) throws AopConfigException { try { super.h.invoke(this, m18, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final int hashCode() throws { try { return (Integer)super.h.invoke(this, m0, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final boolean isInterfaceProxied(Class var1) throws { try { return (Boolean)super.h.invoke(this, m23, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final boolean removeAdvice(Advice var1) throws { try { return (Boolean)super.h.invoke(this, m16, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final void setExposeProxy(boolean var1) throws { try { super.h.invoke(this, m11, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final void setTargetSource(TargetSource var1) throws { try { super.h.invoke(this, m7, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final String toString() throws { try { return (String)super.h.invoke(this, m2, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final Class getTargetClass() throws { try { return (Class)super.h.invoke(this, m26, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final void addAdvisor(int var1, Advisor var2) throws AopConfigException { try { super.h.invoke(this, m15, new Object[]{var1, var2}); } catch (RuntimeException | Error var4) { throw var4; } catch (Throwable var5) { throw new UndeclaredThrowableException(var5); } } public final Class getDecoratedClass() throws { try { return (Class)super.h.invoke(this, m27, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final boolean removeAdvisor(Advisor var1) throws { try { return (Boolean)super.h.invoke(this, m20, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final int indexOf(Advice var1) throws { try { return (Integer)super.h.invoke(this, m5, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final boolean isFrozen() throws { try { return (Boolean)super.h.invoke(this, m6, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final boolean replaceAdvisor(Advisor var1, Advisor var2) throws AopConfigException { try { return (Boolean)super.h.invoke(this, m21, new Object[]{var1, var2}); } catch (RuntimeException | Error var4) { throw var4; } catch (Throwable var5) { throw new UndeclaredThrowableException(var5); } } public final void setPreFiltered(boolean var1) throws { try { super.h.invoke(this, m10, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final Integer add(int var1, int var2) throws { try { return (Integer)super.h.invoke(this, m3, new Object[]{var1, var2}); } catch (RuntimeException | Error var4) { throw var4; } catch (Throwable var5) { throw new UndeclaredThrowableException(var5); } } public final String toProxyConfigString() throws { try { return (String)super.h.invoke(this, m25, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final Advisor[] getAdvisors() throws { try { return (Advisor[])super.h.invoke(this, m12, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final boolean isPreFiltered() throws { try { return (Boolean)super.h.invoke(this, m22, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object")); m9 = Class.forName("org.springframework.aop.framework.Advised").getMethod("isExposeProxy"); m14 = Class.forName("org.springframework.aop.framework.Advised").getMethod("addAdvisor", Class.forName("org.springframework.aop.Advisor")); m13 = Class.forName("org.springframework.aop.framework.Advised").getMethod("isProxyTargetClass"); m19 = Class.forName("org.springframework.aop.framework.Advised").getMethod("removeAdvisor", Integer.TYPE); m24 = Class.forName("org.springframework.aop.framework.Advised").getMethod("getProxiedInterfaces"); m4 = Class.forName("org.springframework.aop.framework.Advised").getMethod("indexOf", Class.forName("org.springframework.aop.Advisor")); m8 = Class.forName("org.springframework.aop.framework.Advised").getMethod("getTargetSource"); m17 = Class.forName("org.springframework.aop.framework.Advised").getMethod("addAdvice", Integer.TYPE, Class.forName("org.aopalliance.aop.Advice")); m18 = Class.forName("org.springframework.aop.framework.Advised").getMethod("addAdvice", Class.forName("org.aopalliance.aop.Advice")); m0 = Class.forName("java.lang.Object").getMethod("hashCode"); m23 = Class.forName("org.springframework.aop.framework.Advised").getMethod("isInterfaceProxied", Class.forName("java.lang.Class")); m16 = Class.forName("org.springframework.aop.framework.Advised").getMethod("removeAdvice", Class.forName("org.aopalliance.aop.Advice")); m11 = Class.forName("org.springframework.aop.framework.Advised").getMethod("setExposeProxy", Boolean.TYPE); m7 = Class.forName("org.springframework.aop.framework.Advised").getMethod("setTargetSource", Class.forName("org.springframework.aop.TargetSource")); m2 = Class.forName("java.lang.Object").getMethod("toString"); m26 = Class.forName("org.springframework.aop.framework.Advised").getMethod("getTargetClass"); m15 = Class.forName("org.springframework.aop.framework.Advised").getMethod("addAdvisor", Integer.TYPE, Class.forName("org.springframework.aop.Advisor")); m27 = Class.forName("org.springframework.core.DecoratingProxy").getMethod("getDecoratedClass"); m20 = Class.forName("org.springframework.aop.framework.Advised").getMethod("removeAdvisor", Class.forName("org.springframework.aop.Advisor")); m5 = Class.forName("org.springframework.aop.framework.Advised").getMethod("indexOf", Class.forName("org.aopalliance.aop.Advice")); m6 = Class.forName("org.springframework.aop.framework.Advised").getMethod("isFrozen"); m21 = Class.forName("org.springframework.aop.framework.Advised").getMethod("replaceAdvisor", Class.forName("org.springframework.aop.Advisor"), Class.forName("org.springframework.aop.Advisor")); m10 = Class.forName("org.springframework.aop.framework.Advised").getMethod("setPreFiltered", Boolean.TYPE); m3 = Class.forName("com.yang.xiao.hui.aop.Calc").getMethod("add", Integer.TYPE, Integer.TYPE); m25 = Class.forName("org.springframework.aop.framework.Advised").getMethod("toProxyConfigString"); m12 = Class.forName("org.springframework.aop.framework.Advised").getMethod("getAdvisors"); m22 = Class.forName("org.springframework.aop.framework.Advised").getMethod("isPreFiltered"); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); } } }
//通过分析，我们知道，jdk动态代理类的所有方法，都会交给//代理对象的所有方法的调用最终都会交给InvocationHandler 的invoke方法执行，那么这个InvocationHandler 又是哪里来的呢，我们回到jdk动态代理创建过程：
因此代理类的方法会被JdkDynamicAopProxy 的invoke 拦截，而JdkDynamicAopProxy有个属性：AdvisedSupport 该对象拥有被代理对象和advisors，因此可以进行前后拦截了，而AdvisedSupport 是什么时候传入的呢？
至此，哪个类会被代理，以及如何代理，分析完毕，下篇博客，我们会分析，代理方法的执行流程
