AnnotationAwareAspectJAutoProxyCreator执行时机
AnnotationAwareAspectJAutoProxyCreator是InstantiationAwareBeanPostProcessor的实现类,实现了 postProcessBeforeInstantiation()、postProcessAfterInstantiation()两个方法,这两个方法的执行时机就是在分别bean创建实例之前和之后执行。
postProcessBeforeInstantiation()
方法分析
/**
AbstractAutoProxyCreator中实现的了InstantiationAwareBeanPostProcessor接口,而下面的方法就是该接口提供的
作用:
postProcessBeforeInstantiation():在每一个Bean创建实例之前,调用该方法
*/
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
// 获取该bean的名称
Object cacheKey = getCacheKey(beanClass, beanName);
if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
// 判断当前bean是不是需要增强的bean,第一次是没有的
if (this.advisedBeans.containsKey(cacheKey)) {
return null;
}
/**
isInfrastructureClass(beanClass):
里面有一条判断代码:
(super.isInfrastructureClass(beanClass) ||
(this.aspectJAdvisorFactory != null && this.aspectJAdvisorFactory.isAspect(beanClass)));
super.isInfrastructureClass(beanClass):用来判断该bean是不是基础类型Advice、Pointcut、Advisor、 AopInfrastructureBean
this.aspectJAdvisorFactory.isAspect(beanClass)):用来判断该bean是否有@Aspect注解(是不是切面类)
*/
if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}
// Create proxy here if we have a custom TargetSource.
// Suppresses unnecessary default instantiation of the target bean:
// The TargetSource will handle target instances in a custom fashion.
// 获取自定义的targetSource
TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
if (targetSource != null) {
if (StringUtils.hasLength(beanName)) {
this.targetSourcedBeans.add(beanName);
}
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
return null;
}
在bean实例化前调用这个方法之后,后面会创建bean实例,然后对bean进行参数赋值populateBean(beanName, mbd, instanceWrapper)
,执行exposedObject = initializeBean(beanName, exposedObject, mbd)
方法。
initializeBean(beanName, exposedObject, mbd)
方法
/**
* 初始化给定的bean实例,并且应用工厂回调init方法和bean后处理器。
* 对于传统定义的bean,从{@link #createBean}调用,对于现有的bean实例,从{@link #initializeBean}调用。
* @param beanName 工厂中的bean名称(用于调试)
* @param bean 我们可能需要初始化的新bean实例
* @param mbd 使用创建的bean的bean定义(如果给定了现有的bean实例,也可以是{@code null})
* @return 初始化的bean实例(可能包装)
* @see BeanNameAware
* @see BeanClassLoaderAware
* @see BeanFactoryAware
* @see #applyBeanPostProcessorsBeforeInitialization
* @see #invokeInitMethods
* @see #applyBeanPostProcessorsAfterInitialization
*/
// 作用:初始化bean方法
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
// java安全管理
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
// 调用Aware方法:方法里面会判断bean是否实现了BeanNameAware、BeanClassLoaderAware、BeanFactoryAware接口,如果实现则调用被重写的方法
invokeAwareMethods(beanName, bean);
}
// 词语解析:wrapped 包裹、包装
Object wrappedBean = bean;
// 判断mbd==null || bean定义是否是“合成的”,即不是由应用程序本身定义的。
if (mbd == null || !mbd.isSynthetic()) {
/**
* 执行beanPostProcessors的postProcessBeforeInitialization()方法;
*
* 作用:会在所有bean进行初始化之前调用所有的beanPostProcessors中的postProcessBeforeInitialization()方法;
*
* 具体代码步骤:
1、Object result = existingBean;
2、遍历所有beanPostProcessors,并调用其的postProcessBeforeInitialization()方法
3、return result;
*/
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
/*
现在,给一个bean一个机会来做出反应,它的所有属性都已设置,并有一个机会了解它拥有的bean工厂(此对象)。这意味着检查bean是否实现了InitializingBean或定义了一个自定义的init方法,并在调用时调用了必要的回调。
作用:对bean进行初始化操作
*/
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
// 判断mbd==null || bean定义是否是“合成的”,即不是由应用程序本身定义的。
if (mbd == null || !mbd.isSynthetic()) {
/**
* 执行beanPostProcessors的postProcessAfterInitialization()方法;
*
* 作用:会在所有bean进行初始化之前调用所有的beanPostProcessors中的postProcessAfterInitialization()方法;
*
* 具体代码步骤:
1、Object result = existingBean;
2、遍历所有beanPostProcessors,并调用其的postProcessAfterInitialization()方法
3、return result;
*/
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
postProcessAfterInitialization(result, beanName)
方法分析
/**
* 如果bean被子类确定为要代理的对象,则用配置的拦截器创建一个代理。
* @see #getAdvicesAndAdvisorsForBean
*/
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
// 获取bean名称
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {、
// 如果需要的话就包装(创建代理对象)起来!!!!(获取到了一个给定bean的proxy代理对象)。需求:如果bean是需要被切入(增强)的组件
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
wrapIfNecessary(bean, beanName, cacheKey)
方法分析
/**
* 必要时包装给定的bean,即是否有资格被代理。
* @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) {
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
// 判断已经增强的bean中有没有当前bean(advisedBeans)
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
// 判断当前bean是不是基础类型(切面相关)/切面
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// 如果我们有增强器(通知)的话,请创建代理。
// 获取当前bean的增强器(通知方法):这里需要深度解析一下
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 为给定的bean创建一个AOP代理。
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
// 将proxy代理对象添加到proxyTypes中
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null)
在这句代码中,作用是获取了当前bean的所有增强器(通知方法),具体过程如下:
getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null)
方法
@Override
@Nullable
protected Object[] getAdvicesAndAdvisorsForBean(
Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
// 查找符合条件(可用)的增强器(通知方法)
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}
findEligibleAdvisors(beanClass, beanName)
方法
/**
* 查找所有符合条件(可用)的增强器(通知方法)以自动代理该class
* @param beanClass the clazz to find advisors for
* @param beanName the name of the currently proxied bean
* @return the empty List, not {@code null},
* if there are no pointcuts or interceptors
* @see #findCandidateAdvisors
* @see #sortAdvisors
* @see #extendAdvisors
*/
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
// 单词扩展:candidate 候选者
// 查找并获取所有候选器增强器(通知方法)
List<Advisor> candidateAdvisors = findCandidateAdvisors();‘
// 查找所有可以使用的增强器(通知方法)
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName)
方法
/**
* 搜索给定的候选Advisor(增强器(通知方法)),以查找可以应用于指定bean的所有Advisor(增强器(通知方法))。
* @param candidateAdvisors the candidate Advisors
* @param beanClass the target's bean class
* @param beanName the target's bean name
* @return the List of applicable Advisors
* @see ProxyCreationContext#getCurrentProxiedBeanName()
*/
protected List<Advisor> findAdvisorsThatCanApply(
List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
// 设置bean名称
ProxyCreationContext.setCurrentProxiedBeanName(beanName);
try {
// 查找所有可以使用在bean的增强器(通知方法)列表
return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
}
finally {
ProxyCreationContext.setCurrentProxiedBeanName(null);
}
}
findAdvisorsThatCanApply(candidateAdvisors, beanClass)
方法
/**
* 确定{@code 候选通知}列表的子列表,该子列表适用于给定的class类。
* @param candidateAdvisors the Advisors to evaluate
* @param clazz the target class
* @return sublist of Advisors that can apply to an object of the given class
* (may be the incoming List as-is)
*/
public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
// 判断候选增强器(通知方法)列表是否为空
if (candidateAdvisors.isEmpty()) {
return candidateAdvisors;
}
// 遍历候选增强器列表,将可用在bean的增强器(通知方法)添加到eligibleAdvisors列表中
List<Advisor> eligibleAdvisors = new ArrayList<>();
for (Advisor candidate : candidateAdvisors) {
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;
}
/*
判断候选增强器是不是可用的,如果是,将增强器添加到eligibleAdvisors列表中
canApply():用于判断增强器是否可以应用到给定的class类上。
内容:
if (advisor instanceof IntroductionAdvisor) {
return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
}
else if (advisor instanceof PointcutAdvisor) {
// 通过切入点表达式判断增强器是否可以用在指定class类的方法上
PointcutAdvisor pca = (PointcutAdvisor) advisor;
return canApply(pca.getPointcut(), targetClass, hasIntroductions);
}
else {
// It doesn't have a pointcut so we assume it applies.
return true;
}
*/
if (canApply(candidate, clazz, hasIntroductions)) {
// 将可以用在指定class类的增强器添加到eligibleAdvisors列表中
eligibleAdvisors.add(candidate);
}
}
// 返回可应用于给定class类的对象的Advisor(增强器)列表
return eligibleAdvisors;
}
Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean))
方法:为给定的bean创建一个AOP代理
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);
}
}
// 对proxy进行一些初始化和自定义操作
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
proxyFactory.addAdvisors(advisors);
proxyFactory.setTargetSource(targetSource);
customizeProxyFactory(proxyFactory);
proxyFactory.setFrozen(this.freezeProxy);
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}
// 返回给定bean的proxy代理
return proxyFactory.getProxy(getProxyClassLoader());
}
proxyFactory.getProxy(getProxyClassLoader())
方法
public Object getProxy(@Nullable ClassLoader classLoader) {
// 创建proxy代理对象并获取proxy代理对象
return createAopProxy().getProxy(classLoader);
}
getAopProxyFactory()
方法
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
return getAopProxyFactory().createAopProxy(this);
}
getAopProxyFactory()
方法
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 {
// 如果目标有实现,使用jdk创建代理
return new JdkDynamicAopProxy(config);
}
}
目标方法执行
bean.play();
ioc容器中存放着bean的代理对象,代理对象中保存了详细信息(增强器、增强对象…)。
创建拦截器链
chain:拦截器链。将每一个通知方法包装成为方法拦截器,利用MethodInterceptor的机制拦截切入点(被增强的方法)的,然后执行通知方法
intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy)
方法
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
// 声明变量
Object oldProxy = null;
boolean setProxyContext = false;
Object target = null;
TargetSource targetSource = this.advised.getTargetSource();
try {
if (this.advised.exposeProxy) {
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
// 获取要切入的目标对象
target = targetSource.getTarget();
Class<?> targetClass = (target != null ? target.getClass() : null);
// 根据proxyFactory对象获取目标方法的拦截器链
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
Object retVal;
// Check whether we only have one InvokerInterceptor: that is,
// no real advice, but just reflective invocation of the target.
if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
// 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 = methodProxy.invoke(target, argsToUse);
}
else {
// We need to create a method invocation...
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
}
retVal = processReturnType(proxy, target, method, retVal);
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) {
targetSource.releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}
this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass)
方法
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
Advised config, Method method, @Nullable Class<?> targetClass) {
// This is somewhat tricky... We have to process introductions first,
// but we need to preserve order in the ultimate list.
// 声明变量
AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
Advisor[] advisors = config.getAdvisors();
// 创建InterceptorList,并设置长度,长度为advisors.length所有增强器的个数(5)
List<Object> interceptorList = new ArrayList<>(advisors.length);
Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
Boolean hasIntroductions = null;
for (Advisor advisor : advisors) {
if (advisor instanceof PointcutAdvisor) {
// Add it conditionally.
PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
boolean match;
if (mm instanceof IntroductionAwareMethodMatcher) {
if (hasIntroductions == null) {
hasIntroductions = hasMatchingIntroductions(advisors, actualClass);
}
match = ((IntroductionAwareMethodMatcher) mm).matches(method, actualClass, hasIntroductions);
}
else {
match = mm.matches(method, actualClass);
}
if (match) {
// 获取MethodInterceptor数组,怎么获取呢?看下面
MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
if (mm.isRuntime()) {
// Creating a new object instance in the getInterceptors() method
// isn't a problem as we normally cache created chains.
for (MethodInterceptor interceptor : interceptors) {
interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
}
}
else {
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;
}
registry.getInterceptors(advisor)
方法:获取MethodInterceptor数组
public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
// 声明变量
List<MethodInterceptor> interceptors = new ArrayList<>(3);
Advice advice = advisor.getAdvice();
/*
判断当前advice(增强器)是不是属于XX类型
*/
if (advice instanceof MethodInterceptor) {
// 如果advice(增强器)是MethodInterceptor类型(是我们需要的类型),则直接添加到interceptors中
interceptors.add((MethodInterceptor) advice);
}
// 如果advice(增强器)不是MethodInterceptor,则在循环中通过Adapter(适配器)将其包装成MethodInterceptor类型
for (AdvisorAdapter adapter : this.adapters) {
if (adapter.supportsAdvice(advice)) {
/*
里面的步骤:
1、通过advisor获取通知方法,强转为MethodBeforeAdvice/AfterReturningAdvice
2、return new MethodBeforeAdviceInterceptor(advice)/AfterReturningAdviceInterceptor(advice)
*/
interceptors.add(adapter.getInterceptor(advisor));
}
}
if (interceptors.isEmpty()) {
throw new UnknownAdviceTypeException(advisor.getAdvice());
}
// 将interceptors转换为MethodInterceptor[]数组,并返回
return interceptors.toArray(new MethodInterceptor[0]);
}
拦截器链(MethodInterceptor)获取+执行顺序
获取拦截器链的顺序 CglibMethodInvocation的**interceptorsAndDynamicMethodMatchers()**中的顺序一致。spring利用拦截器链来保证增强器(通知方法)的执行顺序。
步骤:
- 创建CglibMethodInvocation对象,调用它的==proceed()==方法。
- 调用super.proceed()。
- 判断是否获取了所有的拦截器,如果没有,则按顺序获取拦截器,并调用拦截器的invoke();如果已经获取所有拦截器,则调用反射机制调用被增强的方法。
- ==拦截器.inboke()方法调用mi.proceed()==方法 —> super.proceed() ||开始循环|| ==拦截器.inboke()方法调用mi.proceed()==方法 —> super.proceed() ············
代码单词解析:
- 拦截器中的.==invoke()==方法中的 mi = CglibMethodInvocation对象
注意:
- 获取到MethodBeforeAdviceInterceptor前置通知时会先执行。
this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
- 被增强方法会在获取完所有拦截器后执行。
return invokeJoinpoint();
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
// 声明一些变量
Object oldProxy = null;
boolean setProxyContext = false;
Object target = null;
TargetSource targetSource = this.advised.getTargetSource();
try {
if (this.advised.exposeProxy) {
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
// 获取要切入的目标类
target = targetSource.getTarget();
Class<?> targetClass = (target != null ? target.getClass() : null);
// 创建拦截器链
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
Object retVal;
// 检查我们是否只有一个InvokerInterceptor:并不是一个真正的通知方法,而只是对目标的反射调用。
if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
// 我们可以跳过创建MethodInvocation的方法:直接调用目标即可。注意,最终的调用者必须是InvokerInterceptor,所以我们知道它仅对目标执行反射操作,并且不进行热交换或反射代理。
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = methodProxy.invoke(target, argsToUse);
}
else {
// 创建一个CglibMethodInvocation来进行调用(重点!!!!!)
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
}
retVal = processReturnType(proxy, target, method, retVal);
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) {
targetSource.releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}
new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed()
方法:获取拦截器链并按顺序执行
public Object proceed() throws Throwable {
try {
// 调用父类的proceed();CglibMethodInvocation的父类是ReflectiveMethodInvocation反射方法执行类
return super.proceed();
}
catch (RuntimeException ex) {
throw ex;
}
catch (Exception ex) {
if (ReflectionUtils.declaresException(getMethod(), ex.getClass())) {
throw ex;
}
else {
throw new UndeclaredThrowableException(ex);
}
}
}
super.proceed()
=ReflectiveMethodInvocation.proceed()
public Object proceed() throws Throwable {
// 判断当前拦截器index是否与CglibMethodInvocation的拦截器List数组数量是否相同;如果相同,则调用反射机制执行被增强的方法
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
// 从CglibMethodInvocation的拦截器List数组中获取一个拦截器
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
// 判断拦截器是不是InterceptorAndDynamicMethodMatcher类型
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
// Evaluate dynamic method matcher here: static part will already have
// been evaluated and found to match.
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
else {
// 动态匹配失败。跳过此拦截器并调用链中的下一个拦截器。
return proceed();
}
}
else {
// 它是一个拦截器,因此我们只需要调用它的invoke()
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
获取拦截器之后执行拦截器中的通知方法和被增强的方法: