1.@EnableAspectJAutoProxy原理
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
/**
* Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
* to standard Java interface-based proxies. The default is {@code false}.
*/
boolean proxyTargetClass() default false;
/**
* Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}
* for retrieval via the {@link org.springframework.aop.framework.AopContext} class.
* Off by default, i.e. no guarantees that {@code AopContext} access will work.
* @since 4.3.1
*/
boolean exposeProxy() default false;
}
这部分主要是给AnnotationAwareAspectJAutoProxyCreator注册在IOC容器里面
@Import(AspectJAutoProxyRegistrar.class)给容器导入AspectJAutoProxyRegistrar.class
利用AspectJAutoProxyRegistrar自定义给容器中注册bean,注册了internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator. 的定义信息
其实@EnableAspectJAutoProx y就是给容器中注册了一个AnnotationAwareAspectJAutoProxyCreator
@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
BeanDefinitionRegistry registry, @Nullable Object source) {
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}
@Nullable
private static BeanDefinition registerOrEscalateApcAsRequired(
Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
---核心代码----
//定义RootBeanDefinition,装注册bean的定义信息 //org.springframework.aop.config.internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator
RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
beanDefinition.setSource(source);
beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
return beanDefinition;
}
上面定义RootBeanDefinition,加载注册bean的定义信息,然后注册org.springframework.aop.config.internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator. 在容器里面(只是注册了BeanDefinition,没有创建对象,创建对象在下一步)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WaG2cYDO-1642349415836)(/Users/laiyanxin/Library/Application Support/typora-user-images/image-20191126220112397.png)]
从类图可以看出AnnotationAwareAspectJAutoProxyCreator实现了后置处理器和自动装配BeanFactory
2.AnnotationAwareAspectJAutoProxyCreator注册
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
this();
register(componentClasses);
refresh();
}
refresh()中registerBeanPostProcessors(beanFactory)就是注册BeanPostProcessors
从上面类图可以看出AnnotationAwareAspectJAutoProxyCreator实现了BeanPostProcessors.
实现了BeanPostProcessors接口的实现类,调用通常分两部分,先注册,后调用.
这步主要是注册BeanPostProcessors,调用里面的实现方法在创建bean的时候
注册BeanPostProcessor实际上就是创建BeanPostProcessor对象的保存在容器中
具体逻辑
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
//1.获取ioc容器中已经定义好的需要创建对象的所有BeanPostProcessor
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
//2.给容器中添加别的BeanPostProcessor-》BeanPostProcessorChecker
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
--------省略了区分BeanPostProcessor的逻辑------------------
//3 优选注册实现了PriorityOrdered接口的BeanPostProcessor.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 4再给容器中注册实现了Ordered接口的BeanPostProcessor.
// AnnotationAwareAspectJAutoProxyCreator实现了Ordered接口
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String ppName : orderedPostProcessorNames) {
//ppName=internalAutoProxyCreator,从beanFactory获取
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
//7.把BeanPostProcessor注册到BeanFactory
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
//里面逻辑就是beanFactory.addBeanPostProcessor(postProcessor) 注册的最后一步
// 5再注册没实现优先接口的BeanPostProcessor.
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
//把BeanPostProcessor注册到BeanFactory
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
//6因为internalAutoProxyCreator没有在从beanFactory获取,所以需要创建internalAutoProxyCreator对象
//6创建的internalAutoProxyCreator的BeanPostProcessor就是AnnotationAwareAspectJAutoProxyCreator
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//6.1创建bean的实例createBeanInstance
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//6.2populateBean给bean各种属性赋值
populateBean(beanName, mbd, instanceWrapper);
//6.3initializeBean初始化bean
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
-----------------------------------
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
//6.3.1。invokeAwareMethods 处理Aware接口的方法回调
//里面创建AnnotationAwareAspectJAutoProxyCreator对 象
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//6.3.2 应用后置处理器BeanPostProcessorsBeforeInitialization
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//6.3.3invokeInitMethods 执行自定义初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
//6.3.4 应用后置处理器BeanPostProcessorsAfterInitialization
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
流程
-
获取ioc容器中已经定义好的需要创建对象的所有BeanPostProcessor
-
给容器中添加别的BeanPostProcessor-》BeanPostProcessorChecker
-
优选注册实现了PriorityOrdered接口的BeanPostProcessor
-
再给容器中注册实现了Ordered接口的BeanPostProcessor.
-
再注册没实现优先接口的BeanPostProcessor.
-
注册BeanPostProcessor实际上就是创建BeanPostProcessor对象的保存在容器中
这次创建的internalAutoProxyCreator的BeanPostProcessor-》AnnotationAwareAspectJAutoProxyCreator
- 创建bean的实例createBeanInstance
- populateBean给bean各种属性赋值
- initializeBean初始化bean
- invokeAwareMethods 处理Aware接口的方法回调
里面setBeanFactory创建成功AnnotationAwareAspectJAutoProxyCreator对象 - applyBeanPostProcessorsBeforeInitialization 应用后置处理器BeforeInitialization
- invokeInitMethods 执行自定义初始化方法
- applyBeanPostProcessorsAfterInitialization 应用后置处理器AfterInitialization
- invokeAwareMethods 处理Aware接口的方法回调
-
把BeanPostProcessor注册到BeanFactory
beanFactory.addBeanPostProcessor(postProcessor)
---------------以上是创建和注册AnnotationAwareAspectJAutoProxyCreator过程-----------
3.AnnotationAwareAspectJAutoProxyCreator的调用
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
if (mbd.isSingleton()) {
// 先从缓冲中获取当前bean,如果能获取到,说明bean是之前被创建过的,直接使用,否则再创建,主要创建好的bean都会被缓存起来,(单例才会被缓存)
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
}
-
遍历获取容器中所有bean,依次创建对象getBean(beanName);
getBean->doGetBean->getSingleton
-
createBean创建bean ,
BeanPostProcessor是Bean对象创建完成初始化前后调用的
InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回的对象AnnotationAwareAspectJAutoProxyCreator属于InstantiationAwareBeanPostProcessor会在任何bean创建之前先尝试返回bean的实例
- 先从缓冲中获取当前bean,如果能获取到,说明bean是之前被创建过的,直接使用,否则再创建,主要创建好的bean都会被缓存起来,(单例才会被缓存)
- createBean();创建Bean
- resolveBeforeInstantiation,解析BeforeInstantiation,希望后置处理器在此能返回一个代理对象,如果能返回对象就使用,如果不能就继续,里面流程在第四步
- doCreateBean,里面流程跟第二步2.6里面一样
@Override protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { RootBeanDefinition mbdToUse = mbd; //解析bean的定义信息 Class<?> resolvedClass = resolveBeanClass(mbd, beanName); if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { mbdToUse = new RootBeanDefinition(mbd); mbdToUse.setBeanClass(resolvedClass); } try { //解析BeforeInstantiation,希望后置处理器在此能返回一个代理对象,如果能返回对象就使用,如果不能就继续 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null) { return bean; } } try { Object beanInstance = doCreateBean(beanName, mbdToUse, args); if (logger.isTraceEnabled()) { logger.trace("Finished creating instance of bean '" + beanName + "'"); } return beanInstance; } }
4.AnnotationAwareAspectJAutoProxyCreator创建AOP代理
//1.在每一个bean创建之前,调用postProcessBeforeInstantiation
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
Object cacheKey = getCacheKey(beanClass, beanName);
if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
// 1.1先判断当前bean是否在advisedBeans中(保存了所有需要增强的bean)
if (this.advisedBeans.containsKey(cacheKey)) {
return null;
}
//1.2 isInfrastructureClass(beanClass)判断档期bean是否是基础类型Advice,Pointcut,Advisor,AopInfrastructureBean,或者是切面(@Aspejct)
//1.3是否需要跳过—》shouldSkip,永远返回false
if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}
// 判断是否有自定义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;
}
1.在每一个bean创建之前,调用postProcessBeforeInstantiation
-
先判断当前bean是否在advisedBeans中(保存了所有需要增强的bean)-》isInfrastructureClass
-
判断当前bean 是否是基础类型Advice,Pointcut,Advisor,AopInfrastructureBean或者是切面(@Aspejct)
-
是否需要跳过—》shouldSkip
@Override protected boolean shouldSkip(Class<?> beanClass, String beanName) { //需要获选增强器(切面里面的通知方法) List<Advisor> candidateAdvisors = findCandidateAdvisors(); // 判断每一个增强器是否是AspectJPointcutAdvisor类型,返回true\ // 每一个封装的通知方法的增强器是InstantiationModelAwarePointcutAdvisor类型,永远返回false for (Advisor advisor : candidateAdvisors) { if (advisor instanceof AspectJPointcutAdvisor && ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) { return true; } } return super.shouldSkip(beanClass, beanName); }
- 需要获选增强器(切面里面的通知方法)
List<Advisor>
,每一个封装的通知方法的增强器是InstantiationModelAwarePointcutAdvisor,判断每一个增强器是否是AspectJPointcutAdvisor类型,返回true - 永远返回false
2.创建代理对象
初始化调用postProcessBeforeInstantiation之前,再调用初始化后的postProcessAfterInitialization
- 需要获选增强器(切面里面的通知方法)
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
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;
}
//判断是否包含
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
//判断是否是基础类型的切面等等
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// 1.获取当前bean能使用的增强器,即通知方法
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
//2.保存当前bean在AdcvisedBeans中,
this.advisedBeans.put(cacheKey, Boolean.TRUE);
//3.如果当前bean需要增强,创建当前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);
return bean;
}
核心在于getAdvicesAndAdvisorsForBean
@Override
@Nullable
protected Object[] getAdvicesAndAdvisorsForBean(
Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
//1.找到可用的增强器(通知方法)
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
//1.1找到候选的所有增强器,即我们写的所有增强方法
List<Advisor> candidateAdvisors = findCandidateAdvisors();
//1.2获取到能在当前bean使用的增强器(即找哪些增强方法需要切入当前bean方法的)
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors);
//1.3 给增强器排序
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
上面流程
-
获取当前bean能使用的增强器,(通知方法) Object[] specificInterceptors
- 首先找到候选的所有增强器,即我们写的所有增强方法
- 获取到能在当前bean使用的增强器(即找哪些增强方法需要切入当前bean方法的)
- 给增强器排序
-
保存当前bean在AdcvisedBeans中,
-
如果当前bean需要增强,创建当前bean的代理对象
-
获取当前bean所有增强器(增强方法)
-
把所有增强器(保存到ProxyFactory
-
创建代理对象由spring自动决定
new ObjenesisCglibAopProxy(config);
new JdkDynamicAopProxy(config);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); } } //3,1获取当前bean所有增强器(增强方法) Advisor[] advisors = buildAdvisors(beanName, specificInterceptors); //3.2把所有增强器(保存到ProxyFactory) proxyFactory.addAdvisors(advisors); proxyFactory.setTargetSource(targetSource); customizeProxyFactory(proxyFactory); proxyFactory.setFrozen(this.freezeProxy); if (advisorsPreFiltered()) { proxyFactory.setPreFiltered(true); } //3.3创建代理对象由spring自动决定,给容器返回当前组件使用cglib增强了的代理对象 //Spring会自动决定使用jdk,cglib动态代理,也可以通过配置 //4.给容器返回当前组件使用cglib增强了的代理对象 //5.以后容器中获取到就是这个组件的代理对象,执行目标方法的时候,代理对象会执行通知方法的流程 return proxyFactory.getProxy(getProxyClassLoader()); }
-
-
给容器返回当前组件使用cglib增强了的代理对象
-
以后容器中获取到就是这个组件的代理对象,执行目标方法的时候,代理对象会执行通知方法的流程
5.目标方法执行
IOC容器中保存了组件的代理对象(cglib增强后的对象),这个对象保存了详细信息(比如增强器,目标对象,x x x等等)
执行目标方法执行会被CglibAopProxy.intercept拦截
//1.CglibAopProxy.intercept拦截目标执行
@Nullable
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
TargetSource targetSource = this.advised.getTargetSource();
try {
if (this.advised.exposeProxy) {
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
//2.根据ProxyFactory对象获取将要执行的目标方法拦截器链
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
Object retVal;
//3.如果没有拦截器链,直接执行目标方法拦截器链每一个通知被包装成方法拦截器,利用MethodInterceptor
if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = methodProxy.invoke(target, argsToUse);
}
else {
//4. 如果有拦截器链,把需要执行的目标对象,目标方法,拦截器链等信息传入一个CglibMethodInvocation并调用
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
}
retVal = processReturnType(proxy, target, method, retVal);
return retVal;
}
}
- CglibAopProxy.intercept拦截目标执行
- 根据ProxyFactory对象获取将要执行的目标方法拦截器链
- List interceptorList 保存所有拦截器,其中一个默认的是ExposeInvocationInterceptor
- 遍历所有增强器,将其转为interceptor
Interceptor[] interceptors = registry.getInterceptors(advisor) - 将增强器转为
List<MethodInterceptor>
,如果是MethodInterceptor直接加入到集合中,如果不是,使用AdvisorAdapter适配器将增强器转为MethodInterceptor, 转换完成返回MethodInterceptor数组
- 如果没有拦截器链,直接执行目标方法
拦截链就是把每一个通知方法包装为方法拦截器,利用MethodInterceptor - 如果有拦截器链,把需要执行的目标对象,目标方法,拦截器链等信息传入一个CglibMethodInvocation,下一步调用proceed()方法;
//根据ProxyFactory对象获取将要执行的目标方法拦截器链
@Override
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
Advised config, Method method, @Nullable Class<?> targetClass) {
AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
Advisor[] advisors = config.getAdvisors();
//2.1保存所有拦截器,其中一个默认的是ExposeInvocationInterceptor
List<Object> interceptorList = new ArrayList<>(advisors.length);
Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
Boolean hasIntroductions = null;
//2.2遍历所有增强器,将其转为interceptor
for (Advisor advisor : advisors) {
//核心代码,
Interceptor[] interceptors = registry.getInterceptors(advisor);
//将增强器转为List<MethodInterceptor>
interceptorList.addAll(Arrays.asList(interceptors));
}
return interceptorList;
}
//2.3.将增强器转为List<MethodInterceptor>,如果是MethodInterceptor直接加入到集合中,如果不是,使用AdvisorAdapter适配器将增强器转为MethodInterceptor, 转换完成返回MethodInterceptor数组
@Override
public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
List<MethodInterceptor> interceptors = new ArrayList<>(3);
Advice advice = advisor.getAdvice();
//如果是MethodInterceptor直接加入到集合中
if (advice instanceof MethodInterceptor) {
interceptors.add((MethodInterceptor) advice);
}
//如果不是,使用AdvisorAdapter将增强器转为MethodInterceptor
for (AdvisorAdapter adapter : this.adapters) {
if (adapter.supportsAdvice(advice)) {
interceptors.add(adapter.getInterceptor(advisor));
}
}
if (interceptors.isEmpty()) {
throw new UnknownAdviceTypeException(advisor.getAdvice());
}
//转换完成返回MethodInterceptor数组
return interceptors.toArray(new MethodInterceptor[0]);
}
- 调用proceed()方法,拦截器链的触发过程
- 如果没有拦截器执行目标方法,或者拦截器的索引和拦截器数组-1大小一样(指定了最后一个拦截器)执行目标方法
- 链式获取每一个拦截器,拦截器执行invoke方法,每一个拦截器等待下一个拦截执行完成返回以后再来执行,拦截器链的机制,保证通知方法和目标方法的执行顺序
@Override
@Nullable
public Object proceed() throws Throwable {
//5.1如果没有拦截器执行目标方法,或者拦截器的索引和拦截器数组-1大小一样(指定了最后一个拦截器)执行目标方法
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
//5,2链式获取每一个拦截器,拦截器执行invoke方法,每一个拦截器等待下一个拦截执行完成返回以后再来执行,拦截器链的机制,保证通知方法和目标方法的执行顺序
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
return dm.interceptor.invoke(this);
}
else {
return proceed();
}
}
else {
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
链式调用图
6.总结
-
@EnableAspectJAutoProxy开启Aop功能
-
@EnableAspectJAutoProxy给容器注册一个组件AnnotationAwareAspectJAutoProxyCreator
-
aAnnotationAwareAspectJAutoProxyCreator是一个后置处理器
-
容器创建流程
- registerBeanPostProcessors() 注册后置处理器,创建AnnotationAwareAspectJAutoProxyCreator
- finishBeanFactoryInitializatiom()初始化剩下的单实例bean
- 创建业务逻辑组件bean(我们写的业务代码)和切面组件bean(增强类)
- AnnotationAwareAspectJAutoProxyCreator的后置处理器会拦截组件bean的创建
- 组件创建完成后,判断组件bean是否需要增强
是:切面的通知方法包装成增强器(Advisor),给业务逻辑组件bean创建一个代理对象(cglib)
-
执行目标方法
-
代理对象执行目标方法
-
org.springframework.aop.framework.CglibAopProxy.DynamicAdvisedInterceptor#intercept拦截目标执行
-
得到目标方法拦截器链(增强器包装成拦截器MethodInterceptor)
-
利用拦截器链,依次进入每一个拦截器进行执行
-
效果
正常执行:前置通知-》目标方法->后置通知-〉返回通知正常执行:前置通知-》目标方法->后置通知-〉异常通知
-
-