SpringAOP

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd"> <!-- 注解驱动加上这句话 --> <!--<aop:aspectj-autoproxy proxy-target-class="true"/>--> <bean id="xmlAspect" class="cn.jihongyun.aop.aspect.XmlAspect"></bean> <bean id="xmlCutPointService" class="cn.jihongyun.aop.service.XmlCutPointService"></bean> <!--AOP配置 --> <aop:config> <!--声明一个切面,并注入切面Bean,相当于@Aspect --> <aop:aspect ref="xmlAspect" > <!--配置一个切入点,相当于@Pointcut --> <aop:pointcut expression="execution(* cn.jihongyun.aop.service..*(..))" id="simplePointcut"/> <!--配置通知,相当于@Before、@After、@AfterReturn、@Around、@AfterThrowing --> <aop:before pointcut-ref="simplePointcut" method="before"/> <aop:after pointcut-ref="simplePointcut" method="after"/> <aop:after-returning pointcut-ref="simplePointcut" method="afterReturn"/> <aop:after-throwing pointcut-ref="simplePointcut" method="afterThrow" throwing="ex"/> <aop:around pointcut-ref="simplePointcut" method="around"/> </aop:aspect> </aop:config> </beans>

package cn.jihongyun.aop.aspect; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import java.util.logging.Logger; /** * XML版本Aspect切面 */ public class XmlAspect { private final static Logger logger = Logger.getLogger("XmlAspect"); /** * 配置前置通知，使用方法aspect()上注册的切入点 * 同时接受Joinpoint切入点对象，可以没有参数 * @param joinpoint */ public void before(JoinPoint joinpoint) { logger.info("before" + joinpoint); } // 配置后置通知，使用在方法 public void after(JoinPoint joinpoint) { logger.info("after" + joinpoint); } // 配置环绕通知，使用方法aspect() 上注册的切入点 public void around(JoinPoint joinpoint) { long start = System.currentTimeMillis(); try { ((ProceedingJoinPoint) joinpoint).proceed(); long end = System.currentTimeMillis(); logger.info("around"+joinpoint+"\tUse time : "+(end - start )+"ms!"); } catch (Throwable e) { long end = System.currentTimeMillis(); logger.info("around"+joinpoint+"\tUse time : "+(end - start )+"ms with Exception : "+e.getMessage()); } } // 配置后置返回通知，使用在方法aspect()上注册的切入点 public void afterReturn(JoinPoint joinpoint) { logger.info("afterReturn " + joinpoint); } // 配置抛出异常后通知，使用在方法aspect()上注册的切入点 public void afterThrow(JoinPoint joinpoint, Exception ex) { logger.info("afterThrow " + joinpoint + "\t" + ex.getMessage()); } }

package cn.jihongyun.aop.service; import java.util.logging.Logger; public class XmlCutPointService { private final static Logger log = Logger.getLogger("XmlCutPointService"); public Boolean normal(Long normal) { log.info("normal() execute!"); return Boolean.TRUE; } public Boolean exception(Long exception) { log.info("exception() execute!"); throw new RuntimeException("unknown"); } }

package cn.jihongyun.aop.test; import cn.jihongyun.aop.service.XmlCutPointService; import org.springframework.context.support.ClassPathXmlApplicationContext; public class XmlTest { public static void main(String[] args) { ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application-context.xml"); XmlCutPointService xm = (XmlCutPointService) context.getBean("xmlCutPointService"); xm.normal(1L); System.out.println("=================================="); xm.exception(11L); } }

十月 26, 2021 1:45:42 下午 cn.jihongyun.aop.aspect.XmlAspect before 信息: beforeexecution(Boolean cn.jihongyun.aop.service.XmlCutPointService.normal(Long)) 十月 26, 2021 1:45:42 下午 cn.jihongyun.aop.service.XmlCutPointService normal 信息: normal() execute! 十月 26, 2021 1:45:42 下午 cn.jihongyun.aop.aspect.XmlAspect around 信息: aroundexecution(Boolean cn.jihongyun.aop.service.XmlCutPointService.normal(Long)) Use time : 14ms! 十月 26, 2021 1:45:42 下午 cn.jihongyun.aop.aspect.XmlAspect afterReturn 信息: afterReturn execution(Boolean cn.jihongyun.aop.service.XmlCutPointService.normal(Long)) 十月 26, 2021 1:45:42 下午 cn.jihongyun.aop.aspect.XmlAspect after 信息: afterexecution(Boolean cn.jihongyun.aop.service.XmlCutPointService.normal(Long)) 十月 26, 2021 1:45:42 下午 cn.jihongyun.aop.aspect.XmlAspect before 信息: beforeexecution(Boolean cn.jihongyun.aop.service.XmlCutPointService.exception(Long)) 十月 26, 2021 1:45:42 下午 cn.jihongyun.aop.service.XmlCutPointService exception 信息: exception() execute! 十月 26, 2021 1:45:42 下午 cn.jihongyun.aop.aspect.XmlAspect around 信息: aroundexecution(Boolean cn.jihongyun.aop.service.XmlCutPointService.exception(Long)) Use time : 0ms with Exception : unknown 十月 26, 2021 1:45:42 下午 cn.jihongyun.aop.aspect.XmlAspect afterReturn 信息: afterReturn execution(Boolean cn.jihongyun.aop.service.XmlCutPointService.exception(Long)) 十月 26, 2021 1:45:42 下午 cn.jihongyun.aop.aspect.XmlAspect after 信息: afterexecution(Boolean cn.jihongyun.aop.service.XmlCutPointService.exception(Long)) ================================== Process finished with exit code 0

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <context:component-scan base-package="cn.jihongyun"/> <!--注解驱动需要加上这个配置--> <aop:aspectj-autoproxy proxy-target-class="true"/> <!-- <import resource="application-aop.xml"/>--> </beans>

package cn.jihongyun.aop.aspect; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component; import java.util.logging.Logger; @Component @Aspect public class AnnotationAspect { private final static Logger logger = Logger.getLogger("AnnotationAspect"); @Pointcut("execution(* cn.jihongyun.aop.service..*(..))") public void aspect() { } @Before("aspect()") public void before(JoinPoint joinpoint) { logger.info("before" + joinpoint); } // 配置后置通知，使用在方法 @After("aspect()") public void after(JoinPoint joinpoint) { logger.info("after" + joinpoint); } // 配置环绕通知，使用方法aspect() 上注册的切入点 @Around("aspect()") public void around(JoinPoint joinpoint) { long start = System.currentTimeMillis(); try { ((ProceedingJoinPoint) joinpoint).proceed(); long end = System.currentTimeMillis(); logger.info("around"+joinpoint+"\tUse time : "+(end - start )+"ms!"); } catch (Throwable e) { long end = System.currentTimeMillis(); logger.info("around"+joinpoint+"\tUse time : "+(end - start )+"ms with Exception : "+e.getMessage()); } } // 配置后置返回通知，使用在方法aspect()上注册的切入点 @AfterReturning("aspect()") public void afterReturn(JoinPoint joinpoint) { logger.info("afterReturn " + joinpoint); } // 配置抛出异常后通知，使用在方法aspect()上注册的切入点 @AfterThrowing(pointcut = "aspect()",throwing = "ex") public void afterThrow(JoinPoint joinpoint, Exception ex) { logger.info("afterThrow " + joinpoint + "\t" + ex.getMessage()); } }

package cn.jihongyun.aop.service; import org.springframework.stereotype.Service; import java.util.logging.Logger; @Service public class AnnotationCutPointService { private final static Logger log = Logger.getLogger("AnnotationCutPointService"); public Boolean normal(Long normal) { log.info("normal() execute!"); return Boolean.TRUE; } public Boolean exception(Long exception) { log.info("exception() execute!"); throw new RuntimeException("unknown"); } }

package cn.jihongyun.aop.test; import cn.jihongyun.aop.service.AnnotationCutPointService; import org.springframework.context.support.ClassPathXmlApplicationContext; public class AnnotationAspectTest { public static void main(String[] args) { ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application-context.xml"); AnnotationCutPointService xm = context.getBean(AnnotationCutPointService.class); xm.normal(1L); xm.exception(11L); } }

十月 26, 2021 2:27:58 下午 cn.jihongyun.aop.aspect.AnnotationAspect before 信息: beforeexecution(Boolean cn.jihongyun.aop.service.AnnotationCutPointService.normal(Long)) 十月 26, 2021 2:27:58 下午 cn.jihongyun.aop.service.AnnotationCutPointService normal 信息: normal() execute! 十月 26, 2021 2:27:58 下午 cn.jihongyun.aop.aspect.AnnotationAspect around 信息: aroundexecution(Boolean cn.jihongyun.aop.service.AnnotationCutPointService.normal(Long)) Use time : 15ms! 十月 26, 2021 2:27:58 下午 cn.jihongyun.aop.aspect.AnnotationAspect after 信息: afterexecution(Boolean cn.jihongyun.aop.service.AnnotationCutPointService.normal(Long)) 十月 26, 2021 2:27:58 下午 cn.jihongyun.aop.aspect.AnnotationAspect afterReturn 信息: afterReturn execution(Boolean cn.jihongyun.aop.service.AnnotationCutPointService.normal(Long)) 十月 26, 2021 2:27:58 下午 cn.jihongyun.aop.aspect.AnnotationAspect before 信息: beforeexecution(Boolean cn.jihongyun.aop.service.AnnotationCutPointService.exception(Long)) 十月 26, 2021 2:27:58 下午 cn.jihongyun.aop.service.AnnotationCutPointService exception 信息: exception() execute! 十月 26, 2021 2:27:58 下午 cn.jihongyun.aop.aspect.AnnotationAspect around 信息: aroundexecution(Boolean cn.jihongyun.aop.service.AnnotationCutPointService.exception(Long)) Use time : 1ms with Exception : unknown 十月 26, 2021 2:27:58 下午 cn.jihongyun.aop.aspect.AnnotationAspect after 信息: afterexecution(Boolean cn.jihongyun.aop.service.AnnotationCutPointService.exception(Long)) 十月 26, 2021 2:27:58 下午 cn.jihongyun.aop.aspect.AnnotationAspect afterReturn 信息: afterReturn execution(Boolean cn.jihongyun.aop.service.AnnotationCutPointService.exception(Long))

public interface BeanPostProcessor { /** * Apply this BeanPostProcessor to the given new bean instance <i>before</i> any bean * initialization callbacks (like InitializingBean's {@code afterPropertiesSet} * or a custom init-method). The bean will already be populated with property values. * The returned bean instance may be a wrapper around the original. * <p>The default implementation returns the given {@code bean} as-is. * @param bean the new bean instance * @param beanName the name of the bean * @return the bean instance to use, either the original or a wrapped one; * if {@code null}, no subsequent BeanPostProcessors will be invoked * @throws org.springframework.beans.BeansException in case of errors * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet */ // 为在bean的初始化前提供回调入口 @Nullable default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } /** * Apply this BeanPostProcessor to the given new bean instance <i>after</i> any bean * initialization callbacks (like InitializingBean's {@code afterPropertiesSet} * or a custom init-method). The bean will already be populated with property values. * The returned bean instance may be a wrapper around the original. * <p>In case of a FactoryBean, this callback will be invoked for both the FactoryBean * instance and the objects created by the FactoryBean (as of Spring 2.0). The * post-processor can decide whether to apply to either the FactoryBean or created * objects or both through corresponding {@code bean instanceof FactoryBean} checks. * <p>This callback will also be invoked after a short-circuiting triggered by a * {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation} method, * in contrast to all other BeanPostProcessor callbacks. * <p>The default implementation returns the given {@code bean} as-is. * @param bean the new bean instance * @param beanName the name of the bean * @return the bean instance to use, either the original or a wrapped one; * if {@code null}, no subsequent BeanPostProcessors will be invoked * @throws org.springframework.beans.BeansException in case of errors * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet * @see org.springframework.beans.factory.FactoryBean */ // 为在bean的初始化之后提供回调入口 @Nullable default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { return bean; } }

// 真正创建Bean的方法 protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException { ... // Initialize the bean instance. // Bean对象的初始化，依赖注入在此出发 // 这个exposedObject在初始化完成之后返回作为依赖注入完成后的Bean Object exposedObject = bean; try { // 将Bean实例对象封装，并且Bean定义中配置的属性值赋值 populateBean(beanName, mbd, instanceWrapper); // 在对bean实例对象生成和依赖注入完成以后，开始对bean实例对象 // 进行初始化，为bean实例对象应用beanPostProcessor后置处理器 exposedObject = initializeBean(beanName, exposedObject, mbd); } catch (Throwable ex) { if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { throw (BeanCreationException) ex; } else { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex); } } ... // Register bean as disposable. // 注册完成以来注入的bean try { registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } return exposedObject; }

// 初始化容器创建的bean实例对象，为其添加BeanPostProcessor后置处理器 protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) { // JDK的安全机制验证权限 if (System.getSecurityManager() != null) { // 实现PrivilegedAction接口的匿名内部类 AccessController.doPrivileged((PrivilegedAction<Object>) () -> { invokeAwareMethods(beanName, bean); return null; }, getAccessControlContext()); } else { // 为Bean实例对象包装相关属性，如名称，类加载器，所属容器等信息 invokeAwareMethods(beanName, bean); } Object wrappedBean = bean; // 对BeanPostProcessor后置处理器的postProcessBeforeInitialization // 回调方法的调用，为Bean实例初始化前做一些处理 if (mbd == null || !mbd.isSynthetic()) { wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } // 调用bean实例对象初始化的方法，这个初始化方法是在Spring Bean定义配置 // 文件中通过init-Method属性指定的 try { invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable ex) { throw new BeanCreationException( (mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex); } // 对BeanPostProcessor后置处理器的postProcessAfterInitialization // 回调方法的调用，为Bean实例初始化之后做一些处理 if (mbd == null || !mbd.isSynthetic()) { wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } return wrappedBean; } // 调用BeanPostProcessor后置处理器实例对象初始化之前的处理方法 @Override public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException { Object result = existingBean; // 遍历容器为所创建的bean添加的所有BeanPostProcessor后置处理器 for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) { // 调用bean实例所有的后置处理中的初始化前处理方法，为Bean实例对象在 // 初始化之前做一些自定义的处理操作 Object current = beanProcessor.postProcessBeforeInitialization(result, beanName); if (current == null) { return result; } result = current; } return result; } @Override // 调用BeanPostProcessor后置处理器实例对象初始化之后的处理方法 public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException { Object result = existingBean; // 遍历容器为所创建的bean添加的所有BeanPostProcessor后置处理器 for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) { // 调用bean实例所有的后置处理中的初始化后处理方法，为bean实例对象在 // 初始化之后做一些自定义的处理操作 Object current = beanProcessor.postProcessAfterInitialization(result, beanName); if (current == null) { return result; } result = current; } return result; }

@Override public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException { if (bean != null) { Object cacheKey = getCacheKey(bean.getClass(), beanName); if (!this.earlyProxyReferences.contains(cacheKey)) { return wrapIfNecessary(bean, beanName, cacheKey); } } return bean; } protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) { return bean; } // 判断是否需要代理这个bean if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) { return bean; } // 判断是否是一些infrastructureClass或者是否应该跳过这个bean // 所谓infrastructureClass就是指Advice/PointCut/Advisor等接口的实现类 // shouldSkip默认实现为返回false，由于是protected方法，子类可以覆盖 if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; } // Create proxy if we have advice. // 获取这个bean的advice 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; } 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()); }

@SuppressWarnings("serial") public class DefaultAopProxyFactory implements AopProxyFactory, Serializable { @Override 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)) { return new JdkDynamicAopProxy(config); } return new ObjenesisCglibAopProxy(config); } else { return new JdkDynamicAopProxy(config); } } /** * Determine whether the supplied {@link AdvisedSupport} has only the * {@link org.springframework.aop.SpringProxy} interface specified * (or no proxy interfaces specified at all). */ private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) { Class<?>[] ifcs = config.getProxiedInterfaces(); return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0]))); } }

/** * 获取代理类要实现的接口，除了Advised对象中配置的，还会加上SpringProxy,Advised(opaque=false) * 检查上面所得到的接口中有没有定义equals或者hashcode的接口 * 调用Proxy.newProxyInstance创建代理对象 * @param classLoader the class loader to create the proxy with * (or {@code null} for the low-level proxy facility's default) * @return */ @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); }

@Override @Nullable 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 { // equals()方法，具目标对象未实现此方法 if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) { // The target does not implement the equals(Object) method itself. return equals(args[0]); } // hashCode()方法，具目标对象未实现此方法 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); } // 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. // 获取可以应用到此方法上的Interceptor类 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. // 如果没有可以应用到此方法的通知（interceptor），此直接反射调用Method.invoke(target,args) 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... // 创建MethodInvocation 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; }

@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. List<Object> interceptorList = new ArrayList<>(config.getAdvisors().length); Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass()); // 查看是否包含IntroductionAdvisor boolean hasIntroductions = hasMatchingIntroductions(config, actualClass); // 这里实际注册一系列AdvisorAdapter，用于将Advisor转换为MethodInterceptor 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)) { // 这个地方这两个方法的位置可以互换下 // 将Advisor转换为Interceptor MethodInterceptor[] interceptors = registry.getInterceptors(advisor); // 检查当前advisor的pointcut是否可以匹配当前方法 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; }

// 如果没有可以应用到此方法的通知（interceptor），此直接反射调用Method.invoke(target,args) 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... // 创建MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain); // Proceed to the joinpoint through the interceptor chain. retVal = invocation.proceed(); }

@Override @Nullable public Object proceed() throws Throwable { // We start with an index of -1 and increment early. // 如果Interceptor执行完成，则执行JoinPoint 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. // 如果要动态匹配joinPoint 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. // 动态匹配失败时，略过当前interceptor，调用下一个Intercepter return proceed(); } } else { // It's an interceptor, so we just invoke it: The pointcut will have // been evaluated statically before this object was constructed. // 执行当前Interceptor return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this); } }

@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); } }